Jul 11 2019
Jul 11

Our lead community developer, Alona Oneill, has been sitting in on the latest Drupal Core Initiative meetings and putting together meeting recaps outlining key talking points from each discussion. This article breaks down highlights from meetings this past May. You'll find that the meetings, while also providing updates of completed tasks, are also conversations looking for community member involvement. There are many moving pieces as things are getting ramped up for Drupal 9, so if you see something you think you can provide insights on, we encourage you to get involved.

Drupal 9 readiness meeting! 07/08/19 

Meetings are for core and contributed project developers as well as people who have integrations and services related to core. Site developers who want to stay in the know to keep up-to-date for the easiest Drupal 9 upgrade of their sites are also welcome.

  • Usually happens every other Monday at 18:00 UTC.
  • Is done over chat.
  • Happens in threads, which you can follow to be notified of new replies even if you don’t comment in the thread. You may also join the meeting later and participate asynchronously!
  • Has a public agenda anyone can add to.
  • Transcript will be exported and posted to the agenda issue.

Drupal-check and Upgrade status updates

Drupal 7 migration path UX improvements to do

Started work on "create an audit plugin class/manager for migrations", in an attempt to provide a user interface for situations where the migration path can’t be determined without some input from the user.

Removing deprecated API uses from core

As per Drupal core's own deprecation testing results we have moved somewhat in the past month, therefore by resolving "Replace calls to format_string()" we could cut down to less than 50% of the current number. Previously we indicated that we are looking into core’s use of deprecated APIs as an indicator as to when the Drupal 9 branch could be opened, where we can do the actual Symfony update as well as PHP version requirements updates. Doing this so as to have a branch for people to test with sooner than later, there by resolving the deprecated API uses is in that critical path.

The roadmap for simpletest out of Drupal

  • A published roadmap for simpletest is live. 
  • There are a few issues here:
    • There's a module called simpletest in core that should be deprecated.
    • There's a class called TestBase which should be deprecated.
    • There's a simpletest UI that might end up living in D9 as testing_ui.
    • There's a test runner called run_tests.sh that needs to be refactored for all of the above.

Admin UI meeting (07/10/19)

Meetings are for core and contributed project developers as well as people who have integrations and services related to core. 

  • Usually happens every other Wednesday at 2:30pm UTC.
  • Is done over chat.
  • Happens in threads, which you can follow to be notified of new replies even if you don’t comment in the thread. You may also join the meeting later and participate asynchronously!
  • There are roughly 5-10 minutes between topics for those who are multitasking to follow along.
  • The agenda is public and anyone can add new topics in the document.

Permissions and other requirements for the new Content Editor role:

The "Add new Content Editor" role to "Standard Profile" issue is open.

The basic features we identified are:

  •   Create and edit new content - articles and pages
  •   Use the basic HTML text format
  •   View unpublished content
  •   Create and edit terms (tags and categories)
  •   Access the administration theme

One of the suggestions was to base Editor permissions on what Umami already set up and add all the permissions that are needed in all modules that come with core (even that they come disabled by default).

Review and approve the Roadmap to stabilize Claro

Issue "Roadmap to stabilize Claro" was opened.

Status of the tabledrag component

  • Table drag style update is in progress. From a design perspective, the current table drag and drop is good enough for a MVP(beta) Claro version.
Jul 11 2019
Jul 11

For the past several years (2016, 2018, 2019) Dries has written articles aimed at helping people decide if and how one should decouple Drupal; a general survey of the state of decoupled/headless Drupal. In his most recent post he mentioned the pace of innovation has been accelerating due to the number of Content Management channels and JavaScript frameworks to support. I’ve been particularly excited about the JavasScript frameworks and hoped to find more in-depth coverage of this.

Much to my chagrin, from numerous conversations with Front-End developers as well as other Full Stack developers, I’ve found that knowledge in the community about a lot of the innovations happening outside the traditional Drupal or Open Source world has not grown as fast. Much of the content being published, in my opinion, doesn’t necessarily do a great job of covering some of the better possibilities out there and potentially leave readers and attendee’s of talks un-informed on just what the possibilities are.

Understandably, everyone can’t be expected to know everything about everything, but I believe there’s an opportunity for the community to leverage some of the powerful tools that exist with the knowledge we have to increase the use case for Drupal.

Show ‘Em What We’ve Got

Today, unlike the days of yesteryear, many members of the community are already equipped with the tools to build truly native mobile applications thus eliminating the need for Java or Swift since JavaScript and TypeScript based languages can be just as effective. 

In the interest of raising more awareness of what’s out there, I’ve decided to explore some of the most popular frameworks for building native mobile apps from a single codebase using technologies familiar or learnable by many. With that, I’ll be exploring their ease of integration with Drupal.

Exploring The Possibilities

Over the next several months I will explore and evaluate some of the tools available for native mobile app development, as well as Drupal tools, modules, and distributions that facilitate this. I will also go through the process of building actual apps to provide insight into the research you may not have the time to do yourself. 

The tools I will explore, in addition to core and contrib Drupal modules, will include:

  • ContentCMS (API-first Drupal distribution)
  • ReactNative (Framework for building mobile apps with ReactJS)
  • Tabris (Framework for building native mobile apps with JavaScript or TypeScript)
  • NativeScript (Framework for building native mobile apps with JavaScript, TypeScript, Angular or VueJS)
  • Appcelerator Titanium (Framework for building native mobile apps with JavaScript)
  • Fuse (Framework for building native mobile apps with JavaScript)

My hope is that by the end of the series, there might be a few converts to Drupal-powered native mobile development both from the Drupal side and from the frontend development side. WordPress is already ahead of Drupal on this with several plugins that convert WordPress sites into native mobile apps, so we have some catching up to do.

Jul 08 2019
Jul 08

Our lead community developer, Alona Oneill, breaks down highlights from Drupal Core Initiative Meetings this past week. You'll find that the meetings, while also providing updates of completed tasks, are also conversations looking for community member involvement. There are many moving pieces as things are getting ramped up for Drupal 9, so if you see something you think you can provide insights on, we encourage you to get involved.

Out of the box initiative meeting (07/02/19)

At this meeting we spoke with the developers at Blackfire.

  • We have a working account with Blackfire to try out Umami,
  • Also tried New Relic - which showed that search indexing is taking a long time,
  • Can we change how Umami installs so that long steps can be skipped to save time?

Issues to work on this week:

Admin UI meeting (07/03/19)

Meetings are for core and contributed project developers as well as people who have integrations and services related to core. 

  • Usually happens every other Wednesday at 2:30pm UTC.
  • Is done over chat.
  • Happens in threads, which you can follow to be notified of new replies even if you don’t comment in the thread. You may also join the meeting later and participate asynchronously!
  • There are roughly 5-10 minutes between topics for those who are multitasking to follow along.
  • the agenda is public and anyone can add new topics *in the document*.

Dialog Issue

  • Dialog style issue.
  • Issues in the core.
  • Proposed the idea that we would try to do research on dialog solutions in Claro and replace jQuery UI dialog with something in our scope of work. An a11y maintainer didn’t like the recommendation and after doing some more research on this it feels like very hard because we might not be able to keep BC at least 100%.

Claro Alpha 4 Goals

Documentation to Work On

  • We should open an issue for tracking our plans for alpha releases, as well as beta and Roadmap.
  • There is supporting documentation for Claro here.
  • Strategic-initiatives needs to be updated.
  • The Proposal to use PostCSS for Claro in core.
  • Design sprint at DrupalCon Europe:
    • Several designers will attend the event, so some would like to have a sprint or focused BoFs.
  • Editor role:
    • We are still missing part of the `Define the new set of permissions` before we can create the patch.
  • Vertical tabs:
    • Mobile design is troublesome, because they are not vertical anymore and behave like the details element. The problem on the design here is that we can't have vertical tabs in small devices, they need to be one  below the other. And we can't have the title above and the content 5 tabs later after all the titles.
Jul 01 2019
Jul 01

Our lead community developer, Alona Oneill, breaks down highlights from Drupal Core Initiative Meetings this past June. You'll find that the meetings, while also providing updates of completed tasks, are also conversations looking for community member involvement. There are many moving pieces as things are getting ramped up for Drupal 9, so if you see something you think you can provide insights on, we encourage you to get involved.

CMI 2 Initiative Updates

Status of CMI 2

Major patches are being reviewed and hopefully will land after it gets a change record.

Next steps for CMI 2

  • A final review from Lee to be completed.
  • The config environment module, different configuration in different environment, is in production.
  • At a stage where nothing is needed from Core Cm or FM’s.

Composer Updates

Status of Composer

A patch went in to use composer as a dev requirement and we're on the road to making core test builds and upgrades. The scaffolding patch was reviewed and moved to RTBC.

Next steps for Composer

  • Need core maintainers to review the testing framework from miles 23.
  • Need core team to help with the scaffolding issue.

Workflow Updates

Status

There are two major patches being worked on at the moment:

Would also like to see the issue to allow 'syncing' content to be updated in content moderation without forcing the creation of a new revision be updated. Content moderation is working with this as it allows people to moderate any content within the workspace via the user interface.

Stable release

Upgrade path is on hold until this approach is validated or approved. Workspace merging is currently in need of an issue.

Next Steps for Workflow

Get release managers and fm review is needed on issue #3062434. Get FM review on issue #2803717 because it currently needs additional input. An issue for workspace merging also needs to be created. We're trying to get the first 2 issues into 8.8 (and 8.7).

Drupal 9 Updates

Status

  • Drupal check got a release last week by mglamman with all deprecation error messages.
  • Upgrade Status has new features in dev that categorizes error messages on actionability. The action items are, supported, deal with it now, not supported, deal with it later, or deprecated for Drupal 9.
  • Explaining in the UI of the module to help them engage with contribution maintainers.
  • There is low-level planning in the works to:
    • Identifying work to manage dependencies and defining the process to do this work.
    • Issues related for info:
    • We are asking for investment from Acquia to complete some of the work.
    • Core jQuery UI discussions are continuing.
    • Symfony 5 branch is now open! The branch requires a min php 7.2. For Symfony 4 the php requirement is 7.1.

Drupal 9 Blockers

Cannot complete deprecation list for 8.8 because November is when we’ll get the list from Symfony for the SF5 release.

Next steps for Drupal 9

  • Continue to keep tabs on what is happening with Symfony 4 and 5 changes.
  • Review the list of items being deprecated for 8.8 with RM/FM.
  • Make a decision on if the team goes with Sf4 or Sf5.
  • Confirmation on the resourcing ask for Drupal 9 work.
  • Confirming the front end deprecation process.
  • Identifying critical path items and sequencing for Drupal 9 work.

Claro Updates

Status

We have one group working on admin ui theme, Claro. There is a lot of contribution progress from both front-end developers and designers. The Alpha 3 release of Claro was released in the middle June.

Another team is working on react-based decoupled admin ui, however there is not much momentum at the moment. So far, a component library has moved forward with limited resources.

Next steps

The team is on track for getting in 8.8, likely as a beta. This will address open issues with designers,  address changes that developers need to make which have already been found, and work on get approval from RM/FM on moving the theme toolbar CSS to the Seven theme.

Status

  • At Devdays++ accessibility improvements and fixes were worked on and signed off by RM/Media team consensus.
  • Drag and drop zone for file uploads was discussed at the UX meeting as the current design was causing accessibility issues.
  • The plans for WYSIWYG are complete and ready to be worked on moving forward. 
  • Media metadata issues are now unblocked.

Next steps

  • Continue prototyping on the accessibility solutions to be compatible with drag/drop zone for file uploads.
  • Keep working with contributors and community members to find solutions that could incubate there.
  • Keep working on WYSIWYG.
  • Resource and allocate people to work on metadata.

Migrate Updates

Problem

The current migration is not as user-friendly as we’d like. We need a better user experience.

Solution

There is a large list of things generated from Angie Byron on the experience:

  • Running a pre-flight check will reveal if your data has an issue. We need a better way to check that issues you’d run into are uncovered and fixed before they migrate.
  • Solution needs to not mess with the command line and be more intuitive.
  • Working with UX to find an appropriate solution.
  • Currently have 4 migration maintainers with limited additional resources. We need more people writing code!

Next steps

We will continue with the multilingual upgrade path and keep working on preflight check to improve the migration experience. 

It Takes A Village

Thank you for being involved in the community, we're happy to be helping spread the word about the progression of a great platform. Please check back for frequent meeting recaps to gather insights on the latest Drupal Core developments and find ways to get involved. Our community thrives when we all come together!

Jun 20 2019
Jun 20

For years, community members from Chattanooga talked about their local camp. These community members routinely support other camps, through attendance, volunteerism, and by giving talks. It was our time to return the favor.

Hook 42 not only sponsored the event, but delivered a training and two sessions. From our team Jonathan and Adam attended, and they really enjoyed the time there.

Adam’s Experience

I was grateful to have the opportunity to deliver a full-day training on GatsbyJS on Friday and one of the featured talks on Saturday. I want to recognize my training peer Ryan Bateman who helped out with many of the preparations for the training. I also want to thank attendees who came to either. 

The training was an end-to-end GatsbyJS primer. We set up a Pantheon instance running Umami. We walked through a series of primers and hands on lessons. Most in the room were able to deliver a working Gatsby recipe site to Netlify. It was fun to cover so much material and watch people go from nothing to a functional site. Feedback was positive and it was very helpful to have the super fast Chattanooga internet speeds.

I prepared a brand new talk entitled “Evolving Priorities: Tech, Community, and Impact.” I looked at topics like technical skills, emphasizing the needs of people, and changing our individual frame of reference to what has an impact on the world. I also shared some thoughts on the evolution of Drupal, both from a community and a product. I appreciated those who attended and subsequently gave me feedback for future improvements.

Many people from other close by camps were able to attend. It was so nice to see friends from Asheville and Atlanta to show their support for the deserving Chattanooga crew. Doug Vann, Mike Herchel, Aaron Feledy, and Jordana Fung, among others, also attended from the broader community. It was great spending time with everyone.

I found the camp to be friendly and represent the spirit of those giving back to the Drupal community. Organizers selflessly volunteered their time and committed to helping their guests have a wonderful time. In particular, I was able to go to Rembrandt coffee, Freemont (burger and craft beer night), and Heaven and Ales brew pub. It was a beautiful area with green scenery and beautiful waterways.

Jonathan's Experience

And so we meet again. 2019 was my 2nd year at Drupal Camp Chattanooga, and it was even better than the first. Hanging out with the locals and those visiting from other areas is one of my favorite parts of attending a Drupal Camp. Last year I had to rush home and didn’t get much of a chance to get the full experience, but this year was different in all the best ways.

We started the camp off right with a game night at Code Journeymen’s offices and had a rambunctious night of accusing people of fascism while enjoying each other’s company. It was a welcoming and comfortable atmosphere that, as a camp co-organizer myself, I admired greatly.

After I had a short adventure of being lost in the parking lot, the camp itself seemed to go off without a hitch. They had a lot of really great presentations. I evolved my priorities with Adam, learned about fixing my mistakes as a developer with Jordana Fung, finally got to see Mike Herchel’s Front-end Performance talk, and over lunch looked at some code and talked about custom composite/rich fields with Hawkeye Tenderwolf. It was great times all around.

It was also a great enjoyment to have the opportunity to give my presentation, Glitch: Love to Learn the web again, as the Glitch product and community are a topic I’m very excited about. Reception of the talk seemed to be good as well. There were multiple outstanding questions that I tried my best to answer, and I even remembered to repeat one of them back on microphone for the recording. Otherwise, it was basically a blur of me gushing over Glitch. Check it out!

After camp wrapped up, we were off to the arcade. Rather, a pinball museum, where we played some games older than anyone I’ve ever met and played on another machine that had to weigh over 1,000lbs. We enjoyed a round of pizzas and beverages before hitting the town, exploring a few of Chattanooga’s secrets.

All-in-all, what a great camp experience. As a co-organizer of Drupal Camp Asheville I have some sense of what it takes to make a camp happen, and those Chattanooga folk make the hard work look easy. I can’t recommend enough that you try to attend Drupal Camp Chattanooga 2020.

*Image taken at Drupal Camp Chattanooga, borrowed from Twitter.

Jun 11 2019
Jun 11

Our lead community developer, Alona Oneill, has been sitting in on the latest Drupal Core Initiative meetings and putting together meeting recaps outlining key talking points from each discussion. This article breaks down highlights from meetings this past May. You'll find that the meetings, while also providing updates of completed tasks, are also conversations looking for community member involvement. There are many moving pieces as things are getting ramped up for Drupal 9, so if you see something you think you can provide insights on, we encourage you to get involved.

Drupal 9 Readiness

Meetings are for core and contributed project developers as well as people who have integrations and services related to core. Site developers who want to stay in the know to keep up-to-date for the easiest Drupal 9 upgrade of their sites are also welcome.

  • Usually happens every other Monday at 18:00 UTC.
  • Is done over chat.
  • Happens in threads, which you can follow to be notified of new replies even if you don’t comment in the thread. You may also join the meeting later and participate asynchronously!
  • Has a public agenda anyone can add to at https://www.drupal.org/project/drupal/issues/3054328
  • Transcript will be exported and posted to the agenda issue.

Meeting Highlights From 05/13/2019

Update on Drupal 9 dependency targets (CKEditor, Symfony, PHP)

  • The plan is to release Drupal 9 with CKEditor 4 support, add optional CKEditor 5 support during D9's active support, and deprecate CKE4 before D10
  • D9 will probably be EOL in Dec. 2023 and CKE 4 can have security coverage through then
  • Policy issue

Documentation Updates for Drupal 9

Drupal.org tasks for Drupal 9

Opened an issue today to track these and currently working on Drupal 9 plan summary via https://www.drupal.org/project/drupalorg/issues/3046058.

Deprecations

Upgrading to Drupal 9 version of Classy and Stable could be hard given the number of unknowns. We are proposing to provide the current versions of Classy and Stable in contrib space. This would allow pre-existing themes to add a dependency to the contrib version of the themes and have the exact same behavior in Drupal 9 as they had in Drupal 8.

To avoid this problem in Drupal 10, we are proposing to not ship Classy as part of Drupal 9. The feature gap would be replaced with a new starter kit theme.

Risks for June 2020 Target Date

  1. Biggest worries right now are: D7 to D8 migration support, including finishing multilingual support and UX improvements.
  2. Filtering fails that are not actionable.
  3. Roadmap for Simpletest moving forward. Currently Simpletest isn't formally deprecated, we're welcoming any thoughts and suggestions here https://www.drupal.org/project/drupal/issues/2866082.

Meeting Highlights From 05/27/2019

New Drupal 9 Readiness Features & New Contrib Readiness Data

  1. https://twitter.com/DropIsMoving/status/1130868996771844096 is now live on drupal.org.

  2. Also Dwayne McDaniel figured out a new way to run his contrib analysis scripts and published a fresh set of data at https://github.com/mcdwayne/d9-drupal-check-allthemodules.

  3. Gábor Hojtsy took that and analyzed the top ones up to 50 uses and created this summary doc with docs pulled from api.d.o with a script: http://hojtsy.hu/blog/2019-may-24/analysis-top-uses-deprecated-code-drupal-contributed-projects-may-2019.

  4. Also the coder rules got fixed to conform better to the core trigger_error()/@deprecated formats and a new coder release is out now, so core can update to that https://www.drupal.org/project/drupal/issues/3049433.

Documentation Updates for Drupal 9

An extensive review was completed of the Drupal 9 docs. The review yielded grammatical improvements to improve English formatting.

New Critical for the D9 Roadmap

There's some discussion already in the other meta https://www.drupal.org/project/drupal/issues/2866082.

Sprint plans for DrupalDevDays Transylvania?

  • WebTestBase is officially deprecated, "Convert contrib test suites to BTB" might be a good sprint topic.
  • Alex Pott has a good start on getting the conversion docs a little more up to date and we're trying to continue to add to it, https://www.drupal.org/node/2166895.

Release schedules (branch opening, alpha, beta, rc) for Drupal 8.9 and 9.0

  • Beta1 would be tagged the first week of April 2020 if we are ready for 9.0.0 in June.
    • If we're not ready for 9.0.0 in June by say March, then we switch 8.9 back to a normal minor with a normal minor schedule (and announce the December release date).
    • Also with regards to documenting on the releases page we should probably inform the rest of the committers first. The email should outline the alphas, March as a go/no go decision, deadline for June vs. Dec. 3. as well as the beta and RC dates.

Freezing entity schema updates between 8.9 and 9.0

  • With 8.7 especially, but not only, entity schema updates are causing a lot of trouble for sites trying to update. Sometimes it is a bug in the update, just as often it is corrupted data or custom code on sites trying to update. Given 9.0.0 will have a lot of other changes, we should consider not committing any big entity schema updates to 8.9/9.0.

  • Opened an issue, freeze entity schemas in 8.9.x and 9.0.x to work on solving this.

Out of the Box Initiative Meeting 05/28/2019

  • We want to create a roadmap for Drupal 8.8 release. You can find the details here: https://www.drupal.org/project/drupal/issues/3047414
  • Talking about SimplyTest.me Umami Demo.
    • Trying to shave off all installation time and figure out where it goes.
    • Adding an option with and without multilingual.
  • Talking about creating help pages about all new features and things in 8.8 release.
  • Add a floating tour button on pages that have an explanation (need to create an issue).
  • Implement Layout Builder on every page, recipe, and article.
  • Working on Umami’s Language-switcher as a drop-down menu.

Layout Initiative Meeting 05/29/19

Currently, when using Layout Builder, the already added sections give no indication of their layout or its configuration. This isn't a big deal for sighted users who are only using the default Layout Builder layouts, because the only configuration is the widths of the columns, which they'll be able to see visually.

However, for non-sighted users, or if a layout has more complex configuration (for example, using different proportions for different view port sizes, or adding class names, or anything since layout plugins have full control over their settings and rendering), then there is no indication given of the section's layout or its configuration.

An issue was created to document this concern.

graphic with drupal logo next to phrase community of support

That's A Wrap

Check back for frequent meeting recaps to gather insights on the latest Drupal Core developments and find ways to get involved. Our community thrives when we all come together!

Jun 10 2019
Jun 10

This post was written by Adam Bergstein with input and feedback from Aimee Degnan and Ryan Bateman.

Hook 42 recently had a project that required the use of Kubernetes. Kubernetes is an orchestration tool that helps solve many enterprise problems when using multiple containers. People often want redundancy and scale across a series of containers or the same set of containers across multiple machines. Kubernetes helps solve this. It also can help perform orchestration tasks during failures or to distribute load between containers. Managing containers at scale can be a challenge and the goal of Kubernetes is to help.

We have long been tracking the efforts of Lagoon, a promising open source continuous integration and continuous delivery (CI/CD) hosting platform that is developed with Kubernetes. CI/CD is built around the concept of rapid deployments of ongoing, frequent changes. This lowers the risk presented by larger, fixed deployments by promoting smaller, more routine deployments. Lagoon not only offers hosting-related tools, but the platform is able to run locally as well. The CI/CD capabilities helped create testable environments as we pushed changes through our development workflow. We want to share our experience. 

Understanding Considerations

There are some key concepts to understand how Lagoon works before diving in.

Persistence

Drupal applications require a “source of truth” for persistent content, which includes a Drupal application’s managed files and database. Production environments (or pre-production before a system is launched) conventionally serve as the source of truth environment within a development workflow. Content is subsequently pulled from the source of truth and it is only managed by changes made directly on the production system. Where code can be pushed through environments, content should always get pulled from production. 

Repositories

Code repositories are critical for managing code and deployments. Each change is one or more commits that can be staged within specific branches. Changes can be merged into other branches, rolled back if there is an issue, and audited as a series of changes. 

Hosting providers offer varying conventions and integrations tied to code repositories. As a simple example: both Pantheon and Acquia offer their own Git repositories commonly synchronized with a Github or Gitlab repository. The Github/Gitlab repositories offer development tools like pull requests or integrations to help support team-based workflows. 

Hooks/Events

Both repositories and hosting platforms expose relevant hooks that are useful for performing actions during DevOps events. This is how automation can be built into specific changes. Automation is critical for any CI/CD infrastructure, as it’s not manageable or practical to manually rebuild environments as each frequent change occurs. 

Creating and maintaining branches, tags, and pull requests tied to repositories create opportunities for automation that are commonly leveraged repository events in our DevOps infrastructure. Even synchronizing between two repositories can be a useful DevOps trigger, as this signifies code is ready for some degree of deployment or testing. 

Any sort of deployment found in CI/CD workflows often require rebuilding containers. This is common for all environments. Persistent aspects may be left untouched, while the containers for a given environment are rebuilt as new changes are deployed.

On-demand Environments

Cloud infrastructures changed the traditional way of understanding environments. On-demand environments are a result of rapid change and are transient. This is in contrast to an environment traditionally configured on a bare metal server. On-demand environments are commonly provisioned with new branches, tags, or pull requests and destroyed when the changes are deployed. They are not intended to persist.

