One of the key strengths of Drupal is its flourishing ecosystem for contributed modules. Best of all, you can jump in and add yoour own module! All you really need is a good idea, though of course some programming knowledge, understanding of Drupal coding standards, and a few other technical things would help.

This talk will focus less on how to write code or what code you should write, and more on the process of creating a module, submitting it on Drupal.org, and getting it adopted by the community. We'll touch on such topics as:

• Looking for similar modules that already exist
• Getting help from the community
• Submitting your module - sandbox or full project?
• Getting the word out

You'll hear about the firsthand experiences in developing Smart Date, which went from an idea to one of the top 500 most popular modules on drupal.org in less than two years.

At Drupalcon Global Dries announced Automatic Updates as 1 of 5 strategic initiatives for Drupal 9.

Automatic Updates is an existing initiative that has already produced a contributed module that can provide updates for non-Composer based Drupal 7 and Drupal 8 sites.

The next phase of the initiative is to add support for updates of Composer based sites to Drupal 9. Currently the initiative is focusing on moving update readiness checks and other supporting functionality from the contributed module into Drupal core.

Learn about the initiative and how you can help

Previously, the main way to contribute source code changes to a Drupal project repository was through the patching process. In November 2020, a new and different workflow became available, similar to what open-source contributors commonly use on sites like GitHub.

We'll walk through the basics. There will be a demo followed by Q&A.

Our Devops process at UCSF Web Services team has needed a significant makeover for some time.   We took on the herculean task of upgrading our process using the latest workflow software from Github.   We dive into our process, discuss how we improved it and talk about the various tools we added along the way for a complete DevOps workflow.  We will show you how we use Git Flow and Tag Based Deployments with all our development teams and projects.

In 2017, a national nonprofit focusing on social justice and environmental sustainability embarked on a 18-month process to convert three different platforms into one consolidated website. 

As director of digital products during this conversion, I'll share lessons learned from the buildout including: the RFP and vendor selection process, an assessment of our user roles and permissions, the content structure, and a review of integrations with external systems. 

We'll discuss additional considerations for how to hold space for multiple viewpoints, as well as how to implement a respectful, open, and transparent process for all stakeholders.

Details of the case study are here: http://bit.ly/enviro-nonprofit-drupal

Link to slides: http://bit.ly/drupal-case-study

Have you or your organization fallen victim to one of the classic website blunders? Was it organization by board member, stock photo syndrome, design by committee, vanishing volunteer web developer, or something else? We will discuss 10 classic website blunders we have witnessed that rendered potentially successful projects ineffective engagement tools, and tell you how to avoid them.

Takeaways:

• Identify common mistakes that associations make when designing a website.
• Decide how to align your website with your organization's goals.
• Find out how to categorize your target audience.
• Determine how to identify an appropriate website ROI (Return On Investment).

Running Kubernetes on your laptop is one thing, but running it in production requires a lot of thought and considerations for the planning and execution of the project.

Voice of America runs many new sites around the world. These are very large sites that are designed to handle millions of hits a day.

In this panel, the VOA team will talk about their experience in migrating their sites and infrastructure over to Kubernetes.

Topics of discussion will cover:
1 Getting started with Kubernetes
2 Tooling up for production - things to watch out for...
3 Learning Curve - skills required for management, support, etc.
4 Dev, Test, Live Environments - what’s involved
5 Deployments - application and Kubernetes deployments
6 Technical considerations - for scaling, logging, monitoring, etc.
7 Cost Management - track and limit costs per site and per project
8 Security, Support, and SLA - what’s expected and how to address it
9 Contingency Planning - for loss of data center / access / Fail-over / Fallback
10 Day 2 Ops - Kubernetes upgrade/updates and patches / Backups and restores

We’ll conclude by summarizing what the team was expecting going into the project, what they learned on their journey, and what advice they can confidently share with others to help them with their journey to Kubernetes.

