MidCamp 2017

Emma Karayiannis

This session will help you navigate the great adventure of Open Source contribution.

Successful adventurers need to be prepared. How should you plan for your contribution adventure and what do you need to bring with you.

Learn about the hardships and challenges you will face along the way and how to avoid or overcome them.

You will be introduced to your adventure companions. Hear why you should never adventure alone and how companions can help you every step of the way.

Once you reach your first goal of no longer feeling like a beginner, you will be very eager to keep going. Which direction should you take next? There are many possible paths in front of you. Hear the opportunities available and how joining a project or a team will help you settle into the next stage of your adventure.

As the adventure advances Open Source contribution will become an ever increasing feature in your life. You start to take on more work, assume roles and responsibilities, and put more time aside for contribution. How do you manage all of this plus stay happy and healthy? We will end the session on how you can long continue with your adventure and look after yourself and others.

https://www.midcamp.org/session/great-adventure-open-source-contribution

Todd Zeigler

For most of the web’s short lifetime, the primary way to design a website has been to create wireframes and comps (design compositions) of a site’s key pages. This page-based approach is clearly broken. The proliferation of smartphones and the increasing complexity of the interfaces we create make page-based design extremely time-consuming. A relatively simple site can require 25+ page comps.

The last few years have seen designers move to a process that is more in tune with the way websites are actually built and function. They design overall styles and repeating elements that make up pages, instead of the pages themselves. This process is quicker, easier for front-end developers to implement, and provides maximum flexibility.

In this session we will:

Introduce the concept of design systems
Walk through real world examples of sites using this approach
Explain the design process for system-based projects
Walk through ways to implement the completed designs in Drupal

https://www.midcamp.org/session/design-systems-not-pages

Michelle Jackson
Bec White

Getting content ready for launch is tough for all involved, especially clients. They are often faced with two challenges - tailoring their content to audience needs and restructuring their content to align with the architecture of the new site.

It can take months for product owners to develop content, a process that relies on writing the content and managing internal feedback cycles from the CEO to program-level staff. Clients who envision a seamless transition between development and launch are faced with a mad dash of content entry, or a protracted pre-launch period where the development team is no longer available to respond to questions.

Many of the current solutions available to developers and content strategists pose problems as well. Allowing clients to access the development environment so they can add content as the site is built can introduce unexpected configuration changes and create duplicative work when developers need to make architectural changes to content types or taxonomy. Updating and restructuring content on an existing Drupal 6 or 7 site in preparation for migration can limit the client's ability to restructure content. It can also create missed opportunities for the client to update critical information architecture structures like the primary navigation and taxonomies.

We gave our client, AcademyHealth, a solution that we’re going to share with you today - an external content development tool (GatherContent) integrated with our Drupal 8 development process.

This approach allowed the client team to:

Restructure their old content and prepare new content well in advance of development. experiment and explore content hierarchy independent of design or technical implementation
Evaluate how their content and menu structure functioned within the site at the end of each sprint during development
Have a quick turnaround time between the end of development and the site launch
And allowed our team to:

Have open conversations with the client about content structure early on in the project
Confine client content to mutually-defined structure using content fields and templates
Make design and development decisions based on real content
Seamlessly migrate client-curated content to development environments using the GatherContent API with Drupal 8
IN THIS SESSION, YOU’LL LEARN HOW TO:

Use GatherContent to create content
Migrate structured content in conjunction with Drupal 8
Collaborate with clients in planning, structuring and curating content prior to development
WHO THIS SESSION IS FOR:

Content Editors
Developers/Engineers
Content Strategists
UX practitioners
Project Managers

https://www.midcamp.org/session/content-code-d8-case-study

Fatima Khalid

We will embark on a Pokemon adventure to learn Object Oriented Programming. We'll start out as new trainers, collect Pokemon, battle, and learn OOP concepts along the way.

You should attend this session if you want to learn some basic OOP concepts, need a refresher, or just want to have some fun! :)

We’ll cover the following topics:

What is OOP
Classes
Inheritance
Interfaces
Traits

https://www.midcamp.org/session/adventures-oop-object-oriented-programming

Adam Bergstein

Security is a principle concern for both enterprise and public sector websites. As site building shifts into Drupal 8, organizations are seeking applicable information on baking security into the process from the beginning.



This talk will explore some of the core and contributed solutions that help resolve problems that negatively impact the security of a Drupal 8 installation. We’ll review site building and architecture, and provide application-level hardening techniques for security topics like auditing, access control, phishing, authentication, encryption, and log management. As a final take-home checklist, we’ll give some high-level tips for improving the security of your DevOps processes and hosting environments.

https://www.midcamp.org/session/security-drupal-8-tips-and-tricks

Chris Rooney
Joseph Purcell

Resource allocation and project management in an agency environment is hard, and is one of the critical things you have to "get right" to run have a successful business. To make this process manageable, agencies have typically sold their services to clients in increments of no smaller than 40 hrs (the typical work week).

But what if your agency decides to break this model, and sell time to clients in smaller increments that are more closely aligned to the actual tasks at hand?

Well, of your supply / input still comes in increments of 40 hrs, but you then sell this resource in smaller increments, what you have is a situation where you need to commit to several different clients / tasks to effectively utilize the unit of supply you are dealling with.