In a CI/CD workflow, incremental changes are verified before the production deployment. Development-specific branches and pull requests can build new environments known as on-demand environments. Persistent contents from the “source of truth” are copied with changes pushed to a branch on a new environment. This helps to verify and mimic production behavior with the new change. And, the environment subsequently goes away when the change is deployed.

Fixed Environments

Hosting providers still commonly offer “fixed” environments as people are not often comfortable merging an on-demand environment right into production. But, fixed environments exist for an intended purpose. As an example, a production environment is intended to be what end-users access. Other environments are commonly used to vet changes before a production launch. Vetting may include any of the following purposes: proper deployment, stakeholder approval, automated tests, and verified with the most recent code (changes pushed while the code was developed and/or staged). The same fixed environments can be uniquely configured and used in those capacities in a more permanent capacity.

Exploring Lagoon

Every hosting platform has a set of best practices tied to their platform that drives intended use. While any platform, like Lagoon, can seem opinionated, our focus is to connect the aforementioned concepts to their specific Lagoon equivalent. 

Repositories, Hooks, and Events

Lagoon, at this point, attaches to a remote repository, like Github or Gitlab. Lagoon integrates through the repository platform, via a webhook or continuous integration system. The hook is intended to be invoked during specific events like branch creation and/or pull request to help create the CI/CD on-demand environments. This approach shaped our development and release workflow to the Lagoon platform, which we elaborate more on below. 

Fixed Environments

The first thing our team did was set up fixed environments tied to specific branches. This met the need of having changes go through a conventional development, staging, and production release cycle. Within Github, there are subsequent branches for each fixed environment. As a best practice, each branch was locked within Github. This is to ensure a branch was not accidentally removed, which may remove a fixed environment entirely. 

Github repositories often leverage “master” as the default branch. We’ve selected that as our branch for our development server. This is useful for pull requests, as “master” is selected by default and our team didn’t need to worry about selecting the wrong branch. Doing so may trigger a code deployment to another, unintended environment.

On-demand Environments

Lagoon maintains two events for provisioning on-demand environments. The first is pull requests. Pull requests seem to be useful if you are operating in a pure CI/CD environment where changes can be tested as an environment tied to the change. But, pull requests often are not created until a potential change is ready to be reviewed and possibly merged. This would be ideal for an environment to do smoke testing. But, we desired to have environments for work-in-progress as well, where anyone could push a commit to a branch, demonstrate some work, or get help on something. We opted not to use pull requests for that reason.

The second provisioning event is through a branch pattern. This leverages a naming convention to create on-demand environments. Lagoon monitors the creation of any branch that matches the pattern and creates an environment. This is helpful for the initial testing of changes.

Release Workflow 

Our release workflow is based on staggered branches. Changes are pushed to the on-demand branches and prepared for initial review. A pull request is made for the code review and smoke testing occurs on the on-demand environment. Once the pull request is merged into master, our development server is rebuilt (any commits pushed to master trigger a rebuild of the development server). We close all on-demand branches at this point, which subsequently removes the environment on Lagoon. 

Once the merge is complete, additional quality assurance, client review, and automated testing occurs through development and staging environments. This happens by making a pull request from the master to staging branches, creating a release candidate. 

With all of the verification passing, we are able to initiate the release. This is done via a pull request from the staging to production branches. Once the pull request is accepted, the production release occurs. All of this is automated thanks to the hooks and events tied to the Lagoon platform.

Persistence

Lagoon rebuilds environments on every push to a branch. In our workflow, accepted pull requests push vetted code to branches. Persistence becomes a major factor when environments can be rebuilt in this fluid manner. 

Lagoon also provides the ability to configure what environment is deemed the production environment. This is subsequently protected within Lagoon and persistent. The “production” branch, and its subsequent environment, represent the source of truth for database and files. Rebuilding the database and files on a production release is risky, so this mechanism needs to exist to differentiate from the other more fluid environments that get rebuilt more routinely. These protection mechanisms helped avoid production data being overwritten through the API or any unintended impact by a production deployment and subsequent rebuild. Not only that, but this helps identify what data needs to be routinely backed-up and maintain high fidelity.

DevOps

All non-production environments should automatically load a copy of the production database and files when new changes are pushed to the subsequent branch. Verifying changes before being released to production was a critical DevOps automation for us.  We leverage hooks in Lagoon (defined in the .lagoon.yml file) with Drush commands and aliases to identify the environments that synchronize the database and files from production every time an environment is rebuilt.  

Code artifacts were also a vital part of our DevOps automation. We leveraged Composer to build the Drupal codebase (using the great Composer template for Drupal projects - drupal-composer/drupal-project) and Gulp to build the theme. Custom code was committed to the repository. This allowed us to easily and routinely evaluate changes to core and contrib.

Once our code was built, we executed Drush commands to import the configuration, run database updates, and clear caches to ensure changes were properly deployed. While this does not catch every possible nuance in deploying code (e.g. rebuilding entities), we automated a significant portion of this that should minimize the need for running manual commands. 

Observations

Lagoon is doing some innovative work, especially for Drupal teams looking for a CI/CD platform adopting rapid releases. Their “infrastructure as code” implementation, through their Docker images and .lagoon.yml configuration, enable rapid, effective change at the heart of DevOps that can help continuous learning and the subsequent predictability of automation. 

As expected, coming from the perspective of using other hosting platforms like Acquia and Pantheon, there was some learning to adapt to the fluid CI/CD nature of the platform. Lagoon’s local implementation replaced our standard MAMP, DDEV, and Lando setups. Being able to add in restrictions, like branch locking, was beneficial to our teams transition when configuring the infrastructure. Also, there were some different conventions, like leveraging drush aliases through Lagoon’s CLI container and not through a local Drush, that were unique. But, many of our existing knowledge and concepts were the same or could easily be mapped to their Lagoon equivalent.

After some trial and error, we were able to share some feedback with the Amazee team on improvements to their documentation and relevant code samples we felt could help others. Hopefully shaping the path forward for others being onboarded can make it easier to digest for those new to the platform.

Overall, Lagoon shows a lot of promise for modern workflows. While different than other hosting platforms, Lagoon enabled our team to work effectively and efficiently from start to finish. We’re excited to see how the platform evolves and continues to provide solutions capable of rapidly changing to our customer’s needs. 

Jun 05 2019
Jun 05

Hook 42 is headed to Tennessee for our next community event. Not only have we proudly sponsored Drupal Camp Chattanooga, you'll also find us doing a Gatsby.js training as well as giving talks about topics we hold near and dear to our hearts. Come say hello if you're there.

Presentations

Keynote

We're very excited that Adam Bergstein will be conducting this year's keynote in Chattanooga. You don't wanna miss it!

Change is the only constant in life. As technologists, the landscape around us is constantly shifting. We must evolve or become irrelevant. How do we do so? It's a gradual thing, but it also happens so quickly. Together we're going to explore considerations around that evolution and how we can embrace the changes. 

Topics include the limitations of technical skills, a purpose-driven perspective, and evolving ourselves. When evaluating Drupal, Adam shares how the product and community have evolved in the past and opportunities for the future. You can take away some perspective on how to approach change and evolve professionally.

Glitch: Love to learn the web again

Jonathan Daggerhart is talking about one of his favorite community tools - Glitch! You may not be entirely sure what Glitch is, but we promise you'll leave with more excitement than ever for learning new web technologies again. Jonathan will be covering the basics of Glitch, demoing it, and you to use it for fun and profit! Bonus points if you are already using Glitch today.

Man sitting at desk typing on laptop with gatsby.js logo on the screen

Training

Gatsby.js

Adam Bergstein is leading an all day training on Friday, June 7th, diving deep into Gatsby.js. Make sure you bring your laptop, as this training is very hands-on. We're ensuring everyone participating can leave with a more developed sense of what Gatsby.js can do and how you can implement it in the future. In this training session, Adam will go over setting up your environment followed by primers and follow along exercises that cover the following items:

  • Setting up Gatsby
  • Basic GraphQL & Gatsby
  • Test Drupal GraphQL
  • Recipe Listing Page (plus responsive images)
  • Recipe Detail Page
  • Updating Recipe List
  • Deployment

We hope you're ready to get your hands dirty with this training.

See You In Tennessee

We're excited for our trip to Tennessee. Yet again our ambitious team is always rushing to be first in line for the growth of our community. We enjoy trading stories with all of you, which is why it is important for us to share our experiences and methodologies that we've fine-tuned along the way. Chattanooga is just another stop on the community train for the Hook 42 team, and we couldn't be more excited to watch our community learn and grow together. We hope to see many familiar faces this year and make some new friends along the way.

via GIPHY

Jun 04 2019
Jun 04

One of our recent projects required a progressive enhancement approach for visual changes. Instead of a full end-to-end rebuild of a Drupal theme, a progressive approach can be accomplished with theme switching. Many Drupal 8 projects leverage custom block types, Paragraphs, or Layout Builder to place one or more design components on a page. This provided the client with the ability to split up a larger architectural change into a small set of pages and components that can be gradually rolled out. Of note, such an approach can also serve as a viable solution for A/B testing of visual changes. 

Screenshot of a Drupal 8 layout before and after updates were made

Understanding Context

There are several solutions capable of providing theme switching. One key differentiator is context. Do you want to switch a theme by page, role, language, associated taxonomy, URL parameter, or authenticated/unauthenticated traffic? Context serves as a critical requirement for determining when a theme switches.

In our case, we progressively enhanced a theme page-by-page. We would work on one page, configure the theme to switch for that page, and continue to add pages as our work evolved. Solutions may vary based on the desired context. The rest of the blog post helps explore solutions for page-level context.

Background Research

I explored the following approaches to help solve the problem.

  1. Theme Key module: This is a very popular approach from Drupal 7 sites but did not appear to have a Drupal 8 release and this issue paints a murky future for any sort of use of the module.
  2. Style Switcher module: This offers a block for switching themes, sort of like CSS Zen Garden where you could select the look and feel. This wasn’t quite the context we needed.
  3. Switch Page Theme module: This was most effective for our use case. It allowed both page-level specificity and optionally allowed us to select the applicable roles. It also offered configuration, which was helpful for deploying progressive theme switching with theming changes.

Setting Up Switch Page Theme

It’s basic configuration. No programming is required. 

preview of theme switcher in drupal 8

The configuration page is fairly straightforward. Each rule is demonstrated by a row and can be ordered if there are rules that take precedence over others. The checkbox demonstrates how to enable or disable a rule as needed. Page paths are specified line-by-line per rule, followed by the selection of the displayed theme and the applied roles. 

After saving, going to the various paths should switch the theme as specified. And, don’t forget to export the configuration.

Conclusion

We were able to set up a new theme and gradually build out the various components with a theme switching approach. This allowed us to deploy changes over time instead of deploying an entirely new theme all at once. Switch Page Theme was an easy to use site building solution for us to specify the desired theme switching behaviors.  

May 31 2019
May 31

How to create a custom Facets query for your Drupal 8 faceted search app

When it comes to allowing users to search a site easily, a faceted search app can be an unparalleled solution. Being able to quickly drill down into search results using specific, easy-to-understand parameters is something that most users now simply expect from any site’s search app.

For Drupal 8 sites, the Facets module makes it relatively simple to create your own faceted search app, whether you’re using the Drupal core Search module or the very popular Search API module to manage your search functionality.

In the case of a site using Search API, the Facets module works particularly well in parallel with more powerful search engine backends like Apache Solr and Elasticsearch. Facets within a search app can take all shapes and sizes, and the Facets module provides a few plugins types that, in concert with each other, can be leveraged to programmatically create any sort of facet you may need for your search app. Because the Facets module relies on the Entity API within Drupal 8, these plugins should appear relatively familiar to most Drupal 8 developers:

  • \Drupal\facets\Entity\Facet
    • Describes the facet entity itself, whose data is received via a widget plugin and parsed by processor plugins
  • \Drupal\facets\Entity\FacetSource
    • Describes the source of the data being fed into the facet
  • \Drupal\facets\QueryType\QueryTypePluginBase
    • Describes the type of query being made against the search backend.
  • \Drupal\facets\Widget\WidgetPluginBase
    • Describes the widget that the user interacts with to control the search UI.
  • \Drupal\facets\Processor\ProcessorPluginBase
    • Describes the processor that translates the user input from the widget into data that can be used within the query.

The Facets module (along with its submodule Facets Range Widget) provides 4 basic query types:

  • \Drupal\facets\Plugin\facets\query_type\SearchApiString
    • The most comment facet query type, based on searching for simple strings.
  • \Drupal\facets\Plugin\facets\query_type\SearchApiGranular
    • Used for numbers-based facets that provide a spectrum of values between a set step size.
  • \Drupal\facets\Plugin\facets\query_type\SearchApiRange
    • Used for queries that allow users to select a range of possible numerical values.
  • \Drupal\facets\Plugin\facets\query_type\SearchApiDate
    • Used for queries to allow users to choose (ranges of) date values.

NOTE: These query types are to be used within the context of a Search API backend, rather than the Drupal core Search module.

So how do we do it?

I’d like to offer a brief example of how you might go about writing your own custom query types for a faceted search app using the Search API and Facets modules.

In our recent scenario, we needed a way to allow users to query against our search backend using numerical values, but in the format of comparing their chosen number value against searchable values using a specific comparison operator. In this case, our users were students who needed to be able to search for specific academic or volunteer programs. They also needed to be able to filter results based on a length of time (in weeks) that would be greater than or less than a specified value.or example, users would need a facet that allowed them to filter results by: any length of time, 1+ weeks, 2+ weeks, 3+ weeks, etc.

With this requirement in mind, the 4 basic query types listed above were not quite up to the task. Instead, we needed to write a custom "Integer Comparison" query type that would take in two key pieces of data. A number to compare values against and a comparison operator with which to make those comparisons. From our example use case above, we only needed the number from the user, because we would be setting the comparison operator (“>=“ AKA “greater than or equal to”) in configuration. However, we wanted to write a generic enough query type that could allow for any basic comparison operator in the future. This is the result:

In the code above, the two key pieces of data (the user-input number and the configuration-defined comparison operator) are $value['int’] and $value['op’]. However, in order to get these two simple values, we also needed to write a custom processor that could receive the raw input in from our facet widget and process that input into those two simple $value['int’] and $value['op'] values.

To understand what’s happening in the preQuery method above, you just need to know that the slider widget we implemented on the frontend had its possible data values encoded in a format like this:

Finally, in the code above, you’ll notice the one method getQueryType(), which is needed to specify which query type the processor should pass its data along to (in this case, our custom integer_comparison query type). In order to make our new query type plugin and processor plugin aware of each other, we need to implement one last hook in our module:

Contributed Customization

We're always looking for ways to customize integrations to fit the specific needs of project goals and we understand that out of the box solutions aren't always going to work. For example, the Facets module itself provides a submodule called Facets Range Widget that allows users to search using a range of numbers or dates. However, the default behavior of this facet assumed the use of a bounded range, as opposed to what we needed, which was an infinite range starting from a definite value. In that case, it was simpler for us to quickly create the exact facet query type that we needed, rather than wrestling with the defaults provided by the Facets module. We were only able to do that thanks to the Facets module’s highly extensible plugin system that leverages the contributed Search API and core Entity API of the Drupal ecosystem. That is why, even when we have a need for custom code, it is always a helpful first step to start from the strong contributed code provided by the Drupal community.

May 17 2019
May 17

This past week I had the pleasure of attending Drupaldelphia, a great event that is part of Philadelphia Tech Week. This helped introduce the Drupal community to a broader audience from the Philadelphia area. It was nice to see new attendees curious to learn about Drupal and what we’re doing. It was a pleasure to be able to meet, and greet, many of these individuals throughout the event.

Some beloved community members like Tim Plunkett, Chris Urban, and Anson Han call Philadelphia home. All participants got first hand exposure to our community in Philadelphia, which I consider to be vibrant and growing. It was great for those of us local to Philadelphia, and those we welcomed that came from afar.

Community Discussion

There was something for everyone and it’s always refreshing to see how much cool stuff is happening within the community. Here are a few of the talks I enjoyed this year:

If you were not able to attend, never fear. Kevin Thull recorded all talks, which are now up on drupal.tv

via GIPHY

Hook 42 at Drupaldelphia

Thanks to Hook 42 for sponsoring an event near and dear to me. I live in Pennsylvania and consider this event one of my local camps. It’s not a large event, but it is made up for in the connections forged and overall quality of the event. I’m glad to have been able to speak twice this year.

For my first talk, I spoke about SimplyTest.me. I shared historically where the system has been, what challenges we face today, and where we’re heading. The system represents a labor of love on my part and I’m grateful to be able to spend some of my community time at Hook 42 helping maintain it. The system has a vibrant future and we’re doing some really great things with TugboatQA, one-click demos, Drupal 8, and an Open Collective that should help pave the way for a future inclusion program. 

The second talk was titled, “Impact Through Contribution: A Community for All.” During this talk, I present a path to contribution as “A Hero’s Journey”. This is a known storytelling technique written by Joseph Campbell where characters follow a conventional arc to achieve deeply impactful transformation. I shared stories of those who have had a huge impact and talked about some of the creative efforts happening in the community. I offered some thoughts on areas of growth and improvement for our community. It’s my belief that everyone can have an impact and bring new, creative ways to contribute that make our community stronger. We need to do everything we can to help make that happen.

Final Reflections

It’s such a great time to be with people, talk about cool things we’ve been doing, and help our community progress together. As an example, attendees were able to come together and discuss some outstanding issues on Layout Builder where consensus was formed on some next steps. Taking this conversation purely outside of the issue queue allowed people to learn and help move forward one of the most innovative new tools offered by Drupal.

I had a lot of fun in the city of Philadelphia as well. I can get good cheesesteaks in Central PA, so I needed to think bigger for my time there. I went to not one, but two, different Belgian restaurants where I enjoyed mussels and fries. For breakfast, I enjoyed excellent coffee and an almond croissant that was acquired from Bluestone Lane.

Another great Drupaldelphia came and went. The sessions were great and it was spectacular to connect with those that attended. It had a friendly, lighthearted, low-key feeling that allowed everyone to get something meaningful from the event. I thank the organizers, sponsors, and attendees who made it possible. I’m already looking forward to attending this jawn next year.

May 08 2019
May 08

In case you missed it, Stanford Drupal Camp changed their name to Stanford Web Camp. This transformation marks an important step in the Stanford journey from the camp's inception 10 years ago. We’re happy to be part of the evolution of the Stanford community as they expand into a more inclusive web atmosphere.

Experience Stanford

At Stanford Web Camp, attendees and presenters will discuss a variety of topics about the web from development to accessibility, and everything in between. All of these discussions will take place on the Stanford campus, in sunny California. We're officially inviting you to come explore “The Farm” with Hook 42 and learn other fun Stanford lingo while you’re on site!

As part of the camp, Hook 42’s Aimee Degnan will be giving two talks – one focusing on accessibility and the other on SiteBuilding. So, if you missed Aimee’s talk on a11y tools at DrupalCon 2019 - you can see it live, in-person at Stanford Web Camp! 

Discover Accessibility Tools

Join us to listen to Aimee’s talk, “Which Accessibility Tools are Right For You?“ What you can expect to gain is a broad overview of all the tools that are available in the accessibility testing spectrum. We hope you’ll leave with a better understanding of what the tools are, and how they can be utilized. There are a lot of options out there, and just knowing where to start can be a difficult path.

Aimee will explore the following:

  • Which tools are right for you?
  • Will only one tool fit all of your needs? ;)
  • Build vs. buy some vs. buy vs. free? Is "free" really free?

Level Up Your Layouts

Aimee's second discussion will explore View Modes and Layout Builder. Level up your layout! Component Based SiteBuilding with Layout Builder & View Modes is for those who are familiar with Drupal and are interested in harmonizing tools to streamline component building in the platform.

With Layout Builder in Core, it is essential to build a View Mode and Layout Builder strategy. You can harness the power of View Modes to move beyond Teaser and Paragraphs for display flexibility. Come out and learn how you can build a more streamlined process utilizing the benefits of View Mode and Layout Builder.

The talk will be structured as follows:

  • View Modes in Core
  • Architecting View Modes for your site
  • Lessons Learned with View Modes
  • View Modes and Layout Builder

Join Hook 42 at Camp

Stanford Web Camp is completely free and open to the public, we encourage all of you to explore other sessions and join a community of motivated professionals as we talk about the latest trends and developments in our industry. Come out and say hello to Hook 42, we’re eager to meet new people, connect with old friends, and discuss all things tech.

See you soon! 

via GIPHY

May 03 2019
May 03

It’s been almost a month since DrupalCon 2019. We can’t believe how time flies! While we were there, we had a variety of things going on at many different levels. Just as fast as the time since DrupalCon has flown past us, our time in Seattle felt like a tiny blip. 

From organizing summits, lunches, BoFs and presentations, our team was just as busy behind the scenes of DrupalCon this year, as we were being attendees. There were so many ways for us to really dive into the DrupalCon experience and we’re already looking forward to the next one! In the meantime, we put together a recap of our time in Seattle.

Presenting & Involvement

The most notable thing about our team, is how involved we are in our community, and DrupalCon 2019 was no exception. From 7 talks, a lunch sponsorship, a summit training and BoF organizations, Hook 42 had many members participating in DrupalCon. We are thankful for the opportunities provided to us to be able to participate in many areas. We know we had an unforgettable experience this year, and we hope we were able to help all of you achieve that same feeling.

DrupalCon is its own unique experience every year. My heavy involvement in community efforts this year was truly eventful. Pun fully intended! I’m glad to have had the opportunity to work closely with those outside my day-to-day operations at Hook 42 to bring together expertise that normally isn’t co-packaged together. 

~ Aimee

In case you were unable to catch us in the act, here is a list of all the ways our team was working at DrupalCon.

Aerial view of Adam Bergstein and other coffee BoF attendeesPhoto Credit: Chris Urban

Being Prepared for the Unpredictable

A Full Team Website Takeover

Our team set out on a mission to band together and tackle some internal items while all together. When the decision was made to extend the level of effort into those items, nobody batted an eyelash! It was an incredible tribute to the stamina, talents and dedication of our team members have to completing tasks. We did a full hotel lobby takeover for the majority of the trip, in between sessions of course, to spend time taking the Hook 42 website from a D7 website to a D8 website. It’s a very rare occasion, when all of us are in one place, focusing on one item, and working hard to ensure a successful migration into the new system. All of those involved still can’t stop talking about it! 

Our little secret, an easter-egg if you will, to those who are so dedicated to continue reading. A redesign of the Hook 42 website is in the works. Unfortunately you’re going to have to wait a little bit for that one! We’re just glad we finally upgraded to D8!

Hook 42 team takes over hotel lobby to work on new D8 website

Presenting On The Fly

Secondly, Kristen Pol was invited to co-present on a talk with Lingotek. Talk about being prepared for anything! Being a support-member in the audience quickly turned into providing insights to a room full of eager listeners. With additional help from Aimee Degnan, our team was able to put together additional assets to provide the Lingotek team for the collaborative presentation. A huge shout-out to those involved for coming together for last-minute changes and helping solidify a great talk.

Lingotek’s session, Avoiding Trouble Spots When Creating a Multilingual Site, explored the challenges multilingual websites create, and Kristen took the charge head-on to be a co-presenter on the subject. It was a great experience for everyone. 

A Chance To Have Fun

Whether it’s with new friends, old friends, or colleagues - every year DrupalCon allows us to forge connections that stay with us for a long time. The team took a day to explore Seattle together. We had a full team lunch, took an underground tour of the city, and took advantage of a rather sunny day in Seattle to walk around and take in the beautiful city.

Hook 42 team on Seattle underground tour

Meeting Our Newest Team Members

We also had quite a few new faces on our own team this year. DrupalCon allowed us a place to all come together and meet in person. Lindsey, Emanuel and Michael were all able to join our team on a cross-country trip to Seattle. Yes, all of them are spread across the East Coast! 

I always love to meet with the Hook 42 team in person since they are just a great group of people. We were also lucky to have a few new team members since our last in-person gathering.

~ Kristen

Other Connection Opportunities

Outside of the team, we were also able to say hello to a lot of familiar faces that we usually only get to see once a year at DrupalCon. Whether it was in a session, during lunch, at dinner or ending the day over a few drinks, we are thankful to be able to have seen so many of our Drupal community members and re-connect. Our team was able to use DrupalCon as a way to take time away from the computer and get some quality face-to-face time with others in the community.

DrupalCons are as much about the community as they are about learning new Drupal things. While sessions where you can learn a lot of new things about Drupal are the focus, one of the best parts is bumping into old friends or sitting down next to someone new and chatting about a common interest in Drupal and web development.

~ Danita

A Place To Learn

Our team is never disappointed when we leave DrupalCon. We’re always coming away with new ideas, new thoughts, and new procedures for how we do our jobs. It’s the most important takeaway from all of this - is that DrupalCon is always providing content that is spread across a variety of skillsets and interests. This year’s focus on inclusivity made our designer especially happy - you can read all about her first ever DrupalCon experience here.

Although the new schedule reduced the total number of days of sessions at the conference, I felt like as usual DrupalCon provided an awesome environment for everyone to come together and share their experience and expertise.