Composer - The dependency management tool for PHP applications is a complete feature rich package that addresses a lot of development and deployment problems. Unfortunately, most of the developers only get to know about the basic usage of it(Example: Running commands like ‘composer require drupal/MODULE’, ‘composer install’, and ‘composer update’).

One such lesser known-and-used feature out of many is integrating ‘scripts’ in the composer workflow of your web application. In this session we will cover the following sub-sections of composer scripting:

• Composer events
• Composer scripts
• Registering and executing scripts on composer events
• Composer commands
• Registering & Executing custom composer commands
• • PHPCS
  • PHPCBF
  • PHPUnit
• Referencing scripts

The above topics and their working examples will significantly help you understand how development and deployment teams can work together in simplifying the build process And thereby demystifying the know-how of one of the many powerful features of the composer called composer scripting. 

If you are a junior Drupal developer, you might be looking to find a mentor. If you're a senior Drupal developer, you may be looking for a mentee. If you're neither, you might be wondering where mentorship fits in your career–if at all.

It's no surprise, however, that a powerful mentor/mentee relationship can fast-track you toward rapid career/company growth. But if you went to find a mentor today, would you know what you need from the relationship?

Let's take some time to dive into mentorship as it relates to Drupal and engineering, and how you can get started discovering your next mentor/mentee as soon as possible.

Walk away learning more about: 

• Why mentor/mentee relationships are so important 
• Tips, tricks, and resources for improving your mentor/mentee relationships
• How to overcome common Drupal & engineering mentorship obstacles

So, if you want to help bring out the best in people, let this talk support you in learning how to guide others–and yourself–to succeed. 

Not a coder? That’s perfectly fine! There are many ways to give back to the Drupal Project.

Join us for a contributions overview. We'll talk about the many ways to give back beyond code and documentation.

Not everyone who works on open source projects is a developer. Smaller tasks help the less experienced gain confidence and experience, which, in turn, leads to more contributions. Code is very important, but so are all the other parts.

Composer is a package manager that alleviates the complexity of dependencies in PHP based projects (such as Drupal 8/9). This session provides an introduction to the core concepts behind package management and Composer.  No previous knowledge of Composer required. 

Using practical examples as guidelines attendees will learn the basics of Composer, including:

• What composer is and the concepts of how it works.
• How to add composer to a project and packages to a project.
• Semantic versioning patterns for packages.
• General Do's and Don'ts when using Composer.

Attendees will leave this session with insights and basic knowledge of Composer. Including knowledge of how it works, the value it provides to projects and how to use it on any (PHP  based) project.

Introduction to creating and reviewing patches with AmyJune Hineline

2:00 - 2:20 pm ET

Harmonize design and development by working with the latest module for Drupal’s Bootstrap Layout Builder to increase UX efficacy. Mahya, Aaron, and Mahmoud share the 5 guiding principles for designer-developer collaborations to bridge gaps. Learn more about core collaboration challenges, how to approach them, and component-based designs.

Ever wanted to learn about Drupal plugins as a module developer? Ever wondered what makes Drupal plugins work or why they’re useful? Well, literally every Drupal 8 module uses the Drupal plugin system! At their core, plugins are extensible bits of functionality. They are in YAML files, in Annotation classes, in hooks, and/or can be defined statically. Plugins can also have a custom discovery mechanism. Just create a custom plugin discovery class and use a plugin manager service.In this tutorial, you will learn:

• How to use Drupal plugins
• How to create new plugins
• Why choose to use plugins

We will also explore plugin discovery, plugin decorators, plugin management, plugin derivatives, and plugin definitions. You'll learn how to wrap functionality around the main Plugin discovery class with a Plugin discovery decorator. Using a Plugin decorator, you can provide or alter existing configurations, and/or provide multiple discovery methods. Plugins are in many places and are crucial to every module in Drupal. Having a hard time thinking about what plugins already exist in Drupal? There are quite a few!

• Some YAML plugins include routing, menu links, libraries and permissions
• Some Annotation plugins include blocks, field types, actions, entity reference selections, content and configuration entity types

As you can see, Drupal Plugins are almost everywhere you look! I want to take you on a cosmic adventure into the Drupal Plugin universe. Please come with me.