Which adds a whole new dimension of difficulty to your resource allocation and project management challenge.

This talk will review one agency's answer to the "partial resource allocation" problem, and review the advantages and disadvantages of this approach.

https://www.midcamp.org/session/3d-chess-resource-allocation-and-project-management-partial-resources

Miranda Dumas

This session will combine basic terminology of project management with a simple yoga flow. Perfect for beginners of both practices, attendees will stretch both their minds and their muscles in a gentle workout. The session will include both basic terms as well as a walkthrough of a Project Manager's role, specifically regarding Agile methodology. Attendees are encouraged to wear comfortable clothing, and bring an open mind to both learning and a yoga break. You will leave the session with an introduction to agile project management and feel relaxed at the same time.

https://www.midcamp.org/session/project-management-and-yoga-not-such-stretch

Madison Major

Nobody likes a mess, so why embrace someone else's? Providing quality long term support has become a necessary evil needed by clients in our industry. Recurring support is becoming a major source of revenue keeping organizations in our community stable and afloat. When your organization designed, architected and developed the project, providing support is easy... but how do you engage potential clients whose current site doesn't adhere to best pracitces and was built by one of those "other firms"? This presentation is geared towards experienced project and account managers and outlines our organization's best practices and guidelines for:

1. Understanding a potential client's support need prior to gaining access

2. Structuring the technical and non technical ins and outs of a site audit

3. Sizing and selling a monthly support retainer

4. How to make your client, and their online presenece, look AND perform as desired

5. Tips for how YOU can support the support team when introducing another snowflake to the mix


https://www.midcamp.org/session/support-client-onboarding-eloquently-embracing-mess

Charley Pugmire

Drupal 8's Twig templating engine gives front-end developers and themers a powerful new tool for manipulating Drupal markup. But following Drupal's "Working with Twig Templates" guide to a T is likely to create a bloated theme codebase that is difficult to maintain. Instead, with a few small tweaks, we can take advantage of some of Twig's most powerful features to create a more concise and more semantic templating solution. This means more control over your CSS class names, markup that communicates a clear hierarchy, and an easily readable codebase(!!!).

We’ll steer away from regurgitating documentation and focus on strategies to help simplify the theming process. By the end of the presentation, you’ll see how it’s possible to create a custom field template with custom CSS classes and custom markup without typing a single line of HTML. We’ll also cover some additional tools that make Twig even easier to work with.

https://www.midcamp.org/session/talking-twig

Chris Rooney

We've all seen them. The Drupalcon / Camp photos featuring a sea of smiling white faces punctuated by an occaisional speck of color. The agency "team" pages displaying a grid of white male and female headshots, each offering a witty saying or interesting hobby, but with the leadership team invariably consisting of 2-3 white males.

The Drupal community has a diversity problem. And its not just the Drupal community, its the digital marketing space overall.

The digital agency space is completely whitewashed.

How did such a new and wide-open industry, built on the premise of technology as a great equalizer, allow this to happen? How can a group of people as open and affirming as the Drupal community still be so homogenous?

This session will explore the contributing factors to the diversity challenges faced by the Drupal community, and how those of us in the community who care about diversity can let our actions speak louder than words by actually affecting change in our agencies.

Creating safe spaces is not enough. Building diversity requires bold, often uncomfortable, action. Lets talk about how!

This session is appropriate for anyone working in a digital agency that is interested in fostering diversity.

https://www.midcamp.org/session/whitewashed-drupals-diversity-problem-and-how-solve-it

Drew Gorton

Great teams make the difference between success and failure, between big opportunities and stagnation, between having fun together and dreading work. Many of us have been on great teams and not-so-great teams. While they’re easy to identify once they’re running, building and running a great team might seem like a magical game of chance.

Great teams can be planned and designed, however. There is a lot of research on what makes certain teams outperform others, what motivates people and more

This session will cover the above and give concrete recommendations on how to build workplace structures to improve your team's performance and ways to select new team members that will add to your results.

https://www.midcamp.org/session/building-great-teams

David Needham

It all started when my friend told me about this end of workday survey he made for himself. Every day he answers the same 7 questions that help him wrap up his work and prepare him for the following day.

Around the same time, I heard about the Ivy Lee Method, a proven productivity technique that involves defining the most important things that need to be accomplished tomorrow. I adapted my friend's survey to accommodate the Ivy Lee Method, added gamification, and now I have a daily routine that has made a significant difference in my life.

In this session I’ll:

Discuss why the Ivy Lee Method works and share my experience.
Demonstrate the technique in a Google Form that you can copy.
Walk through alternative questions to ask yourself on the form.
Share techniques for staying on task throughout the day.

https://www.midcamp.org/session/peak-productivity-ivy-lee

Dave Vasilevsky

The new Migrate module in core is great for upgrading sites from Drupal 6 to Drupal 8. But it's useful for a lot more than just that! Migrate adds the power of any external tool to your content workflow.

Not every client is accustomed to using Drupal. Some clients might like Google Spreadsheets; others prefer Markdown files in version control. Using Migrate, you can let your clients use their preferred content building tools—even before you have a Drupal site ready for them! I'll talk about my experiences with several different Migrate-based workflows that we've used at Evolving Web.