~ Ryan

Some Favorite Sessions:

Presentation Title Screen, PEGA Build for Change

Migration Workflow Diagram Preview

Glitter rainbow Drupal 8 unicorn

Elevated Third presentation title screen

Drake YOLO

diagram depicting design feedback and front end pairing with backend to build the website

meme - wrote PHP unit test, only took 4.5 hours, yes!

Team Benefits

DrupalCon is imperative to the health of our team in many ways. For starters, it's one of the only times our full team is in one place at one time, and that alone is enough of a reason to enjoy all DrupalCon has to offer. Our team also uses the event to provide thought leadership to the community. We take the time to also learn from other experts in the field on unfamiliar topics or expanding expertise in a certain area. Giving back to the community in more ways than one as a culmination of the event is really what ties it all together. 

It's such a heart warming experience, like seeing 500 of your closest friends once a year. It's a celebration of wins, sharing of knowledge, and a real feeling of connection. This year had such a pleasant vibe and was a nice reflection of our community, which goes well beyond tech.

~ Adam

Thank you to DrupalCon, and thank you to Seattle, for having such an amazing line-up of things to do for all of us that attended!

May 02 2019
May 02

Hook 42 is heading to Philadelphia for Drupaldelphia. Phew, that’s a mouthful to say! Not only are we proud to be sponsoring such a wonderful event, we’re excited to announce that Adam Bergstein will be giving two talks this year.

Dropping the Knowledge

To say we're excited about Adam's talks would be an understatement. To have a chance to share insights and experiences with other eager-to-learn individuals is something Adam enjoys, and he's looking forward to doing it again at Drupaldelphia.

Better Together: Impact Through Contribution

Adam will discuss his journey through the Drupal-verse, and explore ways to make a big community feel easier to navigate. With so many moving pieces, and people involved, it can be overwhelming at times to know what to do and where to find help. The moral of the story? When we all come together and pitch in, we can accomplish big things! Join Adam for an insightful journey through the community, and explorations of togetherness that make Drupal great.

SimplyTest.me - A Community Case Study

SimplyTest.me is a long-standing, free service that has the served Drupal community with an easy-to-use tool for creating Drupal sandboxes. During this case study, we’ll share the motivations behind SimplyTest.me and how the tool aims to lower the barrier of entry for those participating in the community. We’ll walk through the various use cases and features of the tool and examine how that helps anyone participate in our community. 

We hope you’ll come say hello if you stop in on one of Adam's sessions! If you're not interested in Adam's talks, don't fret! There are plenty of other interesting things happening at Drupaldelphia this year. Take a look at their website to browse other sessions, we're positive there is something for everyone. 

Sponsorship

Understanding the importance Drupaldelphia has on the community, we felt it necessary to spread the love and give back to our Drupal family. We enjoy helping our community in many ways, and sponsorship is just another way to contribute to a community that helps so many people develop valuable skills and long-lasting relationships.

The development of our community important to us. Providing support that paves a way for those to come together and learn from each other is a core value of Hook 42 and it applies to more than just our team. Thats why we try to be part of its growth just as much from the outside as we do from the inside. 

Philadelphia

Beyond the sponsorship and presentations, we’re happy to be back in the city of brotherly love. Those attending are looking forward to exploring the town and seeing some familiar faces. We hope you'll join Hook 42 in Philly for some good food, good culture and community contribution.

The real question though – when you get to Philly will you be going to Pat’s or Geno’s? Choose wisely!

via GIPHY

Apr 17 2019
Apr 17

DrupalCon 2019 was a bit different for me. I have attended previous DrupalCons, usually sitting in the back of the room just taking in all that I could from experts around the world. This year, however, I had the opportunity to be a speaker. Not only was I afforded the opportunity to speak, but I had two separate sessions accepted.

Talking the Talk

Being my first DrupalCon as a speaker, I might have had a few butterflies in my stomach when I arrived. Those quickly faded, and overall, my sessions on Stanford Cantor Arts Center Redesign and A Survey of Emerging Technology were very well received. I had an absolute blast presenting! Special shout-out to my partners in crime, Kristen Pol and Adam Bergstein, for making the transition from attendee to speaker fairly painless.

Stanford Cantor Arts Center Redesign

This talk was a broad review of our work with Stanford Cantor Arts Center that takes a deeper look at a few problems we faced during the build. There were complexities within the content structure and architecture that we needed to be able to accommodate. Flexibility was the most important part of this website. We walked through the solution to leverage UI Patterns module that allowed component based design, making the build process more practical while allowing content editors the ability to adjust as they see fit on certain areas of the site. 

Listen to the full talk on YouTube.

A Survey of Emerging Technology

Together, Adam Bergstein and I highlighted a set of tools that we know integrate well with Drupal and are used to tackle common roadblocks within the environment. I specifically spoke to the value of GraphQL and Gatsby.JS.

GraphQL provides a common interface for API queries. It is specifically notable for the ability to get information in a sole request, versus JSON requests that require multiple attempts before getting all the data. As far as its ability to play nice with Drupal, there is currrently a GraphQL module that is updated and supported by our community. The biggest benefit of using it within Drupal is for standardizing those onboarding into Drupal. Where they may hit roadblocks coming from the outside in, GraphQL makes the Drupal transition easier.

Gatsby.JS is a static site generator that uses static markup, but can still display dynamic information. What is great is you can bring your own backend into Gatsby.JS. Benefit, getting rid of a lot of vulnerabilities by not having any server-side code running. The vulnerability of a CMS is no longer a worry.

Other technologies covered were Hubspot, ElasticSearch, Pattern Lab, and Cypress.io.

You can watch the full video on YouTube.

More Than Presenting

Group of Hook 42 Team Members Working in Sprint Room

Beyond speaking, I had a fantastic time hanging out with the team, as usual. Every time we’re in the same location together I’m reminded of how talented, intelligent, and funny everyone is. It was especially awesome to get a chance to greet our three newest members of the team (Michael, Emanuel, and Lindsey) in person.

We spent a sizable chunk of pre-conference time sprinting on our company website, which was an amazing team-building exercise and really showed how much we can accomplish when we work together. So hopefully you’re reading this on the flashy, fancy new-and-improved hook42.com!

Overall, DrupalCon never ceases to provide an endless amount of opportunity. From spending time with colleagues, to working hard on new efforts, and even having new experiences like being a first-time speaker, I always look forward to what DrupalCon has to offer.

When I began my career at Hook 42, I made it a goal of mine to one day speak at DrupalCon. A long-term goal, but one that I worked very tirelessly to achieve. Getting the opportunity to share my expertise with others on the stage in Seattle felt like the perfect culmination of two years of hard work to get there. It felt amazing to check off my list.

Mar 12 2019
Mar 12

Every year community members from across the globe meet in Orlando for Florida Drupal Camp. This year Adam, Ryan, and Jonathan from Hook 42 attended. It was a fantastic time to connect with people, to learn, and enjoy some warmer weather. Plus, alligators!

Ryan and Adam led a training on connecting Drupal 8 and Gatsby.JS. The training utilized a set of Docker images that help people build everything from end-to-end on their own system. Attendees used the Umami demo, installed JSON API, and configured Gatsby.JS to pull recipes from Drupal. It was well attended and there was a lot of collaboration in the room. Our team appreciated all of those that attended - especially as we worked through technical and wifi issues. 

Ryan and Adam also gave a talk on emerging technology related to Drupal. Some of the topics included Cypress.io, Hubspot, ElasticSearch, GraphQL, Gatsby.JS, and Pattern Lab. It’s important for community members to find and use the right tool for the right job. As Drupal community members, we must be mindful of how these complementary technologies can serve us. You can watch the recording of the session on Drupal TV.

Team Member Reflections

Adam

I look forward to this camp each year, and once again this year did not disappoint. Thank you to “the Mikes”, Kyle, and Jordana for volunteering again. The time spent with the community was uplifting and encouraging - even if it was a bit tiring giving both a training and a session. The time spent with my colleagues Jonathan and Ryan, having barbeque, and drinking craft beer with the community all brought a lot of energy. I was able to reconnect with many friends and I always treasure those opportunities. Also, Jonathan and I unintentionally packed the same hoodies and Drupal Camp Asheville shirts. Twinsies!

The session quality was outstanding! Most notably, there were some incredibly great non-technical, people-focused sessions provided by Jordana Fung and Qymana Botts. I strongly recommend seeing both. Thanks, as always, to the amazing Kevin Thull, all sessions are recorded and posted to Drupal TV.
 
At the end of camp, on the contribution day, I was able to work on the proof-of-concept integrating SimplyTest.me and Tugboat QA. The result of which is a new Tugboat QA contributed module based on a Backdrop CMS module port.

Ryan

This wasn’t just my first time to Florida Camp, it was my first time in the state of Florida in general! What a great experience. I had a great time at the camp and really enjoyed speaking with a wide array of folks about decoupled Drupal and Gatsby.js, both through the training Adam and I conducted as well as hallway conversations. Brian Perry’s talk comparing various static site generators and their compatibility with Drupal proved really insightful. I was really excited about his demo of the Tome static site generator, which runs within Drupal itself.

Thanks a ton to the organizers - the camp was a lot of fun and I look forward to attending again next year!

Jonathan

My second time at Florida Drupal Camp was as good as, if not better, than my first. As a Drupal Camp organizer myself, I find Florida Drupal Camp to be inspiring. They manage to pull off being extremely well organized while maintaining a very casual air to the whole weekend. 

As an attendee, I had a unique (for me) experience this year. I went to Drupal Camp Florida without a computer and it was great! Without a laptop always in front of me I found myself more attentive to the session and more engaged in the camp in general. I enjoyed it so much that I will likely avoid taking my computer to future camps.

The sessions I attended were all wonderful and there are a few I’m still thinking about today. Here is a quick list, and my takeaways:

  • How to keep Drupal relevant in the Git-based and API-driven CMS era
    The Drupal island appears to be shrinking as the overall landscape for approaches to web development grows. It doesn’t hurt keeping an eye on the new ways to solve old problems.
  • How to Hire and Fire Your Employer
    Always a fan of these “being human” talks. In this one, April encouraged me to continuously evaluate my values as a person and how they match any given employer. “Life is too short to be miserable” is a powerful perspective to maintain.
  • An Introduction to Gulp
    I’ve been using Gulp and similar technologies for a number of years, but have almost always used someone else’s configuration. Tim makes it look easy to get started writing my own tasks, and I’m really looking forward to doing so on my next project.
  • The problem with Paragraphs, a return to rich fields!
    Maybe the only actual Drupal session I attended, it’s always great to see Hawkeye and get his perspective. In this session he opened my eyes to some serious problems with the Drupal community’s go to approach to solving complicated fields, the paragraphs module. By the end of the session, I was ready to start making custom rich/composite/compound fields for future projects.

Another top-notch Drupal Camp Florida in the bag. I’ll definitely be back next year, and if you’ve never been I highly recommend it.

Mar 08 2019
Mar 08

Look out for Hook 42 at DrupalCon 2019 in Seattle!

It’s that time again, another DrupalCon is fast approaching and our team couldn’t be more excited for this year’s Seattle event. We’ve got a lot in store for you this year, from presentations, BOFs, sponsorships, partnership collaborations, and using our listening ears. You’ll find our team distributed all about.

We’re bringing a stacked line-up of knowledge and experiences to drop on 'ya this year. Not only that, we’re looking forward to hearing all the ups and downs you’ve had this past year, and how we’re all growing together within the Drupal community. 

Let’s get to sharing!

Summits

Join us at the Performance and Scalability Summit on Monday. Hook 42 and Tandem have worked with the Drupal Association to line up leading speakers to cover scaling performant Drupal websites to scaling efficient Drupal development teams. The Performance and Scalability Summit is the place for developers, DevOps professionals, decision makers, and other technical stakeholders to plan for growth.

Talks

To hear from our experts, find us at one of our talks where we’ll review insights our team has experienced first-hand and how we’re adapting to the new and old needs of evolving technology.

Database Query Optimization in Drupal

Kristen talks all things database, and walks through how to put the sluggish operations behind you to optimize your Drupal environment. Covering the basic optimization steps isn’t always enough, exploring options past the basics will help streamline your Drupal environment for both front-end and back-end users.

Accessibility Deep Dive Workshop

Aimee is teaming up with Caroline Boyden, from UC Berkeley, to take a closer look at accessibility. Together, they’ll use real-world examples of how accessibility is best implemented, and how every member of your team can be part of accessibility, from designers to developers to content authors and everything in between.

Which Accessibility Tools are Right for You?

Aimee breaks down the best tools for implementing and testing accessibility, and the benefits and areas of improvement for these tools. Taking a look at what is available today, and how your team can take advantage of these tools to increase your website’s accessibility.

Drupal 8 Case Study – Stanford Cantor Arts Center Redesign

Kristen and Ryan join forces to walk through one of Hook 42’s latest client projects. Focusing on the implementation of good design and development, and how Drupal was the perfect place to house the dynamic technical needs of the team at Stanford.

A Survey of Emerging Technologies That Complement Drupal

Adam and Ryan are teaming together to talk about the latest tech to take advantage of Drupal’s flexibility and ability to interact well with modern advancements on the web.

Considerations of Federated Search and Drupal

Adam shines the light into federated search, its importance, and how you can implement this applications within Drupal. Taking a close look at how to pair the application with Drupal to minimize risk and increase cross-platform communications.

Sponsors

Women in Drupal Luncheon

We’re proud to sponsor the Women in Drupal Luncheon, fostering inclusivity and empowerment within the Drupal community. We’ll gather to enjoy delicious food, talk shop, and relax amongst professionals.

BOF

Simplytest.me

VP of Engineering, Adam Bergstein maintains the SimplyTest.me service leverage by the Drupal community for testing and prototyping community contributions. Join him for a BOF on Wednesday! We want to chat with you all things about our go-to browser testing tool for all our Drupal projects.

Adam is also sorting out the Drupal Coffee Exchange meetup. 

Partner

Lingotek Session: Avoiding Trouble Spots When Creating a Multilingual Site

Our partner, Lingotek, has organized a session revolving around the challenges with multilingual websites. Through the session you’ll learn about common challenges with multilingual websites, and how you can get ahead of those issues. We’ll be there to support Lingotek and help answer questions during the session.

We Hope To See You There

If you haven’t already registered for DrupalCon Seattle, get on it! We’re ready for yet another amazing DrupalCon adventure, and we’re looking forward to seeing old and new faces in the crowd.

via GIPHY

 

Dec 13 2018
Dec 13

This is the first of many articles about why and how to give back to the community. The information can be used by individuals, agencies, and companies that want to increase their community contribution efforts. 

'Tis the season for giving. A time of giving thanks for the blessing of the harvest and of the preceding year. A time of light in the dark of winter; a season of reflection and thanks. I’d like to recognize the work and efforts of the Drupal Community and reflect on Hook 42’s historic contributions; additionally, I'd like to share how we contribute and how you can contribute more. 

But why listen to Hook 42? We are not one of the largest Drupal agencies; however, Hook 42 was ranked 18th in the list of the global contributors by Dries. We also strategically shaped and sponsored the community efforts of one of the top 30 contributors to the project. 

Hook 42 has a fairly humble approach when sharing our community contributions data. We usually let our team’s commit numbers, sessions, logos, and event organization speak for our continued dedication to the fostering the Drupal community. 

For full disclosure, Kristen Pol and Aimee Degnan (myself) are co-founders / owners of Hook 42, a full-service web development agency specializing in Drupal. We are based out of San Francisco and we have team members distributed across the United States.

Make a Commitment to Contribution

First of all, you must want to contribute. Everyone has different reasons to contribute and how you personally contribute is your own path. It is a deliberate decision that must be turned into action.

The first steps into contribution may be attending a Drupal users group, camp, or logging into Slack or IRC for support. At this point, you meet the community and learn how to further contribute. Hopefully, the Community has been inviting enough that you want to stay. :)

When Kristen and I started Hook 42, we chose “Contribute to Community” as one of our core values. This decision created the foundation for our culture of contribution. We both personally contributed to the project and community in different ways and found great value from giving back. All of our team members have the desire to contribute to community efforts; the passion and self-starting ability to contribute is vital.

Another one of our values, “Ongoing Education and Improvement”, is a strong motivator for our contribution efforts. The Drupal project, and its supporting events, provide a fantastic opportunity for professional development. Coding, documentation, speaking, organization, and volunteerism; there are so many opportunities for growth that are beyond our client work or formal training classes.

I want to thank those organizations and individuals that have made community contributions a deliberate part of their work and life. We are not the only company to do so. We are not the only individuals to do so.

Invest in Contribution

Once you decide contribution is important, a real investment must be made. Contribution takes time. It takes skill. It takes practice. And it also takes money. 

A patch isn’t going to write itself, test itself, or be committed back into the project itself. Documentation must be written and copy edited. Events need to be sponsored and organized.

Hook 42 sponsors 15% of the team’s overall work hours to community contribution. Doing the math, 15% is roughly 4,000 - 4,500 hours of work per year donated to the Drupal community. That is time Hook 42 is not making a profit and is considered a completely operational cost. The work is performed within a normal 40 hour work week for our team members; another value of ours is "Strive for Work and Life Balance".

Our clients also sponsor contributions through the course of project work, session presentations, and case studies.

The 15% metric of sponsored community time does not include the amount of money spent for sponsorship, travel, or one-off support of community contributions like DUG dinners, code sprint snacks, and other community-focused spend. 

An individual’s personal level of investment will probably be much different from a business. The personal investment may include patches, testing, sessions, and camp attendance but is often constrained by personal budget and time one is wanting to commit.

Personally, Kristen and I contribute differently. Both of us organize events, speak, attend conferences, work on core initiatives, and mentor individuals within the community and the team. I contribute less code because my role is more related to business topics (although I’m highly technical); whereas, Kristen’s contributions are more commit and documentation related. This is just an example of how contribution profiles may differ.

From a business perspective, it is both of our jobs to provide a stable environment and work to provide our team members the opportunity to contribute. Consider us “Community Force Multipliers” that strategically align our team’s work with community efforts while we, personally, do less of the commit-centric work.

Many of our team members, including Kristen and myself, contribute additional personal time on top of work-sponsored hours. Those that do are passionate about the community and are active in event organization, preparing sessions and trainings, and participating in sprints. Plus, Kristen and I have to keep the business running regardless of our personal community efforts. Someone has got to keep the lights on. 

I want to thank those organizations and individuals that have made the investment in the community. We are not the only company to do so. We are not the only individuals to do so.

Ongoing Commitment to Contribution

But why do Kristen and I choose to contribute so much to the community? Why do we keep contributing? The two of us drive Hook 42’s budget and time invested in community efforts. Don’t we want more profit or more money in our pockets?

As business owners, we believe that supporting the Drupal project and community ecosystem is an investment in our ongoing business. All people using Drupal must contribute - at their own ability level - to Drupal to keep the platform viable and supported. That contribution can be as easy as active use of the platform.

Improving Drupal isn’t just about benefits to our company, or benefits to Drupal independent contractors, and other Drupal service providers. Improving Drupal benefits organizations using Drupal, so they can have confidence that their choice is a sound investment over time. Again, contribution as a business is not about us, it is about supporting people building their businesses on Drupal.

As people managers, the community ecosystem and the Drupal and Drupal-adjacent technologies provide a great environment for ongoing learning and professional development for our team. Kristen, myself, and Adam help our team members and others in the community find the best fit of work for their goals.

As individuals, honestly, we love the people and the community environment. One of our other company values is “Be Ethically and Morally Good”. As good members of the community, we understand that our individual choices and actions can benefit the greater good of Drupal. 

But I have to admit, sometimes it is a challenge. For all who choose to contribute, you will also be more visible to a diverse, global group of individuals. You may receive criticism for your work or opinions that may not seem agreeable. Kristen and I have been told that the support we provide, both personally and through the business, is not enough. Perhaps without visibility to the actual data of our total contributions, others may not understand the amount of our personal investment in the project. Thankfully, that was an edge case and not the norm. Overall, most community members have provided positive feedback to our sponsorship efforts.

Why don’t we just give up? How much more are we supposed to do? How much more are we supposed to give?

Honestly, constructive criticism and differing opinions make the product and the people improve. No one improves if they are unaware there is room for change.

We constantly renew our commitment to community because we love the people we work with. It brings us great joy to work with such creative and enthusiastic people.

I want to thank those organizations and individuals that recommit their efforts to the community, even after heavy public criticisms. We are not the only company to do so. We are not the only individuals to do so.

Season of Giving Beyond Drupal

I want to thank those organizations and individuals that provide donations to charities throughout the year at different community events. This type of altruistic approach to charitable donations represents the quality of the people in the Drupal community.

Hook 42 has donated to the following charitable organizations chosen by our team members. Some of the organizations were selected by multiple members:

Learn how you can be a top contributor in our next Community Post: The How-to Guide to Successful Contribution.

Dec 10 2018
Dec 10

Nowadays everyone has an API and it's fairly common to want a website you're working on to fetch data from a 3rd party API. That's because pulling 3rd party data into your website can not only enriches your website's content, but doing so can prevent the need to duplicate commonly needed data.

API provided data could include displaying weather information, going through drupal.org projects, looking through census results, or even displaying Magic the Gathering card data. In fact, every WordPress site comes with an active JSON API out of the box.

There really is an API for almost anything. It's no surprise that you'll eventually want to consume some random API while developing a Drupal website. Enough of the sales pitch, let's get started consuming JSON APIs.

The Plan:

  1. Look at what it takes to fetch and consume JSON data in general.
  2. Explore the popular Guzzle PHP library.
  3. Create a Drupal 8 module that consumes an API and displays the data on your website.

Seems pretty straightforward huh? I think so too, but before we go any further let's define some of the terms that appear throughout this post.

  • API - Application Programming Interface. Literally, "a thing developers can use to interact with another program".
  • Request - An interaction with a web API. Very similar to visiting a website in your browser. When you visit a website in your browser, you are making a "request" to the website's server.
  • Base URI - Part of a URL that is the root of a web API request. This tends to be a domain name such as "api.mywebsite.com", but can also include a path such as "mywebsite.com/api".
  • Endpoint - Part of the URL for an API request that usually defines what type of data you are requesting. For example, one of the most common WordPress API endpoints is "posts", which retrieves Posts from the WordPress website.
  • Query Parameters - Part of the URL for an API request that further describes the specific data you are requesting. Query parameters look like key-value pairs within the URL for the API request.

Here is an example on an API request URL:
http://demo.wp-api.org/wp-json/wp/v2/posts?per_page=2

And here is how that API request URL breaks down into the terms defined above:

  • Base URI - http://demo.wp-api.org/wp-json/wp/v2/
  • Endpoint - posts
  • Query Parameters - ?per_page=2

Hopefully that helps clarify some of the terminology used throughout the rest of this post.

Getting Started: Fetching JSON in PHP

The first thing we want to look at are the basics of getting data from an API. We need the following things:

  1. A public API that will provide us with data.
  2. A way to visit the API and get its data.
  3. A method of converting the raw data the API gives us into an array so we can easily process and output it as we see fit.

Broken down into their tiniest pieces, each of the above needs are fairly straightforward. Out of the box, PHP provides us with a function that handles both visiting an API and getting its data in file_get_contents(), as well as another function for converting that raw string data into an array in json_decode().

As for the public API… I'd like to introduce you to Cat Facts, a public API that will provide us with all the facts about cats we could ever want!

Let's put all these pieces together and write a simple PHP script that will consume the Cat Facts JSON data.

<?php
$data = file_get_contents('https://cat-fact.herokuapp.com/facts/random?amount=2');
$cat_facts = json_decode($data, TRUE);

foreach ($cat_facts as $cat_fact) {
  print "<h3>".$cat_fact['text']."</h3>";
}

Result:

There we go. Now we can use this technique to get as many random Cat Facts as we want (up to 500 per request). But before we continue, let's break down this script a bit and see what it's doing.

  1. First we use file_get_contents() to request the data from the API.
    (The response data comes back to us in the form of a string.)
  2. Next we convert it into an Array using the json_decode() function.
  3. Now that the data is an array, we can loop through it and output all of our brand new cat facts. Outstanding!

Note: I didn't make up the URL shown in this example, I read the documentation. You can visit that API request URL directly and see what the response data looks like. Go ahead, I'll wait here…

… Welcome back!

Check this out: Most APIs you interact with will have its own documentation that you should use when planning your project. If you find yourself struggling to figure out how to get data from an API, look for more documentation. Documentation is king when dealing with APIs. The better the documentation, the better the API in my opinion.

Object Oriented API Requests with Guzzle

Now that we have a decent understanding of the main points of requesting data from an API, let's take a look at how we might do that in a more practical and modern way. Let's use the very popular PHP HTTP client named Guzzle to do basically the same thing we just did above.

The main differences in using Guzzle are mostly around the abstractions provided by Guzzle's Client library. Rather than trying to describe each difference out of context, let's look at an example:

<?php
require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client([
  'base_uri' => 'https://cat-fact.herokuapp.com/',
]);

$response = $client->get('facts/random', [
  'query' => [
    'amount' => 2,
  ]
]);