This panel will kick off the day by talking about what DevOps is bringing different perspectives to the conversation.  

Topics of discussion will cover:

• What is DevOps? 
• What are the business impacts of getting DevOps right or wrong? 
• What are the challenges in implementing DevOps? 
• What are some key things to focus on

Are you new to the Git workflow? Is the concept of version control sounds awesome but initimidating? Do you feel like Git would improve your development workflow but don't know where to start?

If this sounds like you, join me for this crash course into Git from the beginner to ninja. We will talk about using Git in the command line like a pro and cover most popular workflows, essential commands, and bonus tips and tricks that will improve your develpment workflow.

This session is great for beginners but intermediate users may also learn a few new tricks!

Github Actions enables you to create custom software development lifecycle workflows directly in your Github repository. These workflows are made out of different tasks so-called actions that can be run automatically on certain events.

This enables you to include Continues Integration (CI) and continuous deployment (CD) capabilities and many other features directly in your repository.

In this session, we are going to look at the core concepts of Github Actions and even dive into creating your own custom workflows to use Github Actions to run a basic build, lint, and deploy the changes to a Digital Ocean droplet.

The session will cover the following areas

• Why care about Github Actions?
• Core concepts of Github Actions
• Using workflow and action templates
• Configuring a workflow
• Running a workflow

A general space to work on Drupal issues not tied to the three initiatives. 

General Contributions - Simplytest.me

Interested in giving back to Drupal and need some help getting the tools on your local machine?

Join Mathew Radcliffe, Drupal Core mentor, and Randy Fay from DDEV to get your local Drupal environment set up to begin working on contributions.

Visit Setting up an environment to test Drupal patches and merge requests for more information.

One question many of us have heard or had when we were getting started as web developers and/or entering a new role is a very simple “how do I deploy my site?” We’re often tied into vendor defined workflows, and literally just go with the flow, or are presented with solutions with very complex projects as the baseline. What if you wanted to evaluate the options objectively? What if you want to build your own workflow? What are some best practices? What are the basics of deploying a site?

In this session we’ll give a high level view of how to work with a Drupal project in this workflow:

• Initial project creation using vanilla Drupal Core, setting up a Git repository, and a local development environment.
• How to use Git to collaborate with a team and protect your work.
• How to share your work in progress with team and stakeholders. 
• How to use continuous integration and deployment (CI/CD) to regularly test and deploy your work.
• What you need to do to move a site from local or preview to live deployment.

When you leave the session you should have a grasp of the pieces of the process and how they fit together regardless of the specific tool or vendor you may use at each stage. You’ll understand how you can put together a workflow that works best for your projects, your team, your students or your clients.

We all want our websites to be resilient, fast & easy to work on but sometimes you inherit a project that’s not any of those things.  Version control is murky or non-existent. Core is way, way, way, waaaaaay out of date.  The documentation on the project hasn’t been touched in about 17 months, and there are multiple views named “Article”. Yikes.  

You may not know how you got into this mess, but I’m here to help you find your way out.  You too can gracefully inherit even the messiest legacy project and leave it better than you found it. 

So many talks on best practices start from a blank slate; a brand new project where *this time* you’ll finally do everything right from the beginning.  This talk focuses on what you can do on all the *other* projects you have: the ones with no budget for a rebuild, the ones that are short on time and long on requirements. You know the type.

Rather than diving into detail about which automated test suite to implement or how to name your views, this talk gives some principles to guide you as you untangle that spaghetti code one noodle at a time.  

Learning Objectives

After this talk, attendees will be able to: 

• Diagnose the factors that cause instability and uncertainty for an adopted or legacy project.
• Create an action plan for how to improve that project.
• Use that plan to reduce instability and increase project performance.

Target Audience

The ideal attendee for this session is a developer or technical project manager who is responsible for working on a legacy project and wants to add some structure to that project.  It should be a good fit for a developer who is looking to make the move to a senior or lead role.

Prerequisites