There's already information out there about building migrations, but most of it focuses on very limited use cases: direct upgrades, or simple nodes. I'll cover many other bits and pieces you need for real-life migration projects, including:

Hierarchical menus
Paths and redirects
Multilingual data
Files and images
Merging multiple migrations
Writing custom migration sources and transformations
Figuring out why your migration isn't working
Attendees with some PHP experience will get the most out of this talk—but many parts will be interesting to site builders and project managers as well.

https://www.midcamp.org/session/migrate-all-things

Chris Panza

Have you felt lost in the Views interface, unsure of what it can do for you? Or have you heard about this great module, but want to know more? This session carries no expectations, and don’t worry, no coding is involved, nor is any knowledge of SQL either.

Views provides a wonderful, but sometimes tricky interface to output and organize listings of your content in infinitely imaginable ways. We’ll step the the critical parts of the interface including:

Field outputs
Filtering
Sorting
Relationships
Contextual Filters (that sounds fancy)
Different styles to display your listings
Paging
Other useful interface elements
The session will also provide realistic examples and how these interface elements are combined to create them. We’ll also discover some of the many extensions for Views to really create impressive outputs. This session is targeted for Drupal 8.

https://www.midcamp.org/session/your-first-24hrs-views

Matt Glaman

Drupal creates incredible digital experiences. Drupal Commerce lets you turn Drupal into a rich eCommerce experience for your customers.

Come learn how we've engineered Commerce 2.x to make it simpler to solve some of the hardest parts of eCommerce. Whether your products and orders are managed in Drupal, or remotely in another service, Drupal Commerce allows you to deliver the experiences you need to sell to your customers.

We will talk about the changes and features brought to the table in 2.x: stores, order types, checkout flows, customizing the add to cart form, and more. But we will also talk how organizations have used Drupal Commerce to meet their unique eCommerce needs at scale. Such as acting as a customer facing interface for enterprise subscription management, or being the front end to an existing ERP/PIM/OMS.

You do not need prior experience with Drupal Commerce to attend, but some familiarity with Drupal 8 and common challenges in eCommerce will help you get the most out of the material.

https://www.midcamp.org/session/using-drupal-commerce-rich-ecommerce-experiences

David Snopek

myDropWizard offers support and maintenance for Drupal sites that we didn't build initially. We've learned the hard way which site building mistakes have the greatest potential for creating issues later.

Before taking on a new client, we do an in-depth site audit looking for security issues and checking if the site follows best practices or has any problems that would make it harder to maintain the site going forward.

In 2016 alone, we did 64 site audits!

Looking at that many sites has taught us A TON about the most common mistakes that people make when building Drupal sites. Some of them were very surprising to us as experienced Drupal site builders!

In this presentation, I'd like to share the most common pitfalls we've seen, so that you can avoid making the same mistakes when building your sites!

NOTE: even though they might take a slightly different form depending on the version, most of these same pitfalls apply equally to Drupal 6, 7 and 8! There's bad practices enough to go around that you'll have something to learn regardless of which Drupal you use ;-)

https://www.midcamp.org/session/most-common-drupal-site-building-pitfalls-and-how-avoid-them

Doug Dobrzynski

With Drupal 8 came core configuration management. It's a magical unicorn that solves all the problems of putting admin configuration and all the clicky setup into code... Or is it?