$cat_facts = json_decode($response->getBody(), TRUE);

foreach ($cat_facts as $cat_fact) {
  print "<h3>".$cat_fact['text']."</h3>";
}

Let's paws for a moment and review what has changed and why:

  1. The first thing to note is that we've created a new instance of Guzzle's Client object and passed in some parameters as an array. Rather than provide the entire URI for the API's endpoint along with query parameters in one string like before ('https://cat-fact.herokuapp.com/facts/random?amount=2'), we will instantiate the client with just the base URI for the API in general. This way we can easily make multiple requests to multiple endpoints with the same Client object.
  2. Next, we use the Client's get() method to request a specific endpoint of 'facts/random'. Internally Guzzle will combine the endpoint with the base_uri we provided during object instantiation.
  3. Additionally, we provide an array of query parameters to the get() method. Internally Guzzle will convert this array into a query string that looks like this '?amount=2' and append it to the URL before submitting the request to the API.
  4. Unlike file_get_contents(), the Guzzle client returns a Response object. This object contains much more information about the reply from the API, as well as the contents of the response.
  5. Finally, we access the contents of the response by using the getBody() method on the Response object.

It may seem like a lot has changed from our first example, but I highly recommend becoming more comfortable with this approach. Not only is it significantly more powerful and flexible than the file_get_contents() approach, but also because Drupal 8 uses the Guzzle library.

Ultimately, both this and the previous example are doing the exact same things. They are both visiting the Cat Facts API and fetching data.

Now that we are comfortable with requesting data from an API (aka, visiting a URL), I think we're ready to do this in Drupal 8.

Guzzle in Drupal 8

The plan is simple; create a Drupal 8 module that fetches cat facts from the Cat Facts API and displays those facts in a Block.

There are a few ways to accomplish this, but we'll start with the most basic. Have a look at this custom Block:

<?php

namespace Drupal\cat_facts\Plugin\Block;

use Drupal\Component\Serialization\Json;
use Drupal\Core\Block\BlockBase;

/**
 * Block of Cat Facts... you can't make this stuff up.
 *
 * @Block(
 *   id = "cat_facts_block",
 *   admin_label = @Translation("Cat Facts")
 * )
 */
class CatFacts extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    /** @var \GuzzleHttp\Client $client */
    $client = \Drupal::service('http_client_factory')->fromOptions([
      'base_uri' => 'https://cat-fact.herokuapp.com/',
    ]);

    $response = $client->get('facts/random', [
      'query' => [
        'amount' => 2,
      ]
    ]);

    $cat_facts = Json::decode($response->getBody());
    $items = [];

    foreach ($cat_facts as $cat_fact) {
      $items[] = $cat_fact['text'];
    }

    return [
      '#theme' => 'item_list',
      '#items' => $items,
    ];
  }

}

Block Output:

At first this looks like a lot more code, but most of the new stuff is the code necessary to create a Drupal 8 block. Rather than focus on that, let's look at the important difference between this and the previous example.

  1. Drupal core provides a service designed to create HTTP clients: 'http_client_factory'. This service has a method named fromOptions() which accepts an array, just like the Guzzle Client constructor did before. We even passed in the exact same parameter.
  2. Instead of calling json_decode() function, we use the Drupal provided Json::decode() method.

Note: We could have instantiated our own Guzzle Client object, but the above approach has the following added benefits:

  • First, Drupal is going to merge our options array into a set of its own options that provide some HTTP request best practices.
  • Second, using this method (somewhat) future proofs us from major changes in the Guzzle library. For example, if Drupal improves its http_client_factory service, or even decides to switch libraries all together, we'd like to believe that the core developers will take on the burden of ensuring the http_client_factory service still works the way we expect.
  • The same reasoning applies to using the Json::decode() method Drupal provides as opposed to the json_decode() function.

Generally, whenever Drupal provides a way to do something, you should use the Drupal way.

Now this is all very good, we're making API requests the "Drupal Way" and we can place it almost anywhere on our site with this handy block.

But, I know what you're thinking. You're thinking, "Jonathan, Cat Facts shouldn't be contained to just a block. What if I want to use cat facts somewhere else on the site? Or what if another contributed module wants to make use of these awesome Cat Facts in their own module?"

And you're totally right to be thinking that. Hence...

Cat Facts as a Service (CFaaS)

There is no better way to make Cat Facts available to other non-block parts of your site and other contributed modules than to provide a Cat Fact service in our own module. I can see it now, with such a powerful feature our Cat Facts module will soon be a dependency of almost every other popular Drupal 8 module.

First thing we need to do is define our new Cat Facts service in our module's services file.

cat_facts.services.yml

services:
  cat_facts_client:
    class: Drupal\cat_facts\CatFactsClient
    arguments:
      - '@http_client_factory'

Purrfect.

Next, we need to write this new CatFactsClient class. It will look relatively similar to the work we've done already; but, this time instead of calling the Drupal::service() method, we'll use dependency injection to provide our CatFactsClient class with the http_client_factory core service automatically.

src/CatFactsClient.php

<?php

namespace Drupal\cat_facts;

use Drupal\Component\Serialization\Json;

class CatFactsClient {

  /**
   * @var \GuzzleHttp\Client
   */
  protected $client;

  /**
   * CatFactsClient constructor.
   *
   * @param $http_client_factory \Drupal\Core\Http\ClientFactory
   */
  public function __construct($http_client_factory) {
    $this->client = $http_client_factory->fromOptions([
      'base_uri' => 'https://cat-fact.herokuapp.com/',
    ]);
  }

  /**
   * Get some random cat facts.
   *
   * @param int $amount
   *
   * @return array
   */
  public function random($amount = 1) {
    $response = $this->client->get('facts/random', [
      'query' => [
        'amount' => $amount
      ]
    ]);

    return Json::decode($response->getBody());
  }

}

What we've done here is create a simple class that focuses solely on the Cat Facts API. It abstracts most of the work you would normally have to do when you need to request data from the API by providing a method named random(). This method performs the HTTP request and return a decoded array of data back to the caller.

Finally, all we need to do is update our Cat Facts block to allow our new service to be injected into it as a dependency.

src/Plugin/Block/CatFacts.php


<?php

namespace Drupal\cat_facts\Plugin\Block;

use Drupal\Core\Block\BlockBase;
use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Block of Cat Facts... you can't make this stuff up.
 *
 * @Block(
 *   id = "cat_facts_block",
 *   admin_label = @Translation("Cat Facts")
 * )
 */
class CatFacts extends BlockBase implements ContainerFactoryPluginInterface {

  /**
   * @var \Drupal\cat_facts\CatFactsClient
   */
  protected $catFactsClient;

  /**
   * CatFacts constructor.
   *
   * @param array $configuration
   * @param $plugin_id
   * @param $plugin_definition
   * @param $cat_facts_client \Drupal\cat_facts\CatFactsClient
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, $cat_facts_client) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->catFactsClient = $cat_facts_client;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static(
      $configuration,
      $plugin_id,
      $plugin_definition,
      $container->get('cat_facts_client')
    );
  }

  /**
   * {@inheritdoc}
   */
  public function build() {
    $cat_facts = $this->catFactsClient->random(2);
    $items = [];

    foreach ($cat_facts as $cat_fact) {
      $items[] = $cat_fact['text'];
    }

    return [
      '#theme' => 'item_list',
      '#items' => $items,
    ];
  }

}

And there we have it! Now our block has the cat_facts_client service injected into it during creation. And rather than the block making its own Guzzle Client and API calls, it uses our shiny new service.

Ya feline it?

View module code on GitHub.

Nov 08 2018
Nov 08

Now that I’ve settled back down in Alaska after a fun trip to Berkeley for BADCamp, I’m finally digesting all of the info I gathered throughout the week. As always, it was cool to look over the schedule and see what topics were getting a lot of attention; and, without a doubt, it seemed like GatsbyJS was the hot-ticket item this year. So here’s a primer on what GatsbyJS is and why the Drupal community seems so head-over-heels for this up and coming site generator.

What is GatsbyJS?

For the uninitiated, GatsbyJS is a static site generator for React which allows you to compose a website using React components and JSX. Then, with a “Gatsby build” command, the entire React app gets compiled into a set of static HTML, JavaScript, and CSS files.

However, this is nothing new. Static site generators like Jekyll or Hugo have been doing this for years. So, what makes Gatsby so popular, especially within the Drupal community? Judging by the sentiments I heard from the four sessions on Gatsby I attended at BADCamp, I noticed that folks tended to gravitate toward a few essential features that made Gatsby appealing, not only as an integration with a Drupal backend but also more broadly.

Gatsby’s Drupal Source Plugin

The feature most commonly cited in BADCamp talks about Gatsby was the source plugin ecosystem, which allows a developer to define a backend “source” from which Gatsby will build pages. There is a robust and well-developed plugin for Drupal 8 (gatsby-source-drupal), which allows Gatsby to programmatically create content from Drupal’s content types, taxonomies, as well as blocks and menus.

The plugin works like this: first, you must enable the JSON API module, which exposes routes and schemas that help Gatsby import your content into your Gatsby application. Then, on the Gatsby side, you are able to query the data from your Drupal site using GraphQL and render the query results to various React components, such as page templates.

Build/Deploy Workflow

Secondly, the architecture around deploying/building a Gatsby site lends itself well to working with Drupal - using something like the Webhooks module, you can have your Gatsby site rebuild (and thus, pull new content) on every node create, update, or delete operation, and so forth.

This is very important, considering that most static sites are perceived as being labor intensive (in the sense that every time content is updated, someone needs to recompile the site); but, to hear Gatsby co-founder Sam Bhagwat talk about it, the ready availability of on-demand build triggers and integrations makes your static site actually perform much more like a cache. However, it’s the sort of cache that doesn’t require maintaining a highly technical caching stack like Varnish or Memcache. After the minute or two it takes for the build step to complete, your changes have completely propagated and site visitors are being served the new content.

React

Love it or hate it, React is here to stay. It is rapidly becoming the most common front-end stack in web development. Although it may not be for everyone, most developers who have spent the time to learn React tend to fall hard for it. Heck, this year’s Stack Overflow Annual Developer Survey puts React as one of the most “loved” frameworks by developers this last year, with 69.4% of respondents reporting that they enjoy working with React. Obviously, something is working for React in terms of developer experience. Being able to implement a React front-end without the architectural concerns of a complete decoupled solution certainly seems to be one of the bigger motivating factors behind Gatsby’s adoption among Drupal developers.

Performance

Last, but certainly not least, Gatsby’s appeal comes largely from speed. As mentioned above, since everything is served from static files, Gatsby sites load really fast. Without any server-side code to execute, the only limitations on performance are in the size of HTML/CSS/JS bundles being served over the network. When folks in a traditional Drupal site (or any other monolithic CMS) concoct solutions for better performance there are a few usual suspects:

  • better caching
  • reducing bundle sizes (minifying JS and CSS, for example)
  • optimizing images
  • serving non-dynamic site files (such as images) from a CDN

Out of the gate, a Gatsby site effectively implements all of these features by default. Since the entire site is a set of static files, your content is effectively ‘cached’ to the state of your website as of the last executed build, and the flat files that are generated from the build perform similarly to cache catch. Likewise, because Gatsby runs a build step, our entire HTML/CSS/JS bundle is minified from source using Webpack. No configuration required! Gatsby also comes pre-wired with a bunch of image optimization, including using the Sharp image processing library and progressive image loading to get a contentful, interactive page rendered as quickly as possible. And lastly, with a completely static site the most common way of hosting the site is through a CDN - some popular ones among Drupalers who use Gatsby include Netlify and Amazon S3. On top of all of that, Gatsby also has some other nifty built-in features like prefetching, which means that after the initial page load you’ll get lightning-quick performance between internal pages on your site.

Limitations

Of course, most folks discussing Gatsby + Drupal implementations at BADCamp were quick to acknowledge Gatsby’s limitations. First, and most notable among the limitations, is the inability to use conventional user-submitted data. If you wanted to define a webform and render those results into a views-generated table, that would be pretty straightforward in a conventional Drupal 8 site. In a Gatsby site, however, it would be much more complicated. Likewise, for many of the ‘nice to have’ out of the box things that Drupal gives us - authentication, custom user roles, and access restriction, etc. – they all need to be effectively re-engineered if we want to implement them on our Gatsby front-end. That said, we could certainly continue to do many of those things in Drupal, but in the emerging conventional patterns of using Gatsby and Drupal together, it is unclear what the ‘best practices’ method is for handling those use cases.

All in all...

I think it’s really interesting to see this attention and centralization on Gatsby as a defacto solution for decoupled Drupal sites. While there are plenty of limitations, Gatsby seems like an interesting solution for some of the characteristic decoupled problems that many decoupled Drupal devs are very familiar with by now.

And, as always, this year’s BADCamp was really great to get a chance to see the Hook 42 team – it’s amazing that we “see” each other so often online, but once we’re all together I’m reminded of what a smart, funny, and fun group of people we are. Can’t wait to see everyone again!

Oct 17 2018
Oct 17

Keyboard accessibility is vital, as many assistive devices emulate the keyboard. Using semantic HTML one can achieve an accessible User Interface (UI) with less code than non-semantic markup.

By managing and guiding focus with semantic HTML, developing an accessible UI is rather easy. Semantic HTML plays an important role in not only accessibility but SEO (Search Engine Optimization) as well. Although we are aware of it, it's often overlooked.

In September’s accessibility talk, Sarbbottam Bandyopadhyay shared the trade-offs of using semantic vs non-semantic markup with an everyday example. He also shared how to manage and guide focus. It was a brief presentation emphasizing the various aspects of keyboard accessibility. He concluded with a brief introduction to WAI-ARIA.

Sarbbottam is a frontend engineer, with more than 14 years experience. He currently works at LinkedIn. He is part of LinkedIn's core accessibility team, focusing primarily on web accessibility. He’s been involved with web accessibility since his Yahoo days.

Takeaways:

Keyboard Accessibility is addressed in the “Operable” principle of the WCAG: Web Content Accessibility Guidelines.

Many users with motor disabilities rely on keyboard navigation. Using a mouse or trackpad can be difficult because it takes a lot of fine motor skills.

WCAG: Web Content Accessibility Guidelines 2.0 - P-O-U-R:

P - Perceivable: Information and user interface components must be presentable to users in ways they can perceive.

O - Operable: User interface components and navigation must be operable.

U - Understandable: Information and the operation of user interface must be understandable.

R - Robust: Content must be robust enough that it can be interpreted reliably by a wide variety of user agents, including assistive technologies.

The WCAG 2 Quick reference guide has done an excellent job organizing and categorizing the POUR guidelines.

Many assistive devices emulate the keyboard

To be keyboard accessible, the website’s user interface must be navigable and operable via the keyboard. Arrows are used for widgets and groups; for example, radio groups or dropdowns.

Tab and arrow keys are used primarily to navigate. 

Enter and space are the primary keys used to operate.

Most common issues:

Mouse only interaction:

This an interaction that can only be accessed using a mouse or pointing device. There is no way a keyboard user can access this functionality.

No focus indicator:

Focus indicators visually identify the current active element on the screen. The focus indicator is often suppressed using CSS. As a result, keyboard-only users are not being able to access content or know where they are on the screen.

Sarbottom has developed a Chrome extension, called Focus Indicator, which forces focus on active highlighted elements.

Focus indicator is the equivalent to mouse pointer, so, 'focus outline: none' is equivalent to 'cursor: none'. We wouldn’t use 'cursor: none', so we shouldn’t use 'focus outline: none'.

Non-deterministic navigation:

It is expected that a tab press will focus on the next visible element in a logical order. The tab order must be in sync with the visual order. When the tab order does not match a user’s expectations, it creates a cognitive overhead.

To have deterministic tab order, avoid using positive tab indexes and CSS to change the visual order. Rely on the DOM (Document Object Model) order for for visual and tab order.

Efficient navigation:

A keyboard user expects the actionable elements in a dynamic apps UI to be navigated by a subsequent tab press.

We can avoid these common issues and pitfalls

Use Semantic HTML

  • It is not only important for accessibility, it is important for SEO
  • Semantic HTML allows the markup to be system, software, or machine interpretable.
  • Using semantic HTML results in less code.

WAI-ARIA

ARIA or WAI+ARIA (Accessible Rich Internet Application) is a set of additional HTML elements that enhance the accessibility of web content by providing extra information.

There are three areas of ARIA attributes:

  • Role - defines what an element is or what it does.
  • State - conveys the current state of the element.
  • Property - adds additional information to an element, like relationship.

Note: The semantic information provided by ARIA attributes supersedes the native HTML semantics.

The first rule of ARIA is to not use ARIA.

Focus management:

By managing focus, we can ensure that the dynamic interaction and UI transitions are accessible. On UI updates, focus the corresponding HTML node programmatically. An HTML element can be focused by JavaScript invoking the focus method upon it. Focusing a container programmatically serves as a guided context switch.

Any subsequent tab press will focus the next focusable element, which enhances the keyboard user’s experience.

Guided Focus Management:

Guided focus management enhances the keyboard user’s experience. It allows the screen reader to read out the textual content of the focused container letting a visually challenged user be aware of UI updates. There are situations when the focus cannot be shifted from the context.

WAI-ARIA can be used to provide spoken feedback.

To wrap it up...

Get romantic with semantic and focus on focusing.

YouTube Video

Accessibility Talks September 2018 - Sarbbottam Bandyopadhyay - Love Thy Keyboard

Links mentioned in the talk:

Drupal Accessibility Group

Join the Accessibility group on Drupal.org for hints, tips, discussions, and patch proposals to help make Drupal more inclusive.

A11yTalks on Twitter

Follow us on Twitter and use the hashtag #a11ytalks to follow the conversation.

Sep 23 2018
Sep 23

HubSpot provides a powerful combination of customer relationship management (CRM) features and insights that can help organize and maintain business processes tied to customers. Drupal is a key digital platform for businesses, especially for inbound customer engagement, marketing initiatives, and 3rd party integrations. The two systems are highly complementary and deserve consideration for logically separating the responsibilities of digital engagement and customer relationship management. Additionally, both HubSpot and Drupal are very flexible and customizable. As an example, both systems support extensible data structures through custom fields in HubSpot and through the entity system in Drupal that allow for implementation-specific data to be stored and maintained.

Federated Drupal + HubSpot Approach

So you like the idea of using a CRM, but is it really worth all the trouble to integrate it tightly with your Drupal site? Are you afraid of commitment? There’s an interim step you can take before getting married to using HubSpot as your CRM.

If your data isn’t updated multiple times a day, you can work with HubSpot without tightly coupling your data integration. This approach involves using HubSpot’s batch update API. For example, with a regularly scheduled job to grab your active records and upload the relevant fields, you can keep HubSpot aware of your more recent data such as contact information. You get all of the HubSpot goodness without having to change your Drupal code since you get the data directly from your database.

We applied this approach for a Drupal system that isn't really a standard "website" but, instead, a very complex web application with a regularly-updated, separate data warehouse. Users are selected for data inclusion after a series of prior steps involving the end user, customer relations, and third parties. There are hundreds of these records a day which is only a very tiny subset of the site's daily data.

This approach leveraged the data warehouse in AWS, but you could do it against your production database as long as you keep an eye on query efficiency and server load. A CRON job to retrieve updated data was implemented in AWS Lambda, their serverless code platform, but it could also be implemented with a CRON hook in Drupal. While Lambda offers lots of coding choices, PHP isn’t one of them. Fortunately Python is. This approach also allowed us to rapidly prototype and implement our solution without impacting the production system.

Lambda jobs automatically log their output with AWS CloudWatch. After becoming familiar with HubSpot API errors, we built CloudWatch alarms which report to Simple Notification Service (SNS) for notification.

Unified Drupal + HubSpot Approach

While it's more advanced and complex, Drupal’s APIs allow for a much more refined, tighter integration if it is desirable. HubSpot maintains web service APIs for all of its various data objects. Developers can leverage these APIs and the various hooks/events within Drupal to synchronize data bidirectionally.

One common use case is a form in Drupal that end users engage with. The HubSpot module offers Webform integration specifically to HubSpot’s Leads feature. This is a concise, but relevant, single-direction use case in which Drupal can send Webform submissions to HubSpot. This allows for capturing inbound leads within a Drupal system and synchronizing that data to HubSpot.

Drupal’s development framework also supports more nuanced and implementation-specific approaches beyond just the Drupal Webform and HubSpot Leads integration. The HubSpot API module leverages a Composer dependency and Drupal service to integrate a PHP SDK within the Drupal application. This service can be programmatically invoked in any Drupal hook or event. Most CRUD-related runtime hooks programmed into a module allow for any data or transaction to be sent to a corresponding HubSpot entity. For instance, having a user-related hook to synchronize specific Drupal users with HubSpot customers can allow for interactive Drupal applications (commerce, collaboration platforms, etc.) to automatically send customer-related information from Drupal user profiles.

Drupal offers other advanced integration options with HubSpot. Drupal’s CRON system can be used to routinely pull data from HubSpot. This is helpful for creating advanced dashboards and data visualization within Drupal that is potentially tied to a single user-based experience. For instance, a user in Drupal could have a unified experience in which their HubSpot campaign data can be shown in a single dashboard in Drupal without potentially having to log into multiple systems.

The user-based example can be extended with some other key features of Drupal’s provided framework:

  1. Drupal’s Entity API can be used to create a custom entity to track unprocessed users and the state of HubSpot-related operations within Drupal.
  2. Reports can be generated in Views to easily list the tracked entities, like when they were created, when they were processed, their state, and more.
  3. Drupal’s log subsystem can maintain the set of activities tied to the user tracking entities and store HubSpot-generated responses from the API. This helps with failures, which is common for large scale sites with HubSpot’s API rate limiting.
  4. Drupal’s queue subsystem can offer opportunities to leverage CRON in staggering user requests instead of at runtime. This is advantageous should the HubSpot API go down or have slow performance, as there is a built-in failure state. Additionally, operations can be batched which helps avoid hitting API rate limits.

Conclusion

Drupal and HubSpot have a lot to offer each other as complementary solutions. Whether you want a more lightweight, federated approach or a tightly-coupled integrated approach, both Drupal and HubSpot offer enough extensibility through their frameworks and APIs to make even the most complex of use cases happen.
 

Sep 21 2018
Sep 21

The BADCamp Circus is coming to town for 4 whole days! From cities near and far, Drupalists are converging in Berkeley very soon for this year’s circus-themed BADCamp!

Join Hook 42 under the bigtop for 3 unique sessions. We’ll be sharing our thoughts on redesigning the Stanford Cantor Arts Center website, accessibility tooling, and creating custom Drupal 8 modules. Of course, the whole team will be there too, collaborating with new and old friends alike.

Join us as we flex our Drupal muscles, perform daring acts of development, and add to the general merriment of the Drupal community. BADCamp 2018 is sure to not disappoint!

Sessions:

Drupal 8 Case Study – Stanford Cantor Arts Center Redesign

Ryan Bateman and Kristen Pol | Friday, October 26, 2:30 - 3:15 PM | Sibley

In the Spring of 2017, Stanford’s Cantor Arts Center came to Hook 42 with a project to redesign their aging website with a shiny new Drupal 8 website that would allow the museum’s exemplary visual arts exhibits and photographic assets take center stage. What followed was a development cycle full of rigorous content strategy, front-end design, and back-end development that culminated in the newly-launched Cantor Arts Center website.

This session will expand upon our methodology and thought process in arriving at each aspect of the site’s development, including:

Intended Audience:

Anyone interested in content strategy, migrations, and flexible components will benefit from this session.

Which Accessibility Tools Are Right For You?

Aimee Degnan | Saturday, October 26, 11:15 AM-12:00 PM | Tilden

As an organization who needs to step up their accessibility (a11y) compliance, accessibility testing and remediation is a big deal.

Accessibility testing has a lot of moving parts! There are so many tools. So many! Plugins, suites, crawlers, dashboards, CI tests, and more.

  • Which one is right for you?
  • Will only one fit all of your needs? ;)
  • Build vs. buy some vs. buy vs. free? Is "free" free?

This is not a session about "what tools did our team use". This is a broader overview of the a11y testing tool types, challenges and benefits of the different types, rough costs (when applicable), and the best use cases for them.

When searching for tools, you can find lists of tools, but not comprehensive comparisons of tools to make the decision of which one(s) to use and buy for your need.

We compared a vast amount of tools to analyze and choose the best for our need as a digital agency specializing in accessible design and development and for our clients' needs as public entities requiring multiple levels of compliance.

A developer's tool needs (and budget) may be much different than a larger organizations need for multi-site dashboards and reporting experiences.

All levels of experience can get value out of this session.

Target audiences:

  • Tool procurement teams 
  • Developers (get a list of tools for a11y testing)
  • Website "Owners" / Stakeholders responsible for compliance
  • Project Managers
  • Dev Team Managers

Drupal 8 Custom Module Architecture: What’s Going On?

Lindsay Gaudinier | Friday, October 26, 4:45 PM-5:30 PM | Sibley