Intermediate Drupal knowledge will be helpful, though not required.  The concepts covered will apply beyond Drupal, but the language and examples will be Drupal-focused.

In this session, we’ll give you an in-depth case study that guides you through the UX, visual design, and development process we followed to create a new digital home for Princeton University’s School of Public and International Affairs.

Our goal was to migrate the school to Drupal 8, while implementing a completely new information architecture, visual framework, and content strategy that better speaks to the core audiences of the school: potential students, the press and policy makers, and current students and staff. We’ll show you how we assembled a team and worked together to gather research, create a strong UX strategy, and build a newly architected site in Drupal 8. Evolving Web’s Drupal Practice Lead and Content Strategist Suzanne Dergacheva, and the School of Public and International Affairs' Web Services Manager John Cloys, will explain the tools and methods they used throughout to get input from stakeholders and users.

We’ll cover the following topics:

UX & Strategy

• Answering the “Why?” - the goals of the project and the goals of the School
• Persona validation and prioritization - gathering input from stakeholders and real users
• Gathering and sorting content
• Usability testing and interpreting the research
• Information overload: using personas as a lens to prioritize, remove, and rewrite content

Design

• Visual approach: creating a visual identity for a school within a school
• Researching higher education best practices
• Building a style guide for flexible content components

Development

• Migration strategy: workflow for a combined manual and automated migration
• Integrating with Princeton: events, single-sign-on
• Building a maintainable platform: developing with the site maintainers in mind

Process

• Collaborating on content and design in parallel
• Accessibility as a priority throughout the process
• Tools and techniques for project success

During this presentation, the simplytest.me team will not only share a timeline of events dating back to the origins of SimplyTest.me, but we will present our gradual modernization efforts and the status of each. AmyJune will highlight the mission for the project and talk about our efforts for outreach and fundraising. James will discuss how TugboatQA is used to power the SimplyTest.me backend. Matt will share an update on the new Drupal 9/React architecture. Finally, Adam will finish with insights on the future of the project.

• Adam Bergstein
• James Sansbury
• AmyJune Hineline
• Matt Glaman

React.js is one of the top players in the JavaScript libraries world. This session aims to explain the basic concepts of library outside of the context of any particular CMS implementation. Throughout the presentation, a static site will be converted into a dynamic React.js application. Many examples will be presented to help you understand how it works and why it is so powerful. No previous experience with React.js is required. Basic familiarity with HTML, CSS, and JavaScript syntax suffices. You will learn about:

• How to integrate React.js into an existing website?
• What are elements and components?
• What is JSX and what about separation of concerns?
• How to reuse components?
• What are props, states, hooks, and proptypes?

Join us after the first-time contributions workshop for some mentoring time to help folks get onboarded for contributions.

Are you losing sleep, worrying about your Drupal site’s security? That isn’t healthy! With Drupal being used for building websites and applications in government, non-profits, higher education, and corporate enterprises, it is important to make sure that projects follow regulatory and organizational security controls. Are you ready to learn how to take immediate steps to improve the security of your Drupal installation? Great, let’s get get started.

This session will provide the details you need to create a security-first plan to enhance Drupal’s strong security foundation with community-contributed modules. Attendees will learn how to leverage these community contributions to ensure Drupal’s ability to provide confidentiality, integrity, and availability for your users.

Drupal core and contributed module security enhancements will be demonstrated live. These demonstrations will show how to address many of the concerns listed in the globally recognized OWASP Top 10 Web Application Security Risks document. In addition, attendees will learn how to keep up with official security announcements from the Drupal Security Team, understand Drupal security advisories, and find resources to learn more about Drupal security.

Security risks and improvements covered

• Attack surface reduction
• Broken Access Control
• Cross-Site Scripting XSS
• Insufficient logging & monitoring
• Password policies
• Security misconfiguration
• Using components with known vulnerabilities

UC Davis has a variety of automated tools in place for workflow and testing. In this session, we dig into some of our more successful implementations.

• Shawn DeArmond
• Mark Miller

General Contributions - Drupal Recipes