This session will seek to answer whether or not configuration management is a magical unicorn (spoiler: it's not) and address how to get closer to the magical configuration management unicorn based on learnings from multiple projects.

During the Session We Will Cover:

Handling the gray area of content versus configuration.
Accounting for environmental differences (dev, staging, prod).
Automating the import of configuration.
Configuration management versus Features.
Developing standards and practices.
Tools to create the magical configuration management unicorn.

https://www.midcamp.org/session/magical-configuration-management-unicorn

Megh Plunkett

Perhaps your company or department is considering hiring an external vendor or agency to work on your next project. Maybe your group has already hired an external development team to supplement an internal team. Integrating your in-house Drupal team with developers from an agency or vendor can positively contribute to a project's success, but can also result in resourcing headaches, hidden costs, and unexpected project management overhead.

This session will highlight what to keep in mind while managing combined teams, how improve collaboration when adding external developers to an internal team, and how fostering the experience of a single team results in the ideal outcome. It will also cover mistakes project managers make with combined internal and external teams, how to spot communication breakdowns before they are unmendable, and provide helpful suggestions on how to mitigate issues.

Also included:

Preparing yourself and your in-house team to work with external developers
Increasing productivity
Ensuring smooth hand-offs and multi-vendor transitions
Resourcing internal and external developers
Managing roles and responsibilities
Note: This session's intended audience is project managers and team leads. The speaker is a senior front-end developer who has more than five years of experience specifically managing and working with many types of mixed teams in a developer capacity. She feels this fresh perspective on project management will offer new and different suggestions to collaboration and team success.

https://www.midcamp.org/session/successfully-integrate-teams-internal-and-external-developers

Jesus Manuel Olivas

Drupal 8 has changed a lot, and the process of building a Drupal site is not the exception.

During this session, you will learn how to use composer to improve your development workflow and reduce project setup and onboarding time, implement automated analysis tools for code review and code coverage and finally how to build and artifact and deploy your project.

Learning Objectives & Outcomes

Using Composer to manage project dependencies.
Applying Patches.
Adding and updating Drupal modules and third party libraries.
Overriding settings and configurations.
Managing configuration changes through the CLI.
Using Git to manage code changes.
Executing composer scripts to install Drupal, import/override configurations, install Drupal and/or import a database dump.
Execute code coverage and static analysis tools.
Build and artifact and deploy a project.

https://www.midcamp.org/session/improving-your-drupal-8-development-workflow

Panel Discussion

Burnout. It's not just a problem for core developers. It's something that all of us have to deal with, especially maintainers of open source projects!

Have you ever felt like you're drowning in your project's issue queues, swimming against a strong tide of vague bug reports posted by entitled users, or felt the temptation to delete all your public code to make it all go away? This session will be a panel discussion with several active contributors. We will explore the problems maintainers deal with on a daily basis, and equip you with tools to reduce the number of problems in the first place!

https://www.midcamp.org/session/just-keep-swimming-dont-drown-your-open-source-project

Mauricio Dinarte

Drupal is an extremely flexible system. To achieve this, various layers of abstractions were built into it. A lot of concepts were created to explain these abstractions. Unfortunately, they are not always intuitive. For example, the ubiquitous word 'node' does not represent a point in a network nor a server side programming language.

Learning the basic building blocks for assembling a Drupal site and how they relate to each other is useful to start building sites having a broad overview of the system.

Have you ever asked yourself any of these questions?

What is a node?
What is a content type?
What are fields and why are they useful?
What is a block and what can I do with it?
What is a view?
What is a module and its purpose?
What is a theme and how can it change the look and feel of my website?
How are users and permissions managed?
How can I create the navigation of my website?
Why does a kitten passes away every time I make a quick fix in the downloaded code? How can I prevent that?
Drupal 8 has been released and it ships with lots of cool new features. As you might imagine, it brings new concepts and more questions for beginners too. The Drupal community does not want new adopters and prospective contributors to go away for not understanding our parlance. Come to this session and figure out what Drupal is all about. Do not worry, it will not be a theoretical, boring talk. It will be a joyful conversation with lots of examples to help you understand Drupal and why it is so powerful.

See you there! :D

P.S.: The majority of the concepts that will be explained apply to Drupal 8 and previous versions. Those specific to Drupal 8 will be noted as such.

https://www.midcamp.org/session/understanding-drupal

Ryan Gibson

It’s a controversial subject, but Facebook Instant Articles, Google AMP, and Apple News are changing the way mobile web content is consumed. These services run parallel to what Drupal does best: managing content. They welcome and perhaps pressure sites to distribute content through their own platforms. Is this something that we, the Drupal community, should be concerned about? Should we embrace these new technologies and utilize them when it makes sense? If so, what are the implications for site content? Most importantly, how should we advise our clients when they ask us for expertise on these services?

Competing web standards and who controls traffic are polarizing issues. In this session, we're not only going to discuss the most popular competing mobile article content standards, but also get an overview of how they work, what solutions currently exist in Drupal to utilize them, what it means for developers, what it means for content editors, and the pros and cons of each technology.

This issue won't go away anytime soon—we, as a community, cannot let these technologies be overlooked as they continue to grow in popularity. Let the battle for mobile web traffic begin!

https://www.midcamp.org/session/facebook-instant-articles-google-amp-and-apple-news-why-do-you-even-have-website-anymore

Robert Huffstedtler

Drupal's core taxonomy system is substantially more powerful and flexible than those offered by most competing CMSes. Most site builders only scratch the surface of what it can do. In this presentation, we'll talk about what a taxonomy is, the use cases that a well thought out taxonomy enables, the reasons that Drupal's taxonomy system is so good, and the steps you need to take to define your taxonomy before you start trying to put it in Drupal. This session is aimed primarily at site builders and non-developer project stakeholders, but everyone should be able to get something out of it.

Many conversations about taxonomy start and end with what happens in the Drupal user interface. This session will describe not only the Drupal specific steps, but the overall methodology that one uses to develop the taxonomy.

This is an updated version of my taxonomy talk given at TC Drupal Camp in 2016.

Learning Objectives & Outcomes

Items covered in this presentation

What is a taxonomy?
What do taxonomies allow you to do?
Dynamic views of categories
Faceted search
Personalization
How Do I Build a Taxonomy
Content Sampling and Analysis
Stakeholder Worksessions
Testing and Revision
Educate and Tag
Why is Drupal Awesome for Taxonomy
Built in taxonomy capabilities
Fieldable terms and vocabularies
views integration
Contrib Modules: Taxonomy Manager
Features that Taxonomists want

https://www.midcamp.org/session/taxonomy-inside-and-outside-drupal

Brian Perry

Since the release of Drupal 8, great strides have been made to develop a component based theming workflow that takes advantage of the best that Twig has to offer and also plays nice with living style guides and pattern libraries. Gone are the days of redundant styles and markup, making way for the efficiencies found when Drupal and tools like Pattern Lab and KSS can share the exact same code.

While there are a number of great talks and resources on the basics of setting up this workflow, there hasn’t been enough discussion around the challenges that arise when you really put this approach through the paces. It’s time to find out what happens when component based theming in Drupal 8 stops being polite… and starts getting real.

This session shares real world experience related to:

Creating a workflow and theme structure using Drupal and Pattern Lab to build reusable components.
Managing complicated mappings between Drupal and your component library--both with core Drupal functionality and with the aid of contributed modules including Twig Field Value and UI Patterns.
Creating a component-friendly content editing experience.
Overcoming challenges with onboarding new developers who may not be familiar with this approach to theming.
Determining where to draw the line in order to avoid diminishing returns when streamlining Drupal’s markup and integrating with a pattern library.
Other common patterns that have emerged in component based theming projects.
Finally, we’ll also step back and take a look at the future of component based theming in Drupal. Both by looking at ongoing efforts in the community and also by considering some of the ways that these real world challenges could be addressed by future versions of Drupal or related modules.

https://www.midcamp.org/session/component-based-theming-real-world

Jeff Geerling

Learn from Drupal VM's maintainer how you can use Drupal VM to make your project's local development workflow stellar!

This session is targeted at intermediate Drupal developers who have used other tools, or even Drupal VM, to develop Drupal sites locally on their own workstations.

We'll walk through:

Where to go to get started and get help
Integrating Drupal VM into your project
Customizing Drupal VM to make your local environment perfect
Debugging and profiling code with Drupal VM
Using Drupal VM with a development team
After the session is over, you should be able to start using Drupal VM immediately, maybe even to build a production server!

https://www.midcamp.org/session/developing-drupal-8-drupal-vm

Tessa Kriesel

Life as a Mom (or Dad) can be hard without adding in the element of self-growth. It’s hard for us parents to take the time away and learn the things we want to know. So how do we make time for becoming better developers? By the time I have alone time, I either want to pass out or binge watch Friends on Netflix.

Shortcuts. It’s all about finding shortcuts and planning ahead. It’s amazing how much you can get done in 15 or 20 mins if you know exactly what you want to do. I have, somehow, found a way to be a mediocre mom, decent developer, active volunteer and a part-time dev instructor by organizing the hell out of everything I do.

What you can expect to get from this session:

A few laughs, likely at my expense
Some fairly decent organization tips
And hopefully some great ways to be a better developer parent person.

https://www.midcamp.org/session/mom-problems-how-manage-life-and-still-be-great-developer

George DeMet

Drupal has a long and rich history of supporting and sparking innovation. Drupal 8 in particular represents a fundamental shift in the way we think about how we build websites and web-enabled software applications. Now more than ever, Drupal is well-positioned to help connect people, technology, and information in ways that have never been possible before.

This session will draw upon existing academic research, interviews, and surveys to explore how different forms of contribution promote innovation within the Drupal project, and the role that companies, agencies, and organizations play in helping to support that innovation.

Some of the questions this session hopes to answer:

What are the different kinds of benefits that companies, agencies, and organizations gain from supporting Drupal in different ways?
What real and perceived barriers are currently keeping companies, agencies, and organizations from contributing to the Drupal project and community?
How can the Drupal community encourage companies, agencies, and organizations to contribute in ways that won’t undermine the intrinsic motivations of individuals?
What are some things that companies, agencies, and organizations can do to promote a culture of contribution within the Drupal community and support ongoing innovation?
This nontechnical session is useful for anyone who is part of a company, agency, or organization who uses and/or supports Drupal and is interested in learning more about how to justify investment and engagement in the community and project.

https://www.midcamp.org/session/supporting-innovation-through-contribution

Anna Mykhailova

Nowadays Drupal is not simply a CMS, it's a big and complicated framework that stands behind large enterprise level websites.

Drupal is used successfully for government, high education and healthcare websites that store large volumes of data. Often enough these organizations need their data to be updated over night, monthly or annually. It can be as simple as stock information updates performed once an hour and as big as update of all programs and courses offered by the college and university including all of the program details and costs.

Large scale complicated imports bring their challenges: time and hosting resources, parsing algorithms, different sources: XML, JSON, CSV. In my talk I'll cover some problems that a developer may face while building imports of data from various external sources into Drupal. I'll cover different formats such as XML, CSV and JSON, as well as approaches that can be used to make the task easier.

The audience will learn how to build imports with solid architecture so they would have less problems with performance as well as won't be limited by cron job time. I will also cover Batch and Queue APIs in Drupal 8 as well as touch base on continuous integration tool such as Jenkins.

The talk is for intermediate to advanced level back-end developers.

https://www.midcamp.org/session/large-scale-recurring-imports-drupal-8-architecture-and-implementation-tips

Jimmy Klatt
Jessica Larsen

The Paragraphs module is a simple and easy way for content editors to create stunning and unique pages. Separate from a WYSIWYG editor, this module offers the ability to split the content into configured components containing a multitude of widgets: photos, videos, maps, text blocks and more!

In this session we’ll explore the Paragraph module, and outline the process of creating and styling new Paragraph Types. We’ll conclude with a discussion of benefits and gotchas to begin implementing in your daily workflow.

Give this session a go if you’re looking to bridge the gap between content editors and site builders - creating more robust websites and introducing another approach to content entry flow.

https://www.midcamp.org/session/paragraphs-module-bridging-gap-between-content-entry-and-beautiful-layouts

Steve Persch

Many people in the Drupal community got into web development by building sites that they needed themselves. That experience of being your own client is a foundation that serves developers well when working with paying clients at work. As frontier of web development continues to shift toward more reliance on integrations with APIs, services, and the physical world, many developers feel out of their depth. A great remedy for this feeling is a return to being your own client.

This presentation will cover ways developers can experiment with the Internet of Things for their own benefit including:

Simple integrations with If This Then That.
Using consumer-oriented products like Hue lights.
Programming IoT frameworks and devices like Littlebits.
Interact with robots using JavaScript (Johnny Five)

https://www.midcamp.org/session/connecting-your-development-workflow-internet-things

Larry Walangitan

Now that Drupal 8’s theming engine is powered by Twig how can we grow our skills to meet the demand? Let's explore the extensions, design patterns and tools that Twig provides when we develop for Drupal 8. In this session you’ll learn about:

Choosing Twig over a decoupled front end for Drupal 8.
Registering custom Twig templates in themes and modules.
Using advanced filters, functions and tags in Twig templates.
Implementing and extending render arrays for performance and caching.
Advanced debugging of Twig templates and variables without running out of memory.
Understanding best practices in Twig templates and Drupal 8 theming.
Staying in the loop with the latest improvements to Twig.
You'll leave this session with an advanced understanding of Twig while also having a path to resolve unforeseen bugs encountered during development. This session will assume that you have a moderate understanding of Twig and Drupal 8.

https://www.midcamp.org/session/talking-about-what-great-about-twig

Chris Weber

The worst part about communicating is that when you need to do it the best, we're often at our worst. Tensions rise, tempers flare and then it's far too easy to fixate on "winning points" than resolving anything effective. I want to share with you what I've learned about these conversations, how they can be diagnosed, debugged, and optimized.

And also reveal to you how it's not usually what's happening on the other side of that kind of conversation that can be fixed. We'll talk about the things that are under your control: Your words and your body. And spolier alert: your body actively works against you at the precise moment you need everything to be working in harmony. We'll talk about how to recognize when that happens. We'll talk about a workflow you can walk through improve your recognition of when you or the other side are out of check and how you can walk a conversation back to constructive dialogue. And we'll talk about how to keep your goals in mind so that the emotion of the situation does prevent you from achieving them.

https://www.midcamp.org/session/crucial-conversations-tools-handling-difficult-conversations

Marc Isaacson

******************
NOTE: The presenter had a laptop incompatible with the recording equipment, so we have audio only. See the readme at https://github.com/vegantriathlete/oop-dp-d8
******************

With the switch to OOP and the inclusion of many parts of the Symfony framework, Drupal 8 has (finally) moved into the modern era of web development best practices. Let's have a look at how some of those best practices are being put to use within Drupal 8.

In this session I will walk you through:

Object Oriented Programming concepts, such as interfaces, abstract classes, (base) classes, dependency injection, services and more
Specific code examples of how Drupal 8 is using the aforementioned OOP concepts
Patterns that are prevalent in Drupal 8 (and that will help you get up to speed much more quickly once you know how to use them)
Whether you are a web developer who has never used Drupal or you are a seasoned Drupal developer who is concerned that all this new OOP stuff is just too hard, you'll want to attend this session so that you can see just how amazing and easy to use Drupal 8 really is!

https://www.midcamp.org/session/oop-design-patterns-and-drupal-8

Carie Fisher

We wear a lot of hats as front-end developers. Depending on the client or company you work for, you may be the designer, UX/UI specialist, site-builder, QA tester, and developer all rolled into one. How can we possibly add the accessibility hat on top of all that? What accessible pieces should we even include? Which pieces are easy wins vs. impossible juggernauts? How do we implement inclusive development when a project does not have a lot of time or budget to include that piece? One way we can tackle these issues is by using an accessible component driven approach. By thinking about inclusiveness from the start, we can get a head start on accessibility while still building the required site components.

While working as the Accessiblity Lead at Mediacurrent, I have developed a KSS node-based accessible style guide. The style guide comes with pre-populated accessible components that include helpful links to related tools and articles to make your site more inclusive. These components also serve as a guide for both HTML markup and SCSS/CSS code, to inform designers, front-end and back-end developers at every stage of the website’s creation.

Session Outline

What exactly is the role of a Front-end developer?
What, Who, and Why of Website Accessibility
What is Inclusive Development?
Why use Component Driven Development for Accessiblity?
Demonstration of KSS node-based accessible style guide - http://a11y-style-guide.com/style-guide

https://www.midcamp.org/session/inclusive-development-using-style-guides-improve-website-accessibility

Daniel Ficker

You have created a beautiful, shiny new Drupal web site or a stellar partner has created one for you. It is ready to launch and usually someone just hands it over to a server administrator or the DevOps team. Instead, this time you are the launch team. Don’t panic. This session will give you the knowledge to understand what you need to make it a smooth launch.

To launch, you need various pieces of information about domains, DNS, SSL and more. You then have to set these up correctly. If you do so, you should have a smooth launch of your new site.

Topics Covered

Gathering domain ownership information.
Setting up DNS records or getting DNS changed smoothly.
Requirements and recommendations for SSL encryption and implementation.
Evaluation of hosting requirements and hosting options.
Considerations from moving from an old site to a new site.
My Experience

This session is based on the presenter’s 12+ years of building, launching and maintaining dozens of websites both freelance and at a design/development agency. From launching a brand new site to moving an existing live site from one server to another, I have launched hundreds of sites on various hosting environments.

https://www.midcamp.org/session/321-launching-your-site

Tim Erickson

As an open source project, there is something inherently political about participation in the Drupal Community. Those of us who contribute to Drupal through code, testing, writing documentation, or planning Drupal events are making a conscious decision to contribute towards the creation of a public good that is used by individuals, non-profits, educational institutions, and multi-national corporations alike. Many of the most active members of the Drupal community got their start in Drupal by building a website for a school, arts organization, political campaign, or a non-profit organization. We were drawn to Drupal, not only because the code was free, but because of the welcoming community that answered our questions online or took time to work with us one on one at a Meet-Up or Drupal camp.

Let’s talk about the political implications of using and developing Drupal?
How does Drupal fit into the larger landscape of open source software, the free software movement, and growing concerns over privacy and government data?
How do we continue to ensure that Drupal is not only affordable but accessible to the small non-profits and organizations of change
In this session we’ll provide some background and context, but we want to hear your thoughts and experiences on this topic.
The title of this session is borrowed from a blog post by Matthew Tift from Dec 2016.

https://www.midcamp.org/session/drupal-political-act

Chris Hamper

More and more frequently, Drupal is being connected to external systems via APIs. Phone apps, decoupled frontends, and other sites or services all might need to consume your content. How do you get your data where it is needed with a minimum of fuss? This session will introduce you to the JSON API standard, its advantages, and how it can be used to pass data between systems. The focus will be on integrating a JavaScript application with Drupal, but the knowledge will be applicable to many other use-cases.

https://www.midcamp.org/session/getting-your-content-where-you-need-it-json-api

Luke Wertz

If you’ve ever used a styleguide, chances are you used one styleguide for one website. But what happens when you have one styleguide and more than one website? In this session, I’ll show how my team turned a styleguide for a large government project into a dependency of the website rather than a deliverable of the website. You’ll walk away from this session with a framework for thinking about styleguides and how to use them in a CMS-agnostic way (using tools like Pattern Lab, Twig, Semver, Drupal) to support a multi-channel (or multi-site) publishing platform that is all styled from a single project. I’ll also cover some basic implementation strategies and touch on tools, so you’ll have practical next steps if you want to try this out yourself.

https://www.midcamp.org/session/your-styleguide-api

Peter Sawczynec

Maximize the advantages of caching and ensure your Drupal 8 websites are performant. Get the technical information you need to handle caching in Drupal 8 now.

Caching is arguably one of the most important aspects of developing a high-performance, enterprise Drupal 8 website.

In this fast-paced, information-filled session you’ll quickly get solid details on caching, why it is important, what it does and how to employ it, including:

Caching Concepts
Caching Basics
Drupal performance settings
Drupal caching modules
D8 caching primer
Varnish .vcl
HTTP Cache headers
Surrogate Keys
Cookies and Caching
HTTP/2
Caching API call results
Browser and Proxy caching
Other technologies to use in tandem with caching: CDN, AJAX, ESI, Cron
When this presentation is complete the developer will have the knowledge to handle caching for Drupal 8.

Aimed at busy, intermediate and advanced Drupal developers, this session offers developer-centric, real-world caching information and techniques for Drupal 8 with tips and information you can put to immediate use and boost your website performance.

https://www.midcamp.org/session/drupal-8-caching-developer%E2%80%99s-guide

Chris Haynes

Have you ever gazed at your screen wondering why your most recent edit is not showing up on the page. So to try to pinpoint what is happening you put 20 print statements in your code hoping that one would show up on you page to let you know where to start your decent into debug land. If this sounds familiar I am here to let you know that there is hope. I was once in the same position.

There have been a few things to help me along my long daunting development process. The first among a long line of improvements in my development world has been the inclusion of PHPStorm and Xdebug.

PhpStorm is a popular IDE growing within the Drupal world, it is utilized by the Acquia development teams and provides native support for Xdebug. Xdebug is a PHP extension that was written and is maintained by Derick Rethans. It provides debugging and profiling capabilities.

With it you can set a breakpoint and pause the execution of a script to see the state of your application at that exact point, including what variables/objects have been instantiated and what their values are.

Xdebug replaces the need to litter your code with echo, print_r() or var_dump() calls, and displays information on all variables. It also allows you to change the values of one or more variables on the fly, affecting the execution of your application.

When the two noted above are combined together you Drupal development and debugging skills will grow to great lengths. This is where I come in. I can help you setup PHPStorm for development of Drupal as well as show you how to setup Acquia Dev Desktop to include Xdebug. Towards the end there will be a section on how you can setup Xdebug when your development environment has been built outside of Acquia Dev Desktop. Some examples may include, using straight DrupalVM, with or without any other helper programs like BLT. and if there is enough time, how to do it by hand.

One HUGE note, is that you do not want to have Xdebug running on production servers.

For most of the developers attending, your environment may already be setup for you, but if you are anything like me, you may have been pushed into an environment that did not have Xdebug installed.

Learning Objectives & Outcomes:

How to setup PHPStorm for Drupal Development
How to setup PHPStorm to use Xdebug
How to setup prepare Acquia Dev Desktop to include Xdebug
How to setup DrupalVm to include Xdebug
How to Manually setup you development environment to include Xdebug

https://www.midcamp.org/session/drupal-development-phpstorm-and-xdebug

Alex Dergachev
Dave Vasilevsky

Figure out how to make your Drupal backend load faster!

Is your site too slow? The first step to a diagnosis is to analyze front-end performance, which usually reveals under-optimized images, excessive ads, or ineffcient javascript scripts as the main culprits. But often you also will find that the page generation time is over a second, and will wonder where to go from there.

Core Drupal developers already use performance analysis tools like XHProf and Blackfire.io to keep the code efficient, but generally a combination of too many contrib modules, inefficient database queries, or poorly written custom code can easily bloat the page's loading time by a factor of 3 or more. This session will provide you the understanding you need to use these tools, and provide a number of real-world case studies in how to use them to identify common performance bottlenecks, and potential remedies.

We will also discuss ongoing performance monitoring with tools like Blackfire and New Relic.

The examples will be presented from Drupal sites, but the tools are PHP specific, while the lessons apply to most web application programmers. The target audience is PHP developers with experience writing and debugging custom code.

This talk builds upon our Blackfire talk at DrupalCon New Orleans with additional techniques and case studies.

https://www.midcamp.org/session/using-blackfire-profile-your-loading-time-0

Michael Porter

How can we use the power of Continuous Integration (CI) servers for offloading some of the repetitive tasks developers and software maintainers need to do on a daily basis? Things like running core and module updates, unit tests and reporting can be automated, and communicated using a few tools I will outline in this presentation.

In this session, I will demonstrate how to use Jenkins, the leading open source automation server to:

Run Drupal core and module updates
Run and report on behat tests
Run and report on Coding Standards
Trigger Offsite backup of production sites
Use Jenkins Pipeline workflows to build branch/feature based servers.
Triggering jobs with webhooks
Report progress, and results to Slack

https://www.midcamp.org/session/butler-did-it-putting-jenkins-work-you

Dwayne McDaniel

We Are All Making This Up: Improv Lessons For Developers There are a lot of parallels between the open source development world and Improv communities. The goal of this talk is to expose the similarities and directly apply the core principles from the stagecraft of improv to get better code, smoother projects and ultimately happier customers. At the end the audience will be able to take practical examples and very simple exercises back to their organizations to better communicate with customers and internal stakeholders alike as well as techniques to get ‘unstuck’ when hitting major blockages in creativity needed for elegant code.
Topics will include: Parallels between the Dev Community and Improv Core principles of Improv and how we can embrace them for better code, including - Active Listening -Yes, And… -Embracing failure as part of the process Simple group exercises for any size team to improve communications

https://www.midcamp.org/session/we-are-all-making-improv-lessons-developers

Amanda Grayson
Yujin Gu

This session will increase attendee’s understanding of UX research and design with the goal of improving the usability, accessibility, and experience of interactions on their site or product. We will focus on conveying the power of user driven design through specific examples. Come learn how using UX design thinking can boost your clarity, productivity, and success when building or revamping a website or product.

Our session will include:

Overview of UX and usability research for goal driven design

Understanding of why UX and usability is so important

Psychology’s influences on UX principles

Heuristic Analysis principles basis in psychology and neuroscience

How to increase the usability of your site or product through usability testing

https://www.midcamp.org/session/fundamentals-ux-design-and-usability-0

Gabe Sullice

With Drupal 8's radically different architecture, the testing story has been completely overhauled. Over the past year, I've had the incredible opportunity to program for Drupal 8 and solve many interesting problems. Along the way, I've learned how to write practical and efficient tests. What I've discovered is that those tests have made it easier to work in a team, make me feel more confident about the code I write, and make my code easier to change as project requirements evolve. In short, they're more than worth their investment. In fact, they make me even more productive where it matters.

In this session, we won't presume that you've done a lot of automated testing—or any at all. We won't wring our hands over behavior-driven or test-driven development. We'll discuss the how and the why from the get-go. We'll clear as many obstacles as we can. We'll learn from my mistakes (and maybe from my successes). And by the end, hopefully you'll have the tools to start your own journey toward testing Drupal 8 simply and efficiently (read "cost-effectively").

Specifically, you'll learn how to extend Drupal's testing classes like UnitTestCase, KernelTestBase, and WebTestBase to test your custom applications from top to bottom. With those tests in place, automated testing on every git push and testing against your team's PRs will be within reach.

This presentation is an intermediate track because you'll need to be familiar with PHP and be familiar with some Drupalisms. Bonus points for some Drupal 8 knowledge, especially familiarity with Drupal's service/controller/plugin concept, however this is not required.

Like so many Drupal developers, I started my professional programming career by building Drupal sites, writing custom modules, and contributing where I could. Unfortunately, that path never exposes one to the art of testing. Before Drupal 8, testing was prohibitively difficult and costly. Outside of core and the most used contrib modules the value of testing didn't seem to outweigh the costs. Without a mentor and/or lots of time to spend learning—one would probably never get the chance to become familiar with the practice of automated testing. Or, so I thought.

https://www.midcamp.org/session/testing-brave-and-true