It is all fun and games modifying existing code, but what about when you have to venture out to unknown waters and create your own custom module? Don’t worry! We can get through this together!

This talk is a deep dive into creating custom modules from scratch, and the role of each component in the final product.

Let’s consider when it is appropriate to leverage custom development, explore the anatomy of a custom module, the types of expected files in a custom module, and the wonderful world of what you can do with a custom module (spoiler - it is a lot!).

This talk will include: Composer uses, forms, theming within a module, custom pages, Drupal namespacing, object oriented conventions, plugins, controllers, routes and more!

Web Accessibility 101 Training - This training course is a crash-course in web accessibility concepts targeted towards both content managers and developers working in Drupal tasked to create an "accessible website".

Navigating the Issue Queue - A beginner's guide to contribution (half day training) - Most Drupalers dream of being a contributor to the Drupal project. But where do you begin? And more importantly, what are some of the tools to help navigate the adventure successfully?

We look forward to seeing you all there!

Stop by our booth in the expo hall to say hi and pick up some newly-designed stickers!

Sep 17 2018
Sep 17

We recently returned from Drupal GovCon and have some standout items we want to share. Overall, the experience was a lot of fun. It was exciting to get to watch Adam give the keynote on how to make an impact in the community. At Hook 42 we love giving back to the community, and it was a great reminder of how everyone who wants to give back, can contribute.

Session / BoF / Training / Track / Summit

Adam: I was honored to be able to give the keynote for the first day of the event. I have been attending Drupal GovCon for years and have always aspired to do this. On top of the keynote, I had a session on Components with Brian Perry (this was super fun) and participated in the governance and coffee BoFs. As such, I was not able to attend the full set of sessions I had wanted to. I often prefer to watch recordings anyway (thank you, Kevin Thull). I tend to learn more when it’s quiet and I prioritize spending time with people when I am at events. 

However, there are a lot of thought provoking sessions I have queued up to watch. There was some great technical content: David Hernandez Demystified Composer, Todd Nienkirk and Gerardo Maldonado both explored a future decoupled perspective on the web (in their respective sessions), and Jakob Perry dove into complexities between data structures and relationships.

There were many non-technical talks that I plan to watch as well: 

It was very clear from discussions and the energy at the conference that people spent a lot of time bringing relevant and thought-provoking topics to share at the conference. I was super impressed with both Lindsay’s and Aimee’s sessions. Overall, I was really pleased with the schedule at the event and know I’ll learn a lot.

[[{"fid":"884","view_mode":"full","fields":{"format":"full","field_file_image_alt_text[und][0][value]":"Adam Bergstein delivering the Drupal GovCon keynote","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Adam Bergstein's keynote"},"link_text":null,"type":"media","field_deltas":{"1":{"format":"full","field_file_image_alt_text[und][0][value]":"Adam Bergstein delivering the Drupal GovCon keynote","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Adam Bergstein's keynote"}},"attributes":{"alt":"Adam Bergstein delivering the Drupal GovCon keynote","title":"Drupal GovCon 2018 - Adam Bergstein's keynote","class":"media-element file-full","data-delta":"1"}}]]

Aimee: I had booth duty, so I didn’t go to many sessions. The caliber of speakers across the board provided a fantastic exploration on a wide breadth of topics. If you didn’t get to go to a session in person, speaking with the presenters in the “hallway track” and at social events was a learning experience not to miss. Thanks to Kevin Thull, the sessions are recorded and posted to each session page quickly. I’m still catching up on sessions! 

I’m not supposed to just talk about our team, but here we go: Adam’s keynote was inspirational and had a lot of very practical attainable improvements for helping folks navigate the Drupal Community. Lindsay did a great job covering Drupal 8 Custom Module development. She provided a clear path of how Drupal 8 module files communicate with and depend on each other. Mind blown. 

Joe from Aten presented about how to write a clear RFP. It was a time for responders and writers to discuss what works and what doesn’t when wrangling legalease to get project work done. It also had Van Halen references (David Lee Roth era) - win win! 

Dwayne from Pantheon is always a great speaker and rallies the folks, even when he closes out the camp with the last session slot. You must discover his session on Discovery!! You are a champ, Dwayne!

Lindsay: My biggest take away from GovCon is that we are a community - and that developers need to focus on accessibility. Websites are for people, so it makes sense that we want to create a platform that can reach as many people as possible. As a community, we also need to make it easier for people to contribute to Drupal.

[[{"fid":"885","view_mode":"full","fields":{"format":"full","field_file_image_alt_text[und][0][value]":"An attendee at DrupalGovCon displaying personal pronoun sticker on their badge","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Pronoun sticker badge"},"link_text":null,"type":"media","field_deltas":{"2":{"format":"full","field_file_image_alt_text[und][0][value]":"An attendee at DrupalGovCon displaying personal pronoun sticker on their badge","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Pronoun sticker badge"}},"attributes":{"alt":"An attendee at DrupalGovCon displaying personal pronoun sticker on their badge","title":"Drupal GovCon 2018 - Pronoun sticker badge","class":"media-element file-full","data-delta":"2"}}]]

Adam had a lot of great suggestions in his keynote that could help the community grow stronger. A great example of community contribution in action is Kevin Thull. Kevin gets his steps in at every conference he goes to by rushing from room to room getting every session recorded. In case you couldn’t make the trip to DC, all the recordings are available on YouTube.

While I didn’t get the chance to go to a lot of sessions, I did attend a great accessibility talk by Tearyne Glover. She gave a real-life example of how inaccessible websites hurt real users and how to fix these problems. 

Conversation

Adam: One of the points I raised in the keynote was the importance of the human connection within our community. There was a vibrant energy around this event that exemplifies this connection. Between the “hallway track” and the BoFs, much of my GovCon experience was conversation. And, that’s probably my favorite part. Since we are a distributed company, connecting with Aimee and Lindsay on our team was one of my highlights. It’s a great chance to connect with my community friends and make new ones. 

There were so many special people that attended (to name a few…): Kevin Thull, Brian Perry, Becca Goodman, Chris Urban, Dwayne McDaniel, David Hernandez, Tim Erickson, Danita Bowman, Brian Hirsh, Mike Herchel, Iris Ibekwe, Gerardo Gonzalez, Kev Walsh, Joe Shindelar, Elli Ludwigson, several of my previous co-workers at CivicActions and Acquia, and many more (by no means intentionally leaving someone out). This time together reaffirms how great our community is. Many people connected with me about my keynote. It’s these relationships that build trust and open up conversations to new and innovative things our community can accomplish.

[[{"fid":"886","view_mode":"full","fields":{"format":"full","field_file_image_alt_text[und][0][value]":"Aimee at a Drupal GovCon session ","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Session audience"},"link_text":null,"type":"media","field_deltas":{"3":{"format":"full","field_file_image_alt_text[und][0][value]":"Aimee at a Drupal GovCon session ","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Session audience"}},"attributes":{"alt":"Aimee at a Drupal GovCon session ","title":"Drupal GovCon 2018 - Session audience","class":"media-element file-full","data-delta":"3"}}]]

Aimee: It was really great to connect with people who work within the government and public service space. I don’t often get to talk with folks working in those environments at camps. Working in the government, and supporting organizations, comes with challenges and strengths that take on a different tone than the private sector. It is beneficial and informative to hear about the technical and organizational needs of our public servants. 

Lindsay: It’s very hard to single out one conversation, so I’ll just say it was great to be at a Drupal event with Drupalers. Someone mentioned that the Drupal community was such a strange unique thing, because he had never heard of another group of people that voluntarily go to conferences on Saturdays. Overall, I am also just happy when I get to hang out with a great group of Drupalers. I met a lot of new people and had a great time!

Social Events

Adam: The Brickside event is one of the highlights of GovCon for me, as I often do not participate in game nights or events too far from the venue. The food, drinks, and good company at the GovCon happy hour always lift the experience. Often people continue onto karaoke, dinner, or other fun evening plans.

Aimee: The GovCon team really does a nice job putting together mixers for attendees to chat in a social venue. Filled with nachos, wings, and beer, the attendees hung out and got to chat at Brickside. Many camp organizers come to the event and it provides a great opportunity to hear how other camps across the US are being run and how they are responding to the community’s needs. There was a nice game night in the camp hotel that had a good attendance, although I only peeked through the window on the way back home.

Lindsay: Every night there was a dinner... and lots of talking... and lots of laughing. From the World of Beer, to Brickside, to Rock Bottom, to the tapas, and back to Brickside - I had a great time with great people.

Overall GovCon Experience

Adam: GovCon continues to be a great event on my schedule each year. The combination of connections, schedule quality, social events, and, honestly, the size of the event just make it special. I really appreciate all of the work done by the organizers; and, how much people invest in their sessions and booths to make the event special. 

[[{"fid":"888","view_mode":"full","fields":{"format":"full","field_file_image_alt_text[und][0][value]":"Aimee, Adam, and Lindsay enjoying a session at Drupal GovCon","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Hook 42 team"},"link_text":null,"type":"media","field_deltas":{"4":{"format":"full","field_file_image_alt_text[und][0][value]":"Aimee, Adam, and Lindsay enjoying a session at Drupal GovCon","field_file_image_title_text[und][0][value]":"Drupal GovCon 2018 - Hook 42 team"}},"attributes":{"alt":"Aimee, Adam, and Lindsay enjoying a session at Drupal GovCon","title":"Drupal GovCon 2018 - Hook 42 team","class":"media-element file-full","data-delta":"4"}}]]

Aimee: GovCon is a wonderful event - the way it is managed, the people that attend, the relevant and timely topics, and the excellent location at the NIH. It is one of my favorite camps to attend and I look forward to returning next year. Thank you for hosting us, Drupal GovCon team!

Lindsay: This was my first GovCon and it was amazing! I met so many wonderful people, took my first trip to DC, presented at the NIH, and got to attend a very well-run camp filled with Drupalers. Awesome!

We hope to see you all at BADCamp!!

Sep 05 2018
Sep 05

AmyJune is venturing to the Great Plains of DrupalCorn Camp to spread her love of giving back to Drupal! Not only will she be training folks on how to navigate the issue queue, she will be leading Contribution Day, and teaming up with Lisa McCray to promote diversity and inclusion.

DrupalCorn Camp is four corn-filled days in September, the 27th through 30th in Des Moines, Iowa.

Training:

Getting Started with Drupal Contribution

AmyJune Hineline | Thursday, September 27 from 9am to 5pm

Many Drupallers dream of contributing to the Drupal project. But where do you begin? And more importantly, what are some of the tools you use to navigate the adventure successfully?

This training is intended for ANYONE who wants to learn how to contribute, not just those who are new to tech. No coding knowledge is required - there are plenty of ways to give back to Drupal without having to code.

In this training, we will discuss why contribution to open source is important and look at some of the tools necessary for working in the Drupal issue queue as a new contributor.

Tools of the trade:

There will also be a hands-on workshop demonstrating the process of finding a bug, creating an issue, writing a patch, uploading the fix to Drupal.org, and then reviewing the patch for RTBC (Reviewed and Tested By the Community).

Prerequisites:

  • A positive attitude about contributing back to open source software.
  • A willingness to learn.
  • A basic understanding of Drupal.
  • A laptop - preferably with a working local Drupal environment (but not necessary as we will go over some of the steps for setup).

Session:

Demystifying Diversity and Inclusion

AmyJune Hineline and Lisa McCray | Friday, September 28th at 3:30pm

What do we mean when we talk about diversity & inclusion, and why is it important?

Diverse communities are strong communities. Drupal has the potential to be more inclusive, but sometimes confusion about what being a diverse and inclusive community means holds us back. In this session we’ll talk about definitions, examples, and actions we can take to help the Drupal project become stronger. By ensuring that the Drupal community is a place where a wider range of people can participate, everyone contribute their knowledge, skills, and personal perspectives.

Topics covered:

  • What is Diversity & Inclusion? Including: definitions, clarifications, and real-life examples.
  • Why is diversity is important?
  • Why we should embrace accessibility for those with disabilities.
  • Ways to get involved.

Sunday, September 30th 9:00am to 4:00pm

Ready to start giving back to the Drupal Project? Whether you attended AmyJune’s training or not, come the Contribution Day on Sunday to put your skills (new or old) to use!! AmyJune and others will be there to help you select an issue you can tackle and provide you with mentorship. There are plenty of smaller tasks that can be completed by those new to contributing to Drupal, so feel confident that you can help out. When everyone pitches in, the Drupal community grows!

Stop by her training, sessions, or Contribution Day and AmyJune will give you a smile and some pretty rad sticker SWAG. 

Aug 26 2018
Aug 26

Dennis Deacon has been involved in digital accessibility for the past four years, most recently as an Accessibility Engineer with The Paciello Group. He’s led the Chicago Digital Accessibility & Inclusive Design Meetup since December 2014. He is organizing Chicago's first Accessibility Camp later this year. And, he leads the curation of the 24 Accessibility article series.

Dennis Deacon spoke about starting the Chicago Digital Accessibility and Inclusive Design Meetup. He spoke about digital accessibility but focused on delivering the most accessible events possible.

Takeaways

What is a Meetup?

A meetup is an informal meeting or gathering. Meetup.com and Eventbrite are popular platforms to organize gatherings; and, LinkedIn has also added the feature. It doesn’t matter which platform you use, it’s all about using the tool to help organize and advertise your event.

Why create an accessibility meetup?

If there is no meetup in your area, create one! It’s the perfect place to connect and learn from others who are passionate about accessibility. Use the space to promote accessibility to a wider audience.

How to start and grow an accessibility meetup

Just do it.
If the event is free, Eventbrite is free to use. Meetup.com has a monthly fee, and you can use the platform to create awareness of your meetup. Meetup.com handles membership activities, and it’s perfect for communicating with the community.

Get help.
Don't try to do it alone. Your job, your activities, and other external circumstances can take you away from the meetup responsibilities. Invested co-organizers or assistants help sustain the meetup, and can really save you some headaches.

Tell everyone.
Use Twitter, Slack, Facebook, and/or LinkedIn - anywhere where people will listen. Use the meetup’s handles and your personal account to spread the word.

Share information with complementary meetups and consider co-hosting. This increases collaboration between groups.

Finding Venues

This can be tricky in the beginning. Be aware of environmental noises and other distractions. Ask the guests if they need any special accommodations.

There are spaces available for hire, like co-working spaces. But, you should be able to find a free space. Ask other members for ideas, they often know about resources you are not aware of.

Make sure the venue is ADA compliant. Stairs, bathrooms, hallways, and seating should be accessible. Be sure the AV equipment can handle all the needs of the guests. Check the projector’s brightness to be sure there is enough contrast.

Wi-Fi is important not only for guests, but also for speakers. Speakers often have their presentation on a web server or want to perform a live demo so internet speed can be an issue.

Consider switching up the venues. This provides options to people who can’t attend some locations due to traffic, parking, mass transit, etc.

Finding Speakers

When you are just starting, this may be hard.

Colleagues who do accessibility work and meetup members are good resources. Encourage members to speak at the events. You can also reach out to other meetups to recruit speakers.

Post a call for speakers on all of your social media platforms. People in the accessibility field are some of the most accommodating and nicest people. You never know who will respond.

Lightning talks tend to be shorter and can take less preparation. The meetup can have 3 or 4 shorter talks instead of the traditional presentations. New speakers who are nervous or feel they don’t have enough content sometimes feel more empowered to lead short sessions.

Meetup formats

Mix it up, keep it fun. Some people don’t respond to presentations; but, they might respond to more interactive or engaging activities.

Some meetup formats:

  • Standard presentation - Slides can be made more engaging with demos, this is the closest to a standard lecture format.
  • Panels and roundtable discussions - Moderated panels or open roundtable discussions allow for a diversity of opinions on target topics.
  • Speed dating style format - Similar to the panel discussion or roundtable, have the guests rotate through “stations” on certain topics.
  • Social events - Educational events are good, but it is great to just have fun sometimes.

Accessible Presentation

Be sure the presentations about accessibility are as accessible as possible. Providing guidelines can be helpful.

Presentations:

  • Presentation foreground/background colors - Check for a high enough contrast. Be mindful of possible projector issues.
  • Font size and weight - Think big for the people in the back, those with limited vision, or guests taking pictures.
  • Consider the amount of content per slide - Limit the amount of content. Be concise.
  • Content positioning on slide - Keep the content to the upper two thirds. Think about the folks in back of the room. More space at the bottom of the slides means more space for captions.
  • Slide effects, transitions, and switching into demos - Be aware of any fast motion; this can make some viewers ill.

Presenters:

  • Volume - Be sure everyone can hear you, ask the audience about the volume. Use a microphone, this is extra helpful if the session is recorded. Speak clearly. Project your voice.
  • Describe visual content - Low-vision or blind users can benefit from descriptions of any visual content including images, charts, graphs, etc.
  • Switching between screens - If done quickly and repeatedly, this can make some viewers experience motion sickness.
  • Repeat audience questions - Repeat questions even when there's a mic, this ensures the question is heard when recorded. Also, repeated questions can be paraphrased. This can make the questions more succinct and understandable.
  • Be aware of your time - Allow time for questions. Be sensitive to remote captioning. It is helpful to have a clock nearby.

Sponsors

Don’t feel intimidated or bad about asking organizations for money. Provide them with benefits for the money you receive. You can offer to promote something your sponsor does or simply get their brand name out.

Act early. Don’t wait until you need them. Create relationships before you need them, already having a rapport helps. Cold calls are not effective. Provide opportunities for partnerships and meaningful relationships.

Many events don't need sponsors. Sponsorships provide revenue that helps provide extras like snacks and drinks, or added accessibility features like an ASL interpreter or captioning.

Live Streaming

It’s not complicated, you can use YouTube to live stream. Have the speaker wear a lapel mic to be sure the audio stream is clear. Bandwidth and background noise are things to consider.

Live streaming can help promote the meetup and bring new potential sponsors.

Live Captioning / ASL

If you live stream, you should provide live captions, so some viewers aren’t left behind. If you can’t provide live captions, be sure to record the presentation and add captions later.

You need to determine whether you want onsite or remote captioning. Some considerations are the audio source and Wi-Fi availability.

ASL interpreters must be onsite. You may need multiple interpreters depending on the length of presentation. They typically break after about 15 - 20 minutes of signing.

Attendance

NO SHOWS are common. People don’t show up for any number of reasons such as weather, timing, etc. Expect an average of 50% turnout; life happens.

Make sure you have realistic expectations, and you book the venue appropriately.

A couple of tips for better turnout: reduce the time between announcing the event and the actual event and, if food will be provided, mention it!

What's the next step after meetups?

Camps and conferences are the next step.

A camp is basically an un-conference. Generally, they’re 1-3 days and may be free or low cost. This is the natural progression from a meetup.

Conferences can be 1-3 days or a week long. They have a more professional feel, and perhaps presenters are paid for travel, time, and efforts.

As the size of the event grows, so do costs in both time and money. That isn’t to say you shouldn’t grow, but be aware of those changes along the way.

To wrap it up...

Just do it. But, make sure you can dedicate time and effort.

Remember to ask for feedback, so you can make the next meetup even more accessible.

YouTube Video

Accessibility Talks August 2018 - Dennis Deacon - A11Y Meetups, Camps, & Beyond

Links mentioned in the talk:

• Slides - http://bit.ly/2KQG6Tq
• A11YChi Meetup Twitter - https://twitter.com/a11ychi
• A11YChi Meetup Meetup - meetup.com/a11ychi
• A11YChi Meetup YouTube - youtube.com/c/ChicagoDigitalAccessibilityInclusiveDesign
• Deborah Edwards-Onoro’s List of A11y Meetups - https://www.lireo.com/accessibility-inclusive-design-in-person-groups/
• Accessible Presentations - https://github.com/A11YChi/A11Y-Presentations

Drupal Accessibility Group

Join the Accessibility group on Drupal.org for hints, tips, discussions, and patch proposals to help make Drupal more inclusive.

A11yTalks on Twitter

Follow us on Twitter and use the hashtag #a11ytalks to follow the conversation.

Aug 20 2018
Aug 20

Andrew Dunkle is the CTO of Go Overseas. Go Overseas is a platform that strives to help people find meaningful travel experiences abroad. They often describe themselves as the Yelp or Airbnb of study abroad programs. Volunteers, recent high school graduates, or anyone who is looking to travel in a more impactful way can use the site to find opportunities. Andrew and his business partner, Mitch, co-founded the company in 2008, while teaching together in Taiwan. They recognized the need for a platform to provide information and encouragement about taking the opportunity to go overseas and give back at the same time.

How long have you been working with Drupal and what version did you start with?

When we first started thinking about how to create this platform and what tools to use, I did a lot of research. What was out there already? Should we use WordPress? I somehow stumbled upon Drupal. We initially started with Drupal 6, when it was in its early stages. I think Drupal appealed to us - specifically me - because it was really flexible. 

I don't have a tech background, I'm entirely self-taught. You can do lots of interesting and cool things with Drupal; but, at the same time, you could do it all through the UI. You can build out a really powerful website without actually having to really touch the code, if you didn't want to, need to, or know how to.

When did you think about migrating the site from Drupal 6 to Drupal 8 and how long did that take to implement?

We started with Drupal 6 during its early stages and we were pretty happy on that platform for a couple years. But, as we grew, there were certain things we wanted to be able to do that Drupal 6 didn't offer. Drupal 7 was released, and it was a big improvement on the Drupal 6 platform. We had started to hear about how Drupal was really going to flip things on their heads, so to speak, with Drupal 8. It was going to adopt more of an object-oriented approach and integrate with different PHP projects, mainly Symfony. We made the decision to not migrate to Drupal 7 knowing that Drupal 8 was going to be such a big change. 

When Drupal 8 finally did come out, the end of November of 2015, we still wanted to wait and let it stabilize - let the core team work out the bugs before we adopted it. I'd say we started that process in May or June of 2016. That's when I really started to dive into the Drupal 8 platform - really try to learn how it was different and start thinking about what it would take to migrate to that. We kicked it off in August of 2016 and started working with Hook 42 full-time. We launched the site February 4th, 2017. It took about eight month from start to finish.

Why did you choose Drupal 8 over Drupal 7 or some other CMS?

Drupal 7 felt like an extension, and while it had improvements over Drupal 6, it still fell within the functional programming paradigm. Drupal 8 felt more modern and had some long-term stability, so we decided to skip Drupal 7. We did consider other CMSs, but that discussion ended quickly. So much of our data architecture is very Drupal. Migrating it to a different data structure would have been problematic and not really helpful. If we went down the route of using full Symfony (or other PHP frameworks) it would have had certain advantages obviously, but we'd be responsible for building out everything: the UI, the different tools, permissions and routing... Drupal 8 already provides those things and it didn't really make a lot of sense to give up all that for the other advantages.

How was the migration? When you started, Media was still in development and the configuration management and composer workflow wasn't yet defined. When those improved, how did that affect your workflow?

The configuration stuff actually wasn't so bad during the development process. We had waited six or seven months after the launch of Drupal 8. I think we started with Drupal 8.1 or maybe 8.2. The config stuff was alright, the things that were bothersome with config back then, are still bothersome. When more than one person ends up working on the same config at the same time, somebody basically wins and somebody else loses. I think there's no real easy way to merge that stuff.

I think the bigger challenges we faced was the layout management at that time. In Drupal 6, we been using Panels pretty extensively; but, by the time we were working with Drupal 8, Panels was still in alpha and was not stable enough. We made the switch over to Display Suite, it was a little bit of a change. I didn't really like it at first; but, the more I started working with Display Suite the more I liked it. I don't like the UI so much, I think the Panel's UI is better than the Display Suite UI - I think it is really just extending Drupal 8 core. Dealing with the layouts was definitely a challenge for us. I think - for certain content on our site - we just had to do big globs of HTML, just to kind of get things migrated over and pushed.

What were some of the challenges when starting with Drupal 8 and how has the Drupal 8 project evolved since the site launched?

I think the organization of the code of Drupal 8 is a big advantage and something else to get used to. It's obviously different from Drupal 6 or 7. It took me about a month or so. I took some online classes and I went to a DrupalCon LA and took some Symfony classes. Once you get it and think "actually this totally makes sense", it speeds up your development. There's more structure to the projects themselves. So, it's easier for other developers to get involved, because everyone's projects end up looking the same. There's a standardization that makes things a lot easier.

The user stuff is all there; it makes it a lot easier for permissions and authentications. Drupal 8 is little bit harder grasp at first, but it's also incredibly extendable. For example, when you're working with contrib modules and want to change something in the way that module works, or you need to do something with some particular class - you can swap classes out and services out. You don't have to necessarily patch modules to add or alter functionality in core and contrib. I think that is pretty powerful; but, arguably, it can be challenging. You have to know Drupal 8 pretty well to do any of those things.

If you could improve something in Drupal 8 what would it be?

Config management certainly solves a lot of problems. But, it can also generate lots of problems, particularly with Git flows. Most - sometimes all - of my issues with config revolve around Git and just dealing with conflicts.

You used to have the ability, when working with a View, that if you messed up the view, somehow you could revert it back to its prior state in the code. For some reason that seems to be lost in Drupal 8, or at least I don't know how to do it yet. If I mess up a View or I don't like it anymore, I don't know exactly how to revert that particular view back to its original state without messing up all my config at that point.