Drupal Recipes Project Page: https://www.drupal.org/project/drupalrecipes

Documentation: https://www.drupal.org/docs/extending-drupal/drupal-recipes

Website: https://foxvalleydrupal.org/drupal-recipes

In this session we will cover:

Engineering:

• Why Vue.js and how it helped with performance and privacy
• Utilizing Drupal to overcome 3rd party API shortcomings
• Performance measurements, scalability

Project Management:

• Coordinating with multiple vendors on tight deadlines
• Managing 4 internal teams
• Implementing Risks and Decision Log

Short summary:

Palantir.net had a 10-week timeline to design and build their online conference platform from scratch. The client assembled a team of top-tier vendors and partners, with Palantir as the technical lead. Our role was to: 

• Implement a Drupal 9-centric solution that would sit nicely with their existing technology stack, leveraging style guide elements and enhancing their web marketing infrastructure.
• Evaluate and make recommendations for the best third-party technology solutions for video streaming, one-on-one session management, feedback systems, sponsorship systems, and community and connection platforms.
• Translate custom visual design provided by the client’s design partner into a style guide and then implement it on the live site
• Coordinating and collaborating with a large team of partners and vendors on a tight timeline, developing a solution that could easily handle traffic from more than 100,000 attendees during the event.

Component based approaches to front end development have taken over the web. From conceptual approaches like Atomic Design, to component based frameworks like React and Vue, this perspective on web development is unlikely to fall out of favor any time soon. And like many others, I love it.

There is however, one component related technology that has eluded me: web components. Web components are of a set of web APIs and standards that can be used to create custom and reusable HTML elements. A custom element that isn’t tied to a specific framework and is supported across all modern browsers truly sounds like component utopia. Yet somehow, native web components still haven’t become a major part of my front end toolset. With web component adoption increasing, it seemed like time to better understand why.

This session recounts the highs, lows, and surprises of my experience as a newcomer to web components, including:

● Key technologies including custom elements and the shadow DOM
● Creating web components using the core API
● Creating web components with the help of a library
● Styling web components
● Application state and web components
● Using web components with frameworks like Angular, Vue and React
● My newfound and slightly more educated outlook on web components

SLIDES - https://noti.st/brianperry/bdLuuQ/web-components-through-the-eyes-of-a-newcomer

Contribution day is a day we get together to move the project forward. Join us for opening remarks where we'll talk about the plan for the day. Initiative leads will all give a brief overview of their needs and then we'll split off into groups.

Many organizations are moving to static websites because they’re super fast and problems like scalability and security just go away from day one. But static websites come with their own set of issues. This panel will discuss how managing these sites in production can be different than managing a traditional Drupal site and how to set up dev, test, live workflow with static sites. 

• Sam Mortenson
• Robbie the Geek
• Neil Hastings
• Salim Lakhani

In a world where working more hours is often touted as a badge of courage and an example of high productivity, keep in mind that overload burnout is a real thing. While our individual thresholds for burnout may vary, our minds and bodies have limitations that when met, can severely impact our lives.

So how do we recognize and avoid burnout in ourselves, as well as others? Join me as I share my experiences and the knowledge I’ve gained in my journey to both overcome and avoid burnout.

In this session, you will learn:

• Overload burnout signs and symptoms
• Common causes and triggers
• Mitigation strategies

Target audience:

• Individuals that want to avoid or overcome burnout
• Leaders that want to support their teams

Presenters: Chris O'Donnell and Aaron Couch

By combining design systems with Layout Builder and Drupal features such as blocks we can deliver a "Wix" like drag and drop experience to site builders tasked with managing Drupal 8/9 websites. 

In this session attendees will learn:

• How to integrate design systems with Drupal
• How to combine component libraries with Drupal Blocks and Layout Builder
• How to use Emulsify to manage your component library for the website
• How to leverage prebuilt built components on other websites
• How this approach builds on Drupal's inherent flexibility 

Non-technical attendees will learn how this approach increases agility while decreasing costs by enabling reuse of previously completed work.