The whole headless Drupal craze which lots of people talk about... there are competing methodologies about how to best utilize that. We've been experimenting with Vue.js a lot and started to integrate that into our project. It is really neat, but there doesn't really seem to be a consistent way to add Vue.js to the projects. You can do it a variety of ways, which all work, but I'm left wondering, "If they change something then I have to go back and change all these other things."

Or you can also build processes. All these JavaScript frameworks require something pretty heavy - web pack and JavaScript build processes - to generate all of this JavaScript code. There are a lot of build processes that you could figure out on your own, but at the same time, there seems to be competing interests about how to best do it. When a company like us is looking for stability, we want to make a decision that's going be stable for years to come. We can go down this route or the other route, but if we choose the wrong route, it could cause trouble down the line.

What are your favorite things about working with Drupal 8? 

Mostly the code organization, I do really like class structures. I would say they are a big help for me. I would tell this to anyone wanting to learn Drupal 8 - get PhpStorm, or something similar, and get really good at it. It is such a powerful tool and it also allows you to really learn how to Drupal 8 works internally. The tool helps you to bounce around classes and methods, so you can go up the tree and see how it all works. It's also self-documenting, some complaints about Drupal - this is Drupal in general, not just Drupal 8 - are that the documentation isn't the greatest. Finding information can be a challenge if you're just looking through the docs, but I find that I can just bounce around in PhpStorm and look at the code that's there. That has helped me understand how Drupal 8 works, what's possible, and what I need to know to extend a certain class or method.

Do you have any advice for people thinking to migrate to Drupal 8?

Have your data architecture down hard. I think that was the biggest challenge for us. Really nail down your nodes and your fields, have your site building really tuned in, know "this field is going map to this field." We had a huge Google Doc that mapped everything over with all the field names, and the data types. The earlier in the process you do that, the better and faster it will go. We thought we had everything mapped over but we had forgotten about something; at the end the project that caused a lot of headaches. During the migration process, you're just migrating data, there's really nothing more important than that. The actual representation of that data, Drupal 8 can handle all that. Particularly at this point, we're coming up on Drupal 8.6 and it's pretty stable. A lot of the core and contrib modules have been ported over to Drupal 8 and they are pretty stable.

Aug 17 2018
Aug 17

We’re excited to be offering two training sessions at BADCamp this year! Both of them focus on widening the reach of the internet and Drupal. Accessibility and contribution are close to our hearts at Hook 42 as they both are great tools for making the web a more diverse and inclusive place. The best thing about both subjects? You don’t have to know everything to dive in and get started - starting where you are is a great way to move things forward.

Please, join us on Wednesday October 24, 2018 for a half day training about getting started with Drupal contribution and/or on Thursday October 25, 2018 for a full day training on accessibility on the web.

Both sessions are appropriate for beginners or those looking for a refresh of the foundational concepts.

Trainings:

Navigating the Issue Queue - A beginner's guide to contribution

Many Drupallers dream of contributing to the Drupal project. But where do you begin? And more importantly, what are some of the tools you use to navigate the adventure successfully?

This training is intended for ANYONE who wants to learn how to contribute, not just those who are new to tech. No coding knowledge is required - there are plenty of ways to give back to Drupal without having to code.

In this half-day training, we will discuss why contribution to open source is important and look at some of the tools necessary for working in the Drupal issue queue as a new contributor.

Tools of the trade:

There will also be a hands-on workshop demonstrating the process of finding a bug, creating an issue, writing a patch, uploading the fix to Drupal.org, and then reviewing the patch for RTBC (Reviewed and Tested By the Community).

Prerequisites:

  • A positive attitude about contributing back to open source software.
  • A willingness to learn.
  • A basic understanding of Drupal.
  • A laptop - preferably with a working local Drupal environment (but not necessary as we will go over some of the steps for setup).

About the Trainers:

AmyJune Hineline is an active member and contributor in the Drupal community. As a Community Lead, she believes that giving back to an open source project should be easy and fun.

John Q.T. Nguyen has helped facilitate contribution sprints at multiple Drupal Camps, Global Training Days, and at DrupalCon. He enjoys introducing new and beginning users to Drupal and participating in activities to grow the Drupal Community.

Daniel Rose's passion for Drupal extends beyond the issue queue. When he is not actively working on issues, he is mentoring new contributors and helping empower them by showing them new tools and techniques.

Web Accessibility 101 Training

This training course is a crash-course in web accessibility concepts targeted towards both content managers and developers working in Drupal who are tasked to create an "accessible website".

Accessibility: what and why?

  • Understanding disabilities and challenges
  • Laws, standards, and organizations (beyond the WCAG 2.0/2.1)
  • Conformance Testing
  • Accessible Elements of the Web
  • Media
  • Content
  • Markup
  • Documents

About the Trainers:

Aimee Degnan is an IAAP Certified Professional in Accessibility Core Competencies (CPACC) and a seasoned Drupal and Web Architect who helps audit and architect websites for better accessibility. She believes in eliminating all the barriers that exist for accessibility to help make the web more diverse through inclusivity.

AmyJune Hineline is an active organizer of the Drupal Accessibility meet-up and is passionate about accessible information for all. Her history as a healthcare professional provides her with a rich understanding of the challenges folks may need to overcome and how that may affect their interaction with the web and supporting tools.

We can’t wait to see you all at BADCamp!

Aug 16 2018
Aug 16

Next week we’ll be traveling to the nation's capital to participate in Drupal GovCon! While Aimee and Adam are veterans of GovCon, Lindsay is embarking on her first trip to the Washington, D.C. area. 

Hook 42 will be presenting on a variety of subjects, including project management, module development, and component based development. We’re excited that Adam will also be delivering the keynote Wednesday morning!

GovCon is Wednesday, August 22nd to Friday, August 24th at the National Institutes of Health in Bethesda, Maryland.

Keynote:

Better Together: Impact Through Contribution 

Adam Bergstein | Wednesday, August 22, 11:00am | Auditorium

Drupal is one of the largest and longest-standing Open Source communities; yet, it can feel difficult to make an impact. How do you find your place in such a large and diverse community? Many community members have made contributions to the project outside of code that have had a significant impact. I will share some stories and examples, to provide ideas of how you might be able to contribute to the project. And, using the framing of a “hero’s journey”, we will explore how all the pieces fit together to make a big impact on the greater whole.

The Drupal community has remained sustainable and vibrant compared to other projects because of the opportunity to provide contributions beyond code. Community members are able to provide both technical and non-technical contributions. In this talk we will look at the appeal of participation beyond just technical contribution and explore the interplay between contribution, impact, and alignment of our personal interests with community work.

When we all pitch in, we can change the world; because, every new contribution adds up to our community doing new and bigger things. Together we can all continue to create a vibrant community built upon our creativity, passion, and interests.

Sessions:

Healing a Broken Project

Aimee Hannaford (Degnan) | Wednesday, August 22, 2:00pm | Room: F1/F2

What happens when you encounter a project that seems broken beyond repair, but for whatever reasons, a brand-new fresh start is not possible?

You may run into the following challenges with these "broken projects":

  • No clear scope
  • No requirements documentation
  • Far less remaining budget
  • Far less remaining time
  • "Project fatigue" from the client
  • Massive amounts of technical debt
  • And many, many more challenges…

How do you even start approaching such a broken project and bring chaos to order?

But what does order really mean? How does one measure success or completion in a fog of wrongness?!

Using project management and enterprise process management techniques, you can work through unclear and incomplete deliverables to help define what Done (success) means. This includes unraveling complex business logic, multiple business processes, and a slew of modules and configurations.

At the same time, we were proactively healing the client’s project pain by finally being able to articulate a clear list of what needs to be built versus what has been built.

Learning Outcomes:

  • Starting assumptions may not completely prepare the team for the project.
  • Identify and proactively address stakeholder’s project fatigue and apprehension.
  • Explore practical techniques to unravel and define the half-built and the unknown.
  • Understand that tools and techniques are really applying the “best practice for the situation” and which tool you use will evolve through the project recovery process.
  • Understand how to prepare your project team for the road to recovery with the client.

Can We Figure This Drupal Component Thing Out Already?

Adam Bergstein and Brian Perry | Thursday, August 22, 9:00am | Room: Auditorium

Over the last two years our community has seen the rise of countless solutions to implement design systems and components within Drupal. During the same period across camps, cons and the internet at large Adam and Brian have been having an ongoing conversation about best practices in component-based development.

With Brian focusing on ease of component integration (often with the help of contributed modules), and Adam focusing on a platform agnostic approach favoring functionality in Drupal core, there was initially quite a bit of good natured debate. But as time went on and approaches in the community matured they found their perspectives aligning more and more.

This session will present their (mostly) shared vision of a set of best practices for component-based development. They’ll still disagree on some stuff, but that’s part of the fun. We’ll review:

An overview of current approaches in the community, along with some limitations.
Our goals for a component-based design system.

  • Breaking down your patterns using atomic design principles to represent the ideal state of design system components.
  • Managing your pattern library as an external dependency of your Drupal project.
  • Limiting processing in your pattern library, and handling processing and mapping within your CMS.
  • Common misconceptions about integrating design system patterns in Drupal.
  • A baseline approach to implementation in Drupal using Drupal core and limited contributed modules.
  • The role of popular component-friendly contributed modules
  • Emerging technology for the future of component-based development.

Finally, we’ll go hands on with a brief demo showing our preferred approach in action.

Drupal 8 Custom Module Architecture: What’s Going On?

Lindsay Gaudinier | Thursday August 23, 9:00am | Room: Balcony A

It is all fun and games modifying existing code, but what about when you have to venture out to unknown waters and create your own custom module? Don’t worry! We can get through this together!

This talk is a deep dive into creating custom modules from scratch, and the role of each component in the final product.

Let’s consider when it is appropriate to leverage custom development, explore the anatomy of a custom module, the types of expected files in a custom module, and the wonderful world of what you can do with a custom module (spoiler - it is a lot!).

This talk will include: Composer uses, forms, theming within a module, custom pages, Drupal namespacing, object-oriented conventions, plugins, controllers, routes and more!

See you in our nation's capital!

Look out for some sweet Hook 42 sticker swag at our booth! We hope to see you at GovCon, and meet many new Drupal friends along the way!

Jul 13 2018
Jul 13

The June A11y Talk welcomed back Drupal Core Accessibility Maintainer, Andrew Macpherson. The “What's New with WCAG 2.1” talk discussed the new guidelines that were released in early June.

Web Content Accessibility Guidelines (WCAG 2.1) extends WCAG 2.0 and is intended as an interim until WCAG 3.0 is released. The new guidelines were needed due to advancements in technology and to fix some gaps and shortcomings in the earlier guidelines. Some of the new guidelines cover touch/mobile devices, speech control, and cognitive disability support.

The new extensions are organized in the same manner with priority levels A, AA, AAA. The numbering protocols remain the same: Principles > Guidelines > Success Criteria. There are 17 new success criteria: Level A - 5 new criteria, Level AA - 7 new criteria, and Level AAA - 5 new criteria. There were more proposed, but were not included because they were difficult to describe how to test. It is important that the success criteria be human testable so audits can be performed. Some guidelines changed numbering, priority levels, or were moved to another group.

There are documents in place to help people understand the new guidelines. They provide successful techniques along with known failures.

What's New with WCAG 2.1

New Success Criteria at Level A

Guideline 1.4.11 - Non-text Contrast
Icons, buttons, “focus rings”, and other state indicators now have minimum contrast.

Guideline 2.1.4 - Character Key Shortcuts
Speech control and dictation can trigger character key shortcuts accidentally. The new guideline requires modifier keys, not only single characters.
Example: Instead of just the key K, the command would be ctrl + K. Providing options to re-map or turn off shortcuts eliminates accidental triggers as well.

Guideline 2.5 - Input Modalities
This is a new guideline surrounding different input devices. Icons, buttons, “focus rings”, and other state indicators now have minimum contrast.

Guideline 2.5.1 Pointer Gestures
Multi Touch screens and trackpads are now common and many have the ability to be controlled by gestures. Not all people can gesture. We can’t assume people can move their phone. The new guideline defines that multi-point or path-based gestures must also work with a single pointer. Websites must be able to work with only a mouse

Guideline 2.5.2 Pointer Cancellation
When buttons are close together, it can be easy to push the wrong one. To avoid accidental activation when a mouse button is pressed, a website can avoid using JavaScript “down” events. By avoiding this code and using “up” events, a user that has pressed down on the wrong button can now move the mouse or pointer to the correct button and release it “up”.
Example: mousedown and touchstart.

Guideline 2.5.3 Label in Name
This new guideline helps speech control users activate controls. Mismatching the accessible name with what is visually displayed should be avoided. If a button reads “Sign In”, the label should read the same.
Example: <button aria-label=”Log in”>Sign In <button>, should read <button aria-label=”Sign In”>Sign In <button>

Guideline 2.5.4 Motion Actuation
Hand held devices, like Smartphones, have many sensors in them so they can detect motion which enables specific events to occur.

Success Criteria Links for Level AA and AAA

Because of time limitations, Andrew focused on discussing the new success criteria at the A level. Here are the sections that got extended at the next levels.

New Success Criteria at Level AA

Guideline 1.3.4 - Orientation

Guideline 1.3.5 - Identify Input Purpose

Guideline 1.4.10 - Reflow

Guideline 1.4.11 - Non-text Contrast

Guideline 1.4.12 - Text Spacing

Guideline 1.4.13 - Content on Hover or Focus

Guideline 4.1.3 - Status Messages

New Success Criteria at Level AAA

Guideline 1.3.6 - Identify Purpose

Guideline 2.2.6 - Timeouts

Guideline 2.3.3 - Animation from Interactions

Guideline 2.5.5 - Target Size

Guideline 2.5.6 - Concurrent Input Mechanisms

Resources

Link to Youtube:

A11Y Talks June 2018 - Andrew Macpherson - What's New with WCAG 2.1
General resources mentioned in the presentation:

• Drupal WCAG 2.1 ticket - https://www.drupal.org/project/ideas/issues/2864791
• WCAG 2.1 guideline for pointer cancellation - https://www.w3.org/WAI/WCAG21/Understanding/pointer-cancellation.html
• WCAG 2.1 target size - https://www.w3.org/WAI/WCAG21/Understanding/target-size.html
• Docksal - https://docksal.io/
• WCAG 2.1 text spacing - https://www.w3.org/WAI/WCAG21/Understanding/text-spacing.html
• Article by Steve Faulkner on text spacing - https://developer.paciellogroup.com/blog/2018/05/short-note-on-getting-spaced-out-with-sc-1-4-12-text-spacing/

Drupal Resources:

Drupal Accessibility Group

Join the Accessibility group on Drupal.org for hints, tips, discussions, and patch proposals to help make Drupal more inclusive.

Jul 10 2018
Jul 10

If you have been to any of the North American Drupal Camps, chances are you recognize Amber Matz. She is the production manager and a trainer at Drupalize.Me. Drupalize.Me is a site for Drupal tutorials and trainings. Amber, along with Joe Shindelar, travel to the various Drupal Camps and DrupalCons and currently run Drupal 8 Theming workshops.

How long have you been working with Drupal & what version did you start with?

My name on Drupal.org Amber Himes Matz and my account is about ten years old. I started with Drupal 6. I had been working in a non-profit organization in the webmaster’s office. I was doing a lot of PHP in MySQL and I was processing a lot of forms by hand - I was doing a lot of hand coding of forms and processing scripts. After about my 150th form I thought, “Someone must have figured something out by now. I'm sure I'm not the only one processing forms this way and getting sick of it.” That's how I found Drupal. I was completely blown away, and so excited because there was this starting point that was something where I didn't have to worry about user login in and authentication. I didn't have to worry about processing forms in the same way that I had been doing. What got me into Drupal is my disdain for writing PHP scripts to process forms.

How has your role in Drupal sort of evolved over the years?

I discovered Drupal because I was working in web development, and it seemed to be a good direction. Right about the time that I recommended that our organization adopt Drupal, I actually switched careers. I had been working in web development for about six and a half years. I went to massage therapy school in the evenings and worked full-time and moved away to Southern Oregon. I worked as a massage therapist in this little hippie town in Oregon called Ashland. I did freelance web development (WordPress and Drupal) for small sites and some business card design.

I was a massage therapist for about four and a half years and I moved back up to Portland. Basically, I stayed in massage therapy for another couple of years and then I just got tired of being poor. The economy had crashed, things were expensive, and income was really tight, especially in the spa industry. It had experienced the first downturn in 12 years, so that was kind of bad timing.

I decided I wanted to revisit Drupal, but I had been doing it wrong. For example, I wrote a search engine within a template file which is the big no-no, but it's was the only thing I knew how to-do. I discovered a Lullabot module development DVD; this was back when they did DVDs, and that just blew my mind. Drupal 7 had just come out as brand-new and Lullabot was doing the Webchick tour. It was Angie Byron and Joe Shindelar and maybe some other folks. They were doing workshops introducing people to Drupal 7, what changed from Drupal 6, what the new features were, and DBTNG which was the new way to access the database which was for me - as a PHP and MySQL developer - a big deal because it just made my life a lot easier. It just made doing dynamic content easier, so I decided to just bite the bullet. Even though I was feeling pretty poor at the time I thought “I have to get a flight down to LA and go to this workshop”. That kind of put things in motion that whole year.

That year, the Drupal Association moved to Portland. At this point, I had been on my own. I was a freelancer, and I was completely isolated from the community. I had seen the forums and seen the issue queue, but I just assumed those people were some kind of special breed of people. I felt like a total outsider; I had an embarrassing moment in IRC, and I didn't know how to interface with these people. When I found out that the Drupal Association had moved to Portland, I did some Googling for “Drupal in Portland” and I discovered that there was a local user group. This was on a Tuesday and it was the fourth Tuesday of the month which is when they have their informal meet up at a local pub.

I proceeded to have a major anxiety attack about going, showing up to this Meetup, totally new. I talked myself into it, and made it down there. I met a person, Dan Muzyka, who works at Phase2 now. Before that, he was working at this other place and they were hiring. I got an interview, I then subscribed to Drupalize.Me and totally binged on site building, views, and theming videos; you know, Netflix style binging, so that I could be conversant for the job interview. I was honest about what I did and didn't know, but at least I could talk about it. I could say, yeah, I know views to this point, but I don't know beyond this.

Anyway, I got the job. Six weeks later I was making views and working with clients. They put me on the phone with a client right away, because I could talk to people. That's always a great skill for a small agency to have, it’s like “oh you can talk to a client” okay…  here, you’re a project manager, now you’re a developer. That was like two years of intense on-the-job skill building, and I learned everything from site building to really advanced views and theming. Our agency got a gig to theme the 2013 Portland DrupalCon site. My first contribution to Drupal.org was making those commits for the theme for the 2013 DrupalCon.

After two years of that intense job, I saw the opening at Lullabot. A former coworker had gotten a job there and he had been really trying to push me to apply. Of course, I was completely intimidated by that. It took maybe three or four months of convincing, and this job opening for a Drupalize.Me trainer popped up. This was my dream job because they had done so much for me and helped me get a job as a full-time Drupal developer. I loved the platform and I had used it - and I had used it to great success to get a full-time job. It liberated me from the economic situation I had been in, so I was very thankful for it.

That was four and a half years ago. I was focused on creating content and back then we did only videos for Drupal 7. Drupal 8 we do both written and video. I create the content, but I also manage our production pipeline and work with our Video Editor and QA.

2014 was when I really started getting involved with the local community and with event planning. My involvement with Drupal has gone from "desperate to get a better job" to getting involved with the local community. That's really where I’ve thrived. After getting this job with Lullabot, and then Lullabot Education, which is now a sister company, speaking at DrupalCons... That has really helped me emerge as a community at-large leader instead of just in the local community. So, that's kind of how my evolution is taking place. I know it's a long story but I love it, because it really got me out of the these jobs that I really hated to something that I really, really love. I'm still kind of pinching myself. It took 20 years to find a job that I really love, but I'm very thankful for it right now.

When did Drupalize.Me start training others on Drupal 8?

Right when Drupal 8 came out. The year before it came out, in fact, we weren't quite sure when it was going to come out, but we knew it was going to be "soon."

We made a decision to set aside five hours a week to learn Drupal 8, so we had that learning time and, out of that, you needed to come up with a blog post. We were really trying to write a lot of blog posts about Drupal 8. This was, you know, using Drupal 8 in some beta version or even maybe an alpha version, but I think once beta came out we started really hitting the blog posts pretty hard. Three weeks or so after, very soon after a Drupal 8 was officially released, we released our configuration management series. We wanted to be training as soon as possible.

We made a decision to do written tutorials, as well as video, because we wanted to commit to keeping our tutorials up to date. It's really expensive and hard to keep video up to date, so we could produce more content and have the ability to keep it up to date, especially with the semantic versioning and these minor releases coming out every six months, we needed that structure in place. It's a lot easier to copy and paste, it's actually possible to copy and paste, code examples from written tutorial than from video.

What have been YOUR favorite components to teach?

I think theming is a lot of fun. I love using Twig. What I like and what Drupalize.Me likes, it's really tight... I don't even know where the separation is at this point. I really enjoyed learning the Responsive Images module, that was really kind of gnarly, because responsive images are kind of gnarly. That was fun to try and untangle that. I got some help from various people, but that was kind of a fun puzzle to do.

What are some of the advantages of working with Drupal 8 over the versions you've worked with previously? Are there any tools that you find more helpful than others?

Theme development in Drupal 8 is much easier with out-of-the-box configuration than it was with Drupal 7. With Drupal 7, you needed some contributed modules and it did some funky overlays, so you could see what the template suggestions were. The interface was there, but it was really quite overwhelming, and it was really hard - especially as a beginner - to figure out what template to use. It just felt tricky and magical. With Drupal 8 and Twig debug, being able to just view the source of the page and see where this chunk of code is coming from, this is which template is being used, these are the theme hooks suggestions, these are the template names you could use - it's just right there, it's just brilliant to have that. I just think it just makes it so much easier with your setup of your site. You set up your settings, and then you have the information you need. You don't need a contributed module. It just makes it easier to teach and easier to learn it from any level, so I just love that.

If you could improve anything in Drupal 8 what would it be? 

Right now, I am working on project with Jennifer Hodgdon called “Help Topics”. It's a sandbox project that we're trying to get into Drupal core. I’m trying to refactor it. She originally wrote it with config using configuration entities. We got some feedback from the community and I did a talk about it in the core conversation track at Drupalcon. The feedback was that we should be using the plug-in system. So, I decided to take that on. I've read a lot about it, I feel like I'm familiar at a high level with the plug-in system, but I really wanted to write the code. Because I’ve spent all my days now, for the last five years, writing tutorials, I don't do a lot of coding anymore, so I wanted to kind of get my chops back up.

There's a lot of abstractions in Drupal 8, it's a steep hill to climb at first, but once you get over that hill, it becomes easier. It feels like a juggling match and I still miss the hook system. Object-oriented programming is super fancy, and super great, and it definitely has a place in a big enterprise level robust system such as Drupal. But, sometimes you just want to implement a hook and be done with it. But, also, I've seen thousands of module files that are thousands of lines long and that's kind of a huge mess to deal with, so I see both sides.

As a PHP developer who learned on pseudo object-oriented code and had a break from that at a time when it was really emerging and then now has to go back and learn proper object-oriented PHP, it's challenging. It's hard. It's time-consuming. I understand why, but sometimes the abstractions get a little bit tiresome because it’s a hard thing to learn. I understand why it exists, and why it was implemented, and it does make some things easier once you know how to use it. It's just getting to that point that can be challenging; a little brain melting at times.

What advice do you have for those who have not made the jump from Drupal 7 to Drupal 8?

When you're planning a migration, you're trying to see if this is a viable thing, like can we migrate this Drupal 7 site to Drupal 8? Let's list all the modules, and let's find out if there's a Drupal 8 counterpart. You can find out some information that way, but there isn't going to always be a straight replacement for it in contrib. There may be a better way to do it in Drupal core, there might just be a completely different approach, or you don't need to use this contributed module anymore and that requires a lot more digging.

I think that it's probably different depending on what role you're in. If you're a site builder, or administrator type person, you're just trying to figure out what modules have been ported and want to know how to configure the site, so they can run this migration. Whether or not that's viable or not is a different process than if there are PHP developers or module developers on the team who can write custom code, who can see how they might implement it differently without needing a contributed module. I think there's just a different process and there might be a perception that their site isn't ready to migrate to Drupal 8. Maybe they feel Drupal 8 isn't mature enough for them, but it might just be a misperception or there's a gap in skills on their team to be able to do it successfully and that's valid. I think it's complicated.

Any migration is difficult, but there is a really great migrate system now in place and a great API. It's not easy-peasy, but there is a lot of help there and some things are really straightforward. But, with every Drupal site there's always the edge case. It's the mantra, this works for 80% of sites, but there's 20% that's that takes the longest to figure out and you know that's the sticky part.

What’s next for you?

I’ll be at GovCon with Joe in August, and we’ll be presenting our beginning Drupal 8 Theming Workshop. I’m reviewing some new tutorials and updates to our configuration management series which will include tutorials on deployment workflows. Also, Tim Millwood is writing some content moderation tutorials for us this summer. Content moderation is new to the latest version of Drupal so that should be exciting.

Drupal GovCon is August 22-24 at the Natcher Conference Center, National Institutes of Health in Bethesda, MD.

Jul 05 2018
Jul 05

Drupal Camp Asheville is next weekend! Join members of the Drupal community of all different skill levels and career paths for 3 days of science, trainings, sessions, and sprints.

Hook 42’s own Adam Bergstein will be sharing some insights on everybody’s favorite online Drupal testing environment, Simplytest.me. He recently took over ownership of the service, and we are excited to hear about where it is going next!

Along with helping to organize the camp, our newest team member, Jonathan Daggerhart, will be leading an all day training on Drupal 8 Essentials.

Session:

Simplytest.me: Past, Present, and Future

Adam Bergstein | Saturday, July 14th, 4:00pm | Room 1
Simplytest.me has been a long-standing tool that has served Drupal community members with an easy-to-use tool for creating Drupal sandboxes. This session walks through how people use SimplyTest and shares the various features of SimplyTest and the current underlying technical architecture, including the distributed computing infrastructure, use of LXC, and the Drupal 7 based provisioning platform. Based on lessons learned and emerging technology, a roadmap has been created to both modernize and evolve SimplyTest. This presentation outlines this future vision and presents opportunities for community members and companies to learn, to contribute, and to participate moving forward. We will review React, Docker, Drupal 8, Digital Ocean, and the new proposed user interface. Simplytest.me will continue to serve the needs of the community in a variety of ways and we’re excited to share the evolution of the service in concert with the needs of community members.

Training:

Essential Drupal 8 Developer Training

Jonathan Daggerhart | Friday, July 13th, 9am - 5pm

Intended for developers who have no, or limited, experience with Drupal 8 or Object Oriented Programming (OOP). Familiarity with Drupal 7 will be beneficial, but isn't required. This workshop will help jump start your Drupal 8 coding work by laying the foundation for all the big concepts that have been recently introduced. More than just teaching these ideas, I will attempt to provide understanding behind the potential motivations for these changes and how they relate to the work you're already familiar with from Drupal 7 or other procedural frameworks/CMSs.

We'll discuss and write a custom module together that uses all of these concepts:

Introduction to Object Oriented Programming

  • PSR4: Namespaces and Autoloading
  • What is Symfony?
  • Drupal 8 file structure - What you need to know.
  • YAML files & Annotations
  • Services
  • Hooks vs Events
  • Config Objects & Config Schema
  • Custom Forms
  • Custom Block Types
  • Custom Routing with Access Control
  • Providing Twig templates within your modules

By the end of this workshop you should be significantly more knowledgeable about how Drupal 8 has changed and understand why those changes are considered improvements on Drupal 7's code base.

It will be useful to come to this training with a local development environment where you can write and run PHP. Having a Drupal 8 site to work with would be beneficial, but isn't completely necessary.

We hope to see all of you in Asheville!

Drupal Camp Asheville is July 13-15 in beautiful Asheville, NC at the The Sherrill Center and Kimmel Arena.

Asheville Drupal Camp team picture

Jun 21 2018
Jun 21

Jill Cohen is a Senior Software Application Engineer at Autodesk Inc. Autodesk is a global company that empowers users to design and create just about everything on this planet - and in virtual worlds. She works with the Digital Platform and Experience Organization on the Digital Help team, which manages the Autodesk Knowledge Network and Services Marketplace. She is also on the board for Autodesk Women in Leadership.

How long have you been at Autodesk?

I have been at Autodesk for 4 years; before that I worked at various other startups, web shops, and worked freelance since about 1995. I have been a programmer, project manager, front-end developer, architect, designer, and database administrator. I was doing DevOps before there was DevOps. At my last job before Autodesk, I was hired as a Java engineer for a small nonprofit which evolved into build and release engineering as well as what has become known as DevOps.

I have spent most of my time working in Java.

How long have you been working with Drupal?

My programming background is primarily Java. I have worked a lot in JavaScript. One of my first applications that I wrote was taking MySQL and turning it into server-side JavaScript. That was about 1997 when JavaScript was on the server. It's on the server now in the form of Node.js, but back then it was very different.

I started working with Drupal with a company called SoundVision. They were producing The DNA files and their first website was a static, plain HTML site. They decided they needed a content management system. We started using Drupal 5. I managed to design and architect it without having to build any modules. There was enough out there to put it all together. The Drupal Admin was a hot mess and a disaster to work in, but I trained the team as to what to do. 

After that I designed and architected another site for them, but I didn't implement it since I left the country. Both sites are still going, they are Drupal 7 sites now. Other people came in and upgraded them. I did the two projects on Drupal 5, and skipped Drupal 6 completely.

I stopped working on Drupal after those two experiences and went back to Java after traveling around for a little while. Four years ago, a friend of mine asked me if I wanted to work with him at Autodesk. It was for Autodesk’s new Knowledge website built on Drupal 7, and I said yes. 

I was given a lot of time to get up to speed. It was a heavily customized site. It was managed by an outside vendor, and they had basically built and customized a lot on their own.

I am more of a full-stack engineer, so it was easy for me to get into the workflow and process. Once you figure out how hooks, menus and views work, you pretty much get it down. It's not super complicated.

When did you start working on Drupal 8 sites?

I started in December 2016. In the beginning of 2017, I put a prototype together for Services Marketplace. It took a lot to build the first module; to figure out all the moving pieces and parts and understand the new object-oriented framework, which I really like and prefer in some ways.

It took about 9 months to actually launch our site - which is pretty good, considering people had tried to put up other Drupal 8 sites and were not successful. I think we did a pretty good job in learning everything we needed to learn, while implementing someone else's vision. Other people's visions can be a moving target.

Plus, we implemented React inside of it which made it more complicated. We were learning both Drupal 8 and React at the same time, it was a pretty tall order. I think it's really challenging moving toward to what Dries calls progressively headless. It's in the middle where you’re still supporting a site for administrators and other users in Drupal, and you want to use Drupal headless.

Decoupled and progressively headless... I would recommend if you are going to go headless, go all the way. It's really hard to implement all the business rules you would need in a React app and make sure the administrator side has all the business rules.

Drupal does really well if you want to work headless, if you have engineers that want to work in JavaScript, Node.js, or some other area of the rendering system and go all the way headless.

Why did you decide on Drupal 8 for the Service Marketplace project?

There was really no point in going back to Drupal 7, and then thinking about having to upgrade it in a year or so. Drupal 8 had enough traction, sites were coming out, and there was enough support. Our hosting provider didn't have everything set up; however, they were getting there. We were on the cutting edge for them and we assessed it and decided "now is the time". 

I am lucky enough to work in a place that takes risks, encourages us to try new things, and expand our knowledge and learning. I felt if all else failed, we could have re-built the site in Drupal 7 pretty quickly. It wouldn’t have been fun, but I felt if something critical happened we had a backup plan.

What were some of the challenges you had working with Drupal 8?

There wasn't a lot of documentation beyond the basics. Menu items, routings, tasks... everything I wanted to do had a learning curve. I would write everything by hand or re-read some of the files in core, I had to reverse engineer in order to move forward.

I think some of the issues that were brought up were around using Composer. How to work with more than one person, people adding modules... I really like using Composer, but it did take us awhile to figure out the proper usage of it.

My biggest challenges have to be working with entity references. Drupal doesn't really clean up after itself. Removing a taxonomy term that is referenced on a node, breaks the node completely - you cannot view it until you re-save it. It doesn't work really well in production. I forgot that we had some barriers to removing entities in the Drupal 7 site. We were doing this one-to-one relationship, and we made sure someone had to remove one piece in order to remove another piece. We didn't hard code that in Services Marketplace, and it definitely is a place where we need to make sure we don't blow everything up.

I love entities and the object structure is great. If you don't understand the relationships, it's a huge stumbling point.

What are your favorite things about D8?

I like all the yaml files. I love the configuration setups and how you can export and import. It takes a while to have the trust that the system will do what you want to do when you want to do it.

Composer: I would use patch management, there's a way to do that.

Configuration: there's a new module for splitting the config per environment, but I haven't been able to implement it yet. 

I love the REST API, it’s really clean. It makes so much more sense the way you create web services. And how the packages and the classes are structured. I think if you haven't come from object-oriented programming background, it's a little disarming, especially when you're writing more functional and everything is in a module or include file. It’s nice to separate things out where they logically belong although it takes a little while to get your head around that.

Debugging is little bit easier. I like the controllers, and the way forms and blocks make more logical sense.

If you could improve something in Drupal 8 what would it be?

There is still a dependency on hooks, and I think if we cut the dependencies it would be much better. For instance, you can set behavior and overrides in a controller only to find that later it gets overridden by a hook. It's not immediately apparent what's going on, why you're setting something where it should be set and your interaction is still not working.

Maybe you can't get rid of all hooks, but I think it's time to let controllers own all the work.

Hook init is gone. We used it on our Drupal 7 site to make sure something always happens on every page request. They are now event managers and subscribers, but there wasn't a lot of documentation on how to use them and how to use it the way I needed to use it. I struggled a lot figuring out “do I want one on request”, “do I want one on response”, “what do I want it to do”, “why isn’t it consistent”? But in the end, it makes so much more sense.

How has Drupal 8 improved over Drupal 7?

The cleaner architecture and organization. I really like the use of yaml files and configurations for everything. I haven't had to use Features. I don't know if we can get into a perfect CI/CD where we don't have to do anything after you deploy. It takes far less time to deploy the new site... even when there are lots of changes. We just drop things into configuration and click one button and it's done. Everything is updated, that aspect is very masterful, and they have done a great job on making it work.

Yaml files are great, they're totally readable. Once you understand how they work, which ones you need, and why and where... it just works.

What advice do you have for people new to Drupal 8?

Don't be afraid to roll up your sleeves and dive into it. You don't have to be a master of object-oriented programming. If you want to be a JavaScript engineer, you're already working in objects and modules and it’s not going to be much different than working in PHP and Drupal.

Get a debugger, work in your IDE, look at all the objects, it makes it so much easier what functions to call on the objects. When you have it there, you can evaluate it, you can see how it's structured and it demystifies things. 

We all do console log, but once you actually get into a debugger, the game changes - even if you're not doing anything complicated. 

Be open minded, and remember that the skill set you're using for Drupal will stay with you and be useful in any other environment you want to work in.

Try to be an end-to-end programmer, there will be times when something is wrong in the database and you will need to figure it out. Drush, Drupal Console... they are your friends, don't be afraid to play. It's going to be a lot of trial and error, but totally worth it.

Jun 18 2018
Jun 18

What It Means to be Drupal Adjacent

One of the major objectives of Drupal 8 is the desire to “get off the island.” Drupal opened its doors to using and contributing to a broader ecosystem of projects instead of replicating functionality in Drupal. We now see tools like Twig and various Symfony components in Core. Contributed modules are also able to integrate projects and Software Development Kits (SDKs). For example, Password Strength, Digital Ocean, and Hubspot API integrate through Drupal’s native use of Composer. This philosophy helps those of us that more closely identify as “Drupal Adjacent.”

I consider being Drupal Adjacent as having some degree of experience in Drupal but maintaining expertise in a breadth of other technology. You are capable of leveraging Drupal’s strengths along with the strengths of other tools. Drupal Adjacent architects use “the right tool for the right job.” Drupal can serve as a bi-directional tool or framework in a broader architecture of systems and other tools can serve a discrete purpose.

As I consider myself Drupal Adjacent, I want to share my experience working in the Drupal community.

My Background

I have experience with a wide breadth of technology that includes Drupal. My first encounter with Drupal was in 2004. A friend of mine had a job implementing a CMS for her client. She evaluated many and chose Drupal - which was at version 4.x at the time. This was before the Security Team created issues and published patches. This was back before the mantra: “don’t hack core.” This was the time when that lesson was learned.

I came in as a backend developer with solid database experience. LAMP was all the rage and this was a great project for me to gain experience with a CMS and framework after writing my own basic CRUD (create, read, update, and delete a database record) without a framework. 

Living close to Silicon Valley, once the project ended, I moved on to other opportunities that came along that had different languages, platforms, and storage systems. 

Pareto’s Principle and Drupal projects

Over the next 12 years, I had many opportunities to come back to Drupal as it matured. I found how Pareto’s Principle (or the 80/20 rule) applied to Drupal projects. Some clients already had Drupal systems, but had hit limitations. Others had Drupal projects started but weren’t able to launch due to inability to fully integrate the modules they had in place. More than once I saw a site that was 80 percent complete with contrib modules, but still not ready to launch. I made an intermittent career out of helping those teams complete projects that needed custom code to close the gap and launch. 

Knowing my way around the Drupal API and framework, I knew how to write modules, hooks, and functions to add the final pieces. I knew when in the development lifecycle I should add custom code. I have written many modules, but many only addressed very niche, custom needs my clients had.

Drupal Adjacent

I have never built a site from scratch that has left my local environment. Don’t ask me to evaluate the best out of a dozen modules in the community. 

But, 

  • You want to upload data from your Drupal system to Hubspot for communication campaigns? I got your back.
  • Do you have years of data and would like use some of the new Big Data and Machine Learning tools out there?  Hundreds of field_data_field_% tables got you down? Set up a reporting database and create some views to normalize the data.
  • The outcome of several contributed modules has created a less-than-ideal outcome for your users? More than once I was able to write functions to change workflow states and other node properties with one user button click.

When you come to realize that not every solution has to be a Drupal solution, a world of tools open up to you. So many times your problem has already been solved, but perhaps not in a Drupal specific fashion. This is where your Drupal knowledge can help bridge that gap allowing use of best in breed tools.

May 15 2018
May 15

This month’s Accessibility Talk was an encore presentation of the panel’s Core Conversation at DrupalCon Nashville: Core Accessibility: Building Inclusivity into the Drupal Project
Helena McCabeCatherine McNally, and Carie Fisher discussed the fundamentals of accessibility and how they can be injected further into the Drupal project. All three are accessibility specialists in their fields.

Takeaways

What is accessibility and why does Drupal need it?

Web Accessibility is about building websites that accommodate people with disabilities. It is especially important in the Drupal community so people can be as self-sufficient as possible.

What disabilities primarily benefit from Web accessibility?

  • Visual Impairment - People who are blind or have trouble distinguishing between colors and color contrasts.
  • Deaf / Hard of Hearing - Some have trouble understanding content that is not captioned.
  • Motor disabilities - People who have fine or gross motor problems and it makes it difficult to use a mouse.
  • Vestibular issues and seizure disorders - These issues are often overlooked and those users can get motion sickness or have seizures from some of the special effects on sites.
  • Cognitive disabilities - Our aging group and people with autism or Down syndrome need to have an inclusive web and be allowed to be as self-sufficient as possible.

How do people with disabilities use the web differently?

  • Keyboard and Screen reader accessibility - Nothing on a website should need a mouse to interact with it. Descriptive text for images and destination of links are important for screen readers.
  • Captions and Transcripts - Captions happen in time with the audio and video, while transcripts are a full transcription of both the audio and visual information provided by a video. Transcripts are especially helpful to the blind/deaf user who might want to download the text into a braille reader.
  • Color and Contrast - The contrast ratio should be 4.5 to 1 for normal text and 3 to 1 for large text. It is best to stay away from using only colors to relay information.
  • Cognitive accommodations - Users benefit from a predictable, intuitive, and constant layout. That way they don’t have to re-orient themselves on how to use the website. Dyslexic people may need more time to process information especially if it’s complex. Don’t force people through content at a pace that cannot be controlled.

Why does Drupal need accessibility?

It is estimated that 2.2% of ALL websites are run on Drupal. The better Drupal Core is out of the box, the better it is for everyone.

  • End users may have disabilities.
  • Developers may have disabilities.
  • Clients and people within the agencies we build websites for may have disabilities.
  • It’s the law: Section 508, WCAG 2.0, and Title III of the ADA.
  • Drupal is for everyone!!

What are some recent Drupal core accessibility improvements?

  • Inline Form Errors module - This project is now stable in core. IFE alerts the user of a screen reader when there is an error when entering information on a form upon submission. The user does not have to rely on the error to be in focus to receive it.
  • Drupal.announce() and Drupal.tabbingManager - Extended coverage to more dynamic content.
  • Umami Out-of-the-box - This theme/demo illustrates Drupal’s accessibility features such as menu accessibility, primary tab theming updates, heading structures, and alt text for images.
  • Point Release - We no longer have to wait for major releases for continuous improvement.

What are some of the challenges we face in integrating accessibility into Drupal Initiatives?

  • Automated testing - QuailJS and other automated testing has been deprecated in core. It is not a perfect science, it only catches about 20%, but it does help with the more obvious issues.
  • Layout Builder - This is an experimental module that was added without an accessibility review. The “drag and drop” aspect does not have a widely adopted accessibility standard.
  • WCAG 2.1 - These guidelines are coming out later this year and will need to be addressed. We want to be proactive rather than reactive.
  • WAI-ARIA 1.1 - These have been out for a while, but there are still issues to be addressed.
  • Migrate - There needs to be a mechanism in place for tagging accessibility during migrations.
  • Media - Features for accessibility for videos and images would be great for things like transcripts. Clients would get a more robust experience if best practices are already incorporated. ie., alt text could be a required field.
  • Umami - Is in core now, but it still needs plenty of work.

Supporting Strategic Initiatives include: Theme component library, JavaScript modernization, Experimental admin UI, and Outside-In.

How can the community help increase accessibility in Drupal?

First of all, be aware that there are not enough experts in the area of accessibility. Some people feel that automated testing can be used, but in actuality, it only catches 20 - 40% of errors; but, manual testing can be time consuming and difficult. The standards for accessibility are constantly changing and adapting as the landscape evolves.

Why and how can we help?

  • Organizations - Improving accessibility can increase the user base, improve conversions, and save time and money. Organizations can make an effort to increase expertise by allowing contributions, providing resources, and sponsoring events.
  • Agency - Accessibility attracts employees and clients. It fosters inclusivity, which can help sell Drupal. Employees can be given the time to study and improve their knowledge. Client contracts and budgets should have accessibility baked in.
  • Community - The accessibility community provides an easy way to give back while helping others develop their skills and empathy. It helps Drupal stay relevant. Education is key: attend meetups and conventions, join online chats, and find a mentor.
  • Leadership - Taking the lead is easy. Mentoring, writing blogs, encouraging documentation, organizing events, and tagging issues can all help novices learn how to make the web more accessible.

How can you contribute and help?

There are many opportunities beside code that we can give back to the accessibility community to ensure diversity through inclusion. 

  • Code - Search the Drupal and GitHub issue queue for accessibility or a11y tags.
  • Documentation - Accessibility has a lot of documentation, but it could always use more!
  • Meetups - Connect with others in the community and bring your knowledge back to your peers or extended community.
  • Connections - Make positive connections through Twitter, Slack, and try to reach outside your network and beyond your own borders.

The Umami theme has open issues and will have more as content is generated:

  • Color Contrast Ratio updates
  • Redundant Links / Wrapping a card as one line
  • Message / Error Status State(s) indicated with color AND icons
  • Issues with Layout Builder

Resources

YouTube Video

A11Y Talks April 2018 - Carie Fisher, Helena McCabe, Catharine McNally - Drupal Accessibility​

General resources mentioned in the presentation:

Drupal Resources:

Drupal Accessibility Group

Join the Accessibility group on Drupal.org for hints, tips, discussions, and patch proposals to help make Drupal more inclusive.

May 15 2018
May 15

Dust off your saddle and get prepared to optimize your workflow. There is a lot packed into 3 days in Austin. Pull on your chaps, fasten your leathers, dig in your spurs and head on over to Texas Drupal Camp. On Thursday, make sure you check out the trainings and sprints. On Friday and Saturday, catch all of the keynotes and sessions.

Our own Ryan Bateman will be at Texas Drupal Camp to share his presentation about visual regression testing.

Texas Drupal Camp is Thursday, May 31st through Saturday, June 2nd at the Norris Conference Center in beautiful Austin, TX.

Deploy without fear – Visual Regression Testing with BackstopJS is here!

Deploying front-end changes can be scary – while you may have set out to make nothing more than a humble CSS change to the footer of a landing page, it’s very easy for that new CSS rule to cascade (excuse the pun) out of control, impacting other regions or pages in ways you never intended. With visual regression testing software like BackstopJS, however, we can rest assured that our changes are precise and contained.

This talk will cover the basic use and configuration of BackstopJS, as well as some Drupal-specific tips for optimizing your visual regression testing workflow on Drupal projects.

To read more about Ryan's session and to find out the location and time, skedaddle over to the session page: Deploy without fear – Visual Regression Testing with BackstopJS is here!
 

May 08 2018
May 08

For this month’s Drupal 8 Interview we were excited to catch up with Eduardo Garcia. He is the CTO of both WeKnow and anexus. WeKnow is a Drupal and Symfony consulting and training firm. Anexus is a company that supports the development of Drupal Console.

Most people in the open source and Drupal community know him as Enzo. His companies are mostly distributed and he likes to think of himself as a distributed person because of his love for travel. He is a native Colombian who lived in Costa Rica for more than 14 years. He currently resides in Australia with his family.

How long have you been working with Drupal and what version did you start with?

I am coming up on my 10th anniversary. I started with Drupal 5; my first project was for the Japanese car company, Mazda USA. It was a marketing website: public relations, news, and marketing releases for Mazda inside the United States.

I was learning, training, and leading the project. It's a similar process to how many people first get started with Drupal, not in perfect conditions. When I started the project, it was a month behind, but we delivered the project with only a two week delay. It was a good experience considering all the problems we had. I hated the process, but enjoyed the platform... despite all the problems we had; if in better conditions, you can create better products and have better interactions and reuse the knowledge you have and train people at the same time. I enjoyed that and this is why I decided to have my professional life be around Drupal.

How did your role evolve over the years to where you're at now?

The first two or three years I jumped from Drupal developer to a team lead. I was the person charged with providing technical leadership as to how to tackle a problem, provide solutions for the tickets, how to implement solutions for the clients, and was also responsible of training people.

At this same time I decided to try to build a Costa Rica Drupal community. I wanted to fill a void, I was maybe the second person using Drupal in Costa Rica, so I decided to build a community.

It was hard to engage with universities and companies. We created our first camp, this year is our 9th Drupal Camp Costa Rica, and it is the oldest and largest in Latin America. It is very international, we sometimes have 300-400 attendees depending on the location, we always have 25-50% people from USA, Europe, and all over Latin America coming to Costa Rica… because, you know Costa Rica... and Drupal.

When did you first start working on Drupal 8 sites?

It was about two or three years before it was released. Everybody in the community was concerned about the jump in technology. All these new things, I was worried about people being left behind in the process... As my role as a technical lead and a CTO of my own company, I was worried that maybe the move in the community will leave my own company behind.

So I decided to take action. I was very concerned about the whole Drupal ecosystem and joined the Drupal Console team. At the time it was led by Jesus Manuel Olivas and David Flores in Mexico. The Drupal Console project at that moment was in the beginning phase, it was a tool to help you ramp up in the learning curve from the inside out. I had to take unstable code and implement generators to try to accelerate the adoption in Drupal 8. 

When did you start mentoring people and training?

About two years before the Drupal 8 stable version was released. We worked with the idea that we need to reduce the scary moment of change.

Some people choose to contribute to core, which is of course the most important team in terms of development. We chose to tackle the problem from a different perspective. There were a lot of people who needed to become involved in the change and they needed something to try to help them. Learning all the new things can be complicated, but they can use Drupal Console to help them generate code by themselves and learn from there. The minimal tools are provided to create functional code and then the user is in a better position to learn the concepts and code.

What were some of the challenges you had when you first started working with Drupal 8?

That's a tough question, perhaps working with Symfony. Good changes are sometimes the most challenging changes. With Symfony, the whole idea is that we need to leave the island and use the bridges that Symfony console brings to us. Really, more than that, using something, not just in theory, the real implementation is the most difficult part. It’s like swimming, the first time you drop into the water it is scary and difficult. But after a few hours you are used to the water; it’s like a jump of faith.

What are some of your favorite things about working with Drupal 8 as opposed the earlier versions?

The same things. All the things that were scary are all the things I later enjoyed. I can now use more integration with less code. With Drupal 7, I would have to write lots of custom code, using the modern development practices allows me to create more fancy and professional integrations that in Drupal 7 would require more human effort.

If you could improve anything in Drupal 8, what would it be?

The first time user experience, Dries talked about this in his driesnote. For someone with zero Drupal experience, a marketer, CEO, or someone trying to illustrate the platform, it’s really hard for them to get it running by themselves.

Compared with other platforms which might be easier, like Symfony, Laravel, WordPress, or Magento… Getting a site up and running for the non technical person is very hard.

I want to emphasize to the community that Drupal needs to be made more accessible and have relevant content for users in other countries. Localization and multilingual needs to be seriously addressed. As a traveler, it is difficult to sell things to people that is not in their native language.

What advice do you have for people who are new to Drupal 8?

They really need to embrace the concept of using tools outside of Drupal. That will allow people to have an easier path into the code and more enjoyable journey into Drupal.

What is next for you, do you see any evolution?

On the company sides of things, we are working on trying to automate the process, using Drupal itself, using Symfony, and decoupling themes. We have been doing a lot with decoupled stuff and starting to play around with some artificial intelligence ideas. Maybe it sounds crazy, but why not?

What’s next for Eduardo?

Drupal Camp Costa Rica’s 9th anniversary is August 3-4 in Liberia, Guanacaste. The camp takes place just over 30 minutes from one of the most beautiful beaches in Costa Rica. This year promises Drupal (of course), front-end, back-end, business, projects, UX and more!

Eduardo has been asked to keynote at this year’s Drupal Camp Singapore in July. Follow Drupal Singapore on Twitter to keep up to date with their community.

May 03 2018
May 03

In March, A11y Talks welcomed Melanie Sumner, an application architect from JP Morgan Chase. She is an accessibility advocate and is an EmberJS core team member and meetup organizer in Chicago. The tagline for Ember is "the framework for building ambitious applications". Melanie spoke of ways to inject accessibility into not only the Ember project, but into other single-page applications so some users are not left behind.

Takeaways

Why do we ignore Accessibility?

Accessibility is emotional - It is easy to ignore things that are emotional. But, users are important! They need to be able to perform everyday tasks like checking their bank balances or buying items online. Lack of accessible websites can be frustrating and lead to thinking that developers don't care.

It is also emotional for developers. Timelines are a reality and the “ship it now and fix it later” doesn’t always work or happen in the real world.

Accessibility is hard - It is difficult to get accessibility correct when first starting out. There are some difficulties that should be solved no matter what framework is used.

  • Route transitions - Ember handles routes splendidly, but assistive technology doesn’t always pick up link events. 
  • Modals - There’s a difference between visible focus and screen reader focus and when using a modal the focus needs to be trapped. 
  • Aria attribute support - We need to be able to provide easy Aria attribute support, which isn't always done.
  • Click all the things - Attaching actions to all the things can be tricky, especially when events are nested into other events. Keyboard navigation needs to accessible for everyone.
  • Passwords - They need to be safe, but passwords can be difficult for screen readers.

Web standards are important

These give us easy wins by giving us accessibility by default. Easy wins include:

  • Use HTML 5 - Please use semantic HTML, divs are great but we should be using an HTML element.
  • Link vs. Button - If it goes to a route use a link. If it goes with a form or closes a modal, use a button. Focus on what is machine-readable more than what it looks like.
  • Keyboard Navigation - Anything that can be done with the mouse should be able to be done with the keyboard.
  • Color contrast - There are lots of color contrast tools available - USE THEM.
  • Image alt text - Add alt text to an image if it’s relevant to the image. EX- Images used within paragraphs don't need to be as descriptive as images used to sell products.

Pick your battles

There are things we need to do as a whole web community - not just within the Ember community. There are arguments about tabs vs. spaces or the div element vs. the semantic HTML5. HTML, CSS, and JS are all fundamentally important for creating accessible applications.

In the ember community there's the saying, “There’s an ADDON for that”. The following features already exist:

  • Ember - A11y - Relevant focus to views and outlets.
  • Ember - A11y Testing - Built on aXe core and takes the automated testing processor a little further.
  • Ember - A11y - Landmarks - Single page applications usually wrap everything in a div and put the div in the body, but then some of the landmark navigation regions or elements then require extra roles to be added. Ember is pushing to be able to opt out of the wrapping div.
  • A11y - Announcer - Tells which route you’re on when you switch routes.
  • Ember - CLI - Template-Lint - Helps make sure there are some extra accessibility rules written into the linter to help developers before they ship the code.
  • Ember - Component-Attributes - Is a stop-gap while we revisit how to handle attributes in components. This provides the biggest win by being able to add HTML attributes to existing components.

EmberJS list of accessibility addons

Solutions are happening NOW!

  • Sight - Engineers don’t always think of the little things... A new innovation, EnChroma, allows color-blind users to see things such as the red and green MacBook power cord lights.
  • Hear - Auditory brainstem implant surgeries help those with hearing loss know when sound is present or absent.
  • Auto-Generate Text - Microsoft has a project cloud service called Video Indexer. It can provide transcriptions, extract text that appears in the video, live translate to different languages, and it can adjust the language model used for transcription making it market specific.
  • Image Descriptions - Include.ai makes image descriptions more web accessible.

Most importantly

Remember you’re not alone! If you get stuck, ask the community, ask your mentors, and ask others. You just don’t know how to do it YET. “Be magnanimous”. Get involved and be present. Be sure to always have these issues addressed:

  • Keyboard navigation
  • Focus Management
  • Aria attribute support
  • Actively use semantic HTML

Resources

YouTube Video

A11Y Talks March 2018 - Melanie Sumner - Ambitious Accessibility

Links to the Slide Deck

Ambitious For All - Slides Only

Links mentioned in the talk:

Drupal Accessibility Group

Join the Accessibility group on Drupal.org for hints, tips, discussions, and patch proposals to help make Drupal more inclusive.

May 03 2018
May 03

Every year at DrupalCon our team has an amazing time. This year was no different. We rounded up everyone who attended and asked them about their favorites this year.

Technical information was being readily exchanged and processed, while the humans who make up the community shared many stories as well. On top of all of the good information there was good food, so much food!

Session / BoF / Training / Track / Summit:

Aimee: The Business Summit had a great turnout and fantastic contribuors. I enjoyed hearing about the state and direction of Drupal in the Driesnote, the Dries Q&A, and Gábor Hojtsy's review on the Drupal core innovation cycles.

AmyJune: I enjoyed participating in the Mentored Sprints... I love contributing to the Drupal project and I enjoy empowering others to do the same even more!

AmyJune helping folks during the Mentored Sprint Workshop
Photo credit: Amazee Labs

Carie: Hot JAMS(tack): Building a Music Discovery App with Drupal and React by Brian Perry was my favorite presentation of the Con due to the integration with components and React.

Chris: Surprisingly, various tools (Devops and otherwise). Along with some of the ancillary technologies and decoupled stuff.

Dan: The theme for me this year was DevOps, as always. Anything I can learn about DevOps is always interesting to me. It’s probably my favorite topic to talk and learn about. I went to a handful of DevOps sessions and learned a lot about how we can incorporate a more consistent DevOps workflow into our projects. Everyone on the team is part of the DevOps team. Communicate communicate communicate! In order for all of us to incorporate a good DevOps system of tools/workflows, etc., we need to communicate what we are doing, plans, etc. Drupal Coffee BoF was nice. I talked with some people who I’ve never met in person but have been interacting with on Twitter for a long time, as well as some people I’ve never met or talked to before. 

Darryl: I took the ReactJS training, and along with that, I took in a couple sessions having to do with decoupling. Actually, much of the React training wasn’t really about decoupling, but rather how to attach React to Drupal’s output, as an introduction. I went to a couple of sessions on the Layout Initiative and Layout Builder, as these seem to be where Drupal is headed. I also went to the I Was Wrong session, which was very interesting, and a very brave thing for the presenters.

Genevieve: I didn't make it to as many sessions this year as I have in the past; I did enjoy the  “I Was Wrong” session though. It was great to hear a variety of stories on ways in which people may have faltered and recovered in the past.

John: The two things that made me the happiest were: 1) seeing entries in the “Being Human” category, and 2) I knew a number of people who were presenting at DrupalCon for the first time and rocked it. With the latter, I am obviously heavily biased in the matter, but, hey… What are you going to do about it?

Kristen: I enjoyed all the Core Conversations and how we are trying to make Drupal easier for content editors, for site builders, and for developers.

Oliver: I was introduced to a couple of new things to put into the accessibility toolbelt, including an audit tool that is a bookmarklet (as opposed to an extension), which creates a pop-up on the page you’re currently on.

Ryan: I’m getting really excited about the movement happening with GraphQL in Drupal – talks like “Push vs. Pull: GraphQL in Twig” are showing off some interesting ways that GraphQL might even be a suitable alternative to conventional render arrays. I think the implications for decoupled Drupal as well as component-driven conventional Drupal sites are really interesting!

Social Events:

Adam: I loved the Pantheon party and the Amazee party. I really liked the restaurants there and small convos had.

Adam having a good time with other Drupallers
Photo credit: Susanne Coates

Aimee: I'm not supposed to say I was super excited to hang out with the Hook 42 team, but since we are all remote, it is a great opportunity to come together. Dancing and yoga-flash-mobbing in the basement room of the Pantheon / Lullabot party was hilarious and entertaining - for us and everyone watching. :D Genevieve, Kristen, and Greg Anderson: thank you for an excellent evening! 

AmyJune: The parties are always fun. I really enjoy reconnecting with folks from previous Cons and building stronger relationships. I enjoyed the game nights more than anything; unlike the parties, they provided a quiet atmosphere, which is much appreciated by mid-week!

Carie: All the social events were fun and the food and music in Nashville were amazing.

Chris: Plenty of good restaurants where it wasn’t too loud to talk, hanging out with new people and not being stuck in some dangerous part of town :)

Dan: Of course, any chance to hang with our team is fun. The Amazee party was great. I loved the tour of the Country Music Hall of Fame, as well as the food at Martin’s BBQ. I’m not a social butterfly but I did enjoy the Pantheon/Lullabot party as well, even though I mostly socialized with the Hook 42 team. I also enjoyed all the board games with John and David Needham from Pantheon.

Darryl: The Pantheon/Lullabot Party was fun, but perhaps too crowded for me. I really enjoyed the Amazee Labs party - a tour through the Country Music Museum and then what is reputed to be some of the best BBQ in Nashville.

Genevieve: I think each social event had its own special moment that made it a lot of fun. I do have to say, leading some yoga on the dance floor at the Pantheon/Lullabot party was pretty great! Thanks to handful of people who joined :) In general it is always fun to catch up with the team and see friends that we only get to see at DrupalCon. 

DrupalCon Nashville Coffee Birds of a Feather drawing pad with drupal drops and cups of coffee
Photo Credit: Daniel Rose

John: I went out three times for Hot Chicken, partook in two Official Board Game Nights, attended a Pantheon Partner Dinner and Women in Drupal both for the first time, and went to a Partridge in a Pear Tree. However, I probably had the most fun doing Impromptu Game Nights with friends and team members. And I’ll forever cherish the memory of scoring a Perfect Victory over Ryan in Street Fighter II and hold it near and dear to my heart, right next to the memory of him completely schooling me in every Pinball Game known to mankind. That kid sure plays a mean pinball!

Kristen: The Country Music Museum was interesting… so many gold records!

Oliver: The bingo cards at the Women in Drupal event were underrated. They got me talking to a lot of people I wouldn’t have otherwise interacted with.

Ryan: The Pantheon/Lullabot party was a great time. Otherwise, I loved all the great food but feel like I’ve progressed my Type-2-Diabetes Doomsday Clock six hours in one week!

Conversation:

Adam: Too many to count. They were all good.

Aimee: Lots of conversations about coffee, food, and music. Great to touch base with the Drupal community and meet new people in addition to connecting with old friends. And talks about layout... lots of layout talks... and security patches...

AmyJune: I found myself discussing compost a lot over the course of the week. Though they weren't necessarily my favorite conversations, they were definitely the most interesting.

Carie: Lots of great convos with old Drupal friends and met a lot of new people as well. Chatting with the accessibility team is always the highlight for me.

Chris: Plenty of great chats about mentoring for next year, simplytest.me and other complexities of the Drupal world with Adam, and the scary world of games with John, amongst many others.

Dan: To echo what Genevieve said, I didn’t have a favorite conversation. I enjoyed the many different conversations with lots of people from wandering in the exhibit hall to mentoring, training, Drupal Coffee BoF, etc.

Darryl: Lots of talk with the team I only ever interact with by typing on Slack. I also had a nice chat with Murray from Australia, while we were waiting to board the flight from SFO to BNA. He came halfway around the world to give a session on the Bricks module, a simpler way to get similar functionality to Paragraphs.

Genevieve: I don’t think I have a favorite conversation, but much conversation was had :) John may have a winner though!

John: If you could qualify an interaction with Genevieve that was an attempt to close a card game and ended with me literally rolling on the floor laughing as a conversation, then that was the best conversation. Also, shenanigans that happen after midnight are much, much funnier and amusing to a brain that is barely operational because it’s after midnight.

Kristen: I had a lot of fun talking with the Lingotek folks at the Acquia party. They are good people.

Oliver: I liked being prompted to converse by the bingo cards at the Women in Drupal event.

2 women discussing  life, the universe, and everything over some bingo cards at the Women In Drupal Party.
Photo Credit: Susanne Coates

Ryan: Maybe I’m just partial to the Hook 42 team, but some of my best conversations of DrupalCon were with folks on our own team. You guys are a riot!

Booth / SWAG:

Adam: The Life Aquatic shirts/hats from Lullabot were amazing. Loved the soft shirts from Linode.

Aimee: Four Chickens, without a doubt. I love me some Four Kittens, Four Chickens, and Four Kitchens. I missed out on the Drupal drop Pink Floyd prism from the DA. I'm on the hunt for one for Lindsay, who didn't attend DrupalCon this year.

AmyJune: I ended up taking mostly notepads from booths. In this digital age, it is always refreshing to go back to the basics by actually writing things down.

Carie: Lullabot shirts and hats were great. I always love the stuffed Digital Echidnas.

Chris: Life robotic shirts were great, also the Acquia one, a nice glass water bottle from FFW, also their combo usb cord, plenty of great stickers, usb power pack, many more things.

Dan: Lets see.. I got shirts from Pantheon, Linode, Hook42 :), Lullabot, Drupal Association. I got some stickers from many booths and as always I made an appearance every day at the Digital Echidna booth to play some hockey. I now own 2 echidnas and 2 Drupal drops. Someday I need to win that Drupal hockey jersey!

Digital Echidna stuffed Echidna in the expo hall
Photo Credit: Susanne Coates

Darryl: I got another yo-yo from JetBrains - the one from last year is still working, but the one from the year before gave up the ghost a while back, so having a spare is probably a good idea. (I gave up on T-shirts and hoodies years ago, I’ve probably donated >500 to Goodwill over the course of my career, and my collection is growing again in spite of not taking any as swag.)

Genevieve: I think the yo-yos from JetBrains win - but mostly because Darryl & Ryan taught me how to finally actually kind of use a yo-yo beyond just the basic skill of getting the yo-yo to return to you. :)

John: I actually have been actively trying to NOT get SWAG at Camps and Cons in an attempt to not clutter up the house, with the exception of the Obligatory T-Shirt from Event Being Attended. That being said, I walked away with two more T-Shirts than I expected: one from being a Sprint Mentor and the other a Drupal 8 Pac-Man shirt that I got in honor of Dan, who wasn’t able to get one in his size for himself.

Kristen: My teenage son really likes the Life Aquatic shirt. Some booths had earbuds which is also a great idea for people with teens.

Oliver: I’m keeping that 3.5” floppy (the Lullabot Party invite) I got until I can pop it into a computer and see what’s actually on it.

Red floppy disk invite for Lullabot party
Photo credit: Jeff Geerling

Ryan: Yo-yos! I had a miniature (okay, maybe not so miniature) nostalgia trip playing with my JetBrains yo-yo for a day (okay, maybe I played with it for several days). I also re-stickered my laptop with some new and cool stickers – the ones from Siteground in particular were really fun.

Nashville:

Adam: I liked that it was walkable and there were many amenities close by. The hotel was great. The area was fun, even though I’m not a country music fan. The venue was good (slightly confusing to navigate).

Aimee: The neon. The sparkles - everything is Bedazzled. The music. The walkability. The food - SO MUCH BBQ. Nom. 

AmyJune: I loved all the music coming from every door we passed. Being a vegetarian was a little challenging at times, but there was plenty of beer to satiate my appetite! 

Carie: I am also not a country music fan, but there was enough to do outside of that to keep you busy...including shopping for cowboy boots ;)

Dan: Nashville was great. Everything that we needed was within walking distance. I wished I could’ve made it to the hockey game which was right next door. The food was fantastic. Favorite restaurants were Puckett’s and Martin’s BBQ. Country Music Hall of Fame was pretty interesting as well. Also bought a nice cowboy hat. Will definitely go back to Nashville again.

The Hook 42 team having BBQ in Nashville
Photo Credit: Carie Fisher

Darryl: Nashville was fun - I regret all those times I drove by on I-40!

Genevieve: It was fun to get to see Nashville in a month other than January. All the past times I’ve been it has been very cold so there has been a bit less walking around. It was also nice that there were a lot of food and entertainment options nearby. 

John: Having so many things within walking distance of the venue was awesome. It was also really fun having those Random “Music Boxes” on what seemed like every other street corner blaring out tunes; it helped to really drive home that Music City feel.

Kristen: Everything seemed really close and easy to get too and I had some good BBQ at Martin's. It was actually a lot more modern than I expected… lots of modern-style buildings.

Oliver: At night, the downtown was like a mini-Vegas, except with boot stores instead of casinos.

Ryan: So. Much. Food. I’d never had an opportunity to go to Nashville, so it was really fun to see the city despite the fact that we brought 40-degree temperatures with us those first few days. The amount of live music in the city was amazing!

Overall:

Adam: A very great experience that made me feel closer to the community and the team. I really enjoyed it.

Chris and Dan at the Hook 42 booth during DrupalCon Nashville
Photo credit: Carie Fisher

Aimee: Every DCon is a bit different. It was great meeting contrib maintainers that I've seen online for years and just met in person. It is exciting to see where Drupal and the community is heading! 

AmyJune: Of course, the community is my favorite aspect of every Drupal event. I love meeting the maintainers of projects I have contributed to and discussing further collaboration.

Carie: It was a good DCon. Every year seems better and better, but that could be because I know more people each year, so more like visiting with friends instead of just meeting strangers.

Dan: DrupalCons and camps are always a great experience for me. It’s nice to connect with others from around the world in the Drupal community. Of course, it’s always great to see our team members in person as well. This DrupalCon was fun because I felt more connected with others in the community. There were a lot of people that knew me or at least knew my name from my contributions and interactions, etc. That was a neat feeling.

Darryl: Our company is basically all remote, even the Bay Area locals mostly work from home, so getting to see everyone and chat is great!

Genevieve: As with every other year, I think my overall favorite thing usually ends up seeing all the team members we don’t get to see during the rest of the year. We had some newer team members with us this year, so that was also extra enjoyable to have some new perspectives (and lots of board games… thanks to John) with us. 

John: At this point, every DrupalCon for me is more like a Family Reunion, with the greatest pleasure coming from reconnecting with old friends and getting the chance to interact with team members in-person, especially since we’re practically all remote. It’s always fun making new connections as well, and I was pleasantly surprised to talk to so many people who were new to Drupal (as recent as March!) and loving what they’ve been exposed to so far.

Kristen: The people are always the favorite part… both seeing everyone from our remote team to lots of people from the community from all over the world. Also, I think Core Conversations was an awesome track this year. :)

Oliver: It was great getting to meet some team members in person for the first time and see others again for the first time since BADCamp. Getting to interact in person definitely has a different vibe than collaborating remotely. It was a really great experience.

Ryan: This was my first DrupalCon ever, so I was incredibly excited about finally being able to attend, and it was nothing short of my expectations! I learned a ton, had great conversations, and really enjoyed seeing so many Drupalers in one place at the same time :)

Ryan Bateman playing the guitar in the expo hall at DrupalCon Nashville
Photo Credit: Jeff Geerling

See everyone soon!

We're looking forward to seeing everyone again at BADCamp in the fall... Seattle next year... and in Minneapolis in 2020! In the meantime, keep contributing, keep building community, and keep moving the Drupal project forward!

Apr 23 2018
Apr 23

DrupalCon is more than just a conference for networking and learning; it provides an avenue for contributing back to the project during code/contribution sprints. Being a beginner to the issue queue can be daunting and overwhelming. With the help of mentors, novices can get the tools and support they need to jump in and start contributing.

Chris, AmyJune, Daniel, and John took it upon themselves to volunteer as mentors at the DrupalCon Nashville Sprints and we thought we’d share their afterthoughts to empower others to help with mentoring in the future.

Chris:

Never having mentored before, I signed up for mentoring on a whim... Mostly because I felt it was something everyone should try to do to help out, in as much as their abilities allow, but also for all the glory that would be bestowed upon us mythical beings at the end of the week.

DrupalCon Nashville Sprint mentos meeting in the morning

Photo credit: David Needham

Seeing that I spend most of my professional life in the land of D7, that I was wary about how much I could contribute, and that I was rather worried about messing up and giving the wrong advice, I started off helping people get set up. Having the Sprint Package was incredibly handy for getting people on a standardized setup, one that I was able to test and retest earlier on in the week to find all of the 'issues'. For the few that wanted to do something different, where I wasn't able to help, there was always someone else around to give a hand, so I never felt like I had to resort to spending 20 minutes on Google trying out different solutions!

From there moving to the first time sprint workshop and helping a team work on some issues collaboratively, reminded me that you don't need to be a D8 guru to help out. Most of the issues were not particularly D8 related, and had us looking for answers in accessibility, finding and reporting new bugs, and working on small CSS fixes. I really enjoyed the energy in the room, the fact that people left feeling as inspired as I had on my first sprint workshop various years ago, and that I had been part of that.

AmyJune:

I love contributing to the Drupal issue queue. I enjoy the feeling that comes along with knowing I am moving the Drupal project closer to perfection. Even more than that, I love sharing my knowledge with others, so volunteering to mentor at the sprints was a no-brainer. I don't spend the majority of my time coding, but I have been an active participant in the issue queue for over 2 years. Sharing what I know and inspiring others who are either new to tech or who have roles that have traditionally prevented them from contributing is the real reason I chose to mentor.

Early in the week, Dan and I sat at the Mentoring booth in the expo hall and invited all who would listen to the Friday sprints. We encouraged people from all backgrounds to swing by and check it out.

Dan and AmyJune sitting at the DrupalCon Mentoring table talking with a potential sprinter.

Photo credit: Mike Gifford

I started Friday by welcoming sprinters and directing them to either the First Time Sprinter Workshop if they needed help setting up their local, the Mentored Sprint Room, or the General Sprints. From there, I moved to the First Time Workshop and the Mentored Sprint Room to help folks contribute to documentation. Documentation is so important, it removes a huge hurdle to entry. It’s difficult to feel empowered when you’re lost from the beginning, so helping others to improve documentation feels especially good.

Daniel:

Dan helping a sprinter at DrupalCon Nashville First Time Sprinter Workshop

Photo credit: David Needham

I chose to volunteer because I really enjoy working with the Drupal community. It’s a great way for people to meet other developers and non-developers alike. There is a lot we can learn from one another. We all have different perspectives and hearing/seeing how someone else does something could be a great learning experience for both mentor and mentee. The same goes for general collaboration in the community. I enjoy reaching out with questions to the Drupal slack channels and reading feedback on issues in the issue queues. I love learning from others and seeing things from different perspectives.

Of course, being a mentor is also rewarding. I enjoy the feeling of helping someone learn something new that potentially unblocks them at work or breaks down a barrier to the community contrib space. I enjoy helping as a way of paying it forward for those that helped me along the way. I wouldn’t be where I am without their help.

John:

I was raised with the mentality that whenever you can help out, you should help out. Maybe one day that kindness gets returned, or maybe it doesn’t, but you still leave the world in a better place, and that’s never a bad thing. That being the case, I like to give back to the community wherever I can.

I’ve always enjoyed being a mentor and trainer at camps and cons, and in particular working with people who are just getting started out with something. I remember what it was like to be there, and how things would have been so much easier if I had a guide to point me in the right direction and walk me through those first few steps. While you may not know everything about a given topic, any experience you have is more than someone who’s in the early beginning stages, and the knowledge that you might take for granted as obvious can be worth its weight in gold to someone hearing about it for the first time.

John helping a sprinter at the First Time Sprinter Workshop

Photo credit: David Needham

Even if you’re not super technically savvy in mega hyper fighting web development skills, there are still a great many things that you can do to help out. I mean, one of the things that I did was take attendance, and that’s something simple that anyone could do! Don’t be shy, put yourself out there, and lend a hand where you can. Any little thing that you can do will lighten the load for everyone, and that makes every contribution important.

We hope to see all of you next year in Seattle!!

Remember, you don't have to be technical to contribute to the Drupal project. And, you don't have to be a master to help mentor people on how to get started in the issue queue.

Pages

About Drupal Sun

Drupal Sun is an Evolving Web project. It allows you to:

  • Do full-text search on all the articles in Drupal Planet (thanks to Apache Solr)
  • Facet based on tags, author, or feed
  • Flip through articles quickly (with j/k or arrow keys) to find what you're interested in
  • View the entire article text inline, or in the context of the site where it was created

See the blog post at Evolving Web

Evolving Web