Feeds

Author

Aug 13 2019
Aug 13

A great place to start a conversation about decoupled Drupal is evaluating Contenta CMS. While Contenta CMS is not necessarily something you must have to build a decoupled Drupal 8 site, it is designed to do it. You can relatively easily create a vanilla Drupal site that supports a decoupled application, but Contenta has already solved many of the related problems.

So what is Contenta CMS exactly? 

Contenta CMS is an API-first Drupal 8 distribution intended to be used to build fully decoupled Drupal sites. It was built by the developers of many of the modules you may end up using as you build your decoupled site, using their defined best practices to address typical needs and challenges. It is meant to be 100% decoupled, and only uses Drupal 8 as an administrative backend with no user-facing HTML content. This is something you could change if you desired to do so.

At first it seemed like a magical, mysterious system. However, Contena uses core and well-known contributed modules with only a single custom module that provides a few customizations. With only a few small tweaks, you could conceivably have a base system for your decoupled project with Contenta CMS as you would any Drupal 8 project.

Features

The main difference between Contenta CMS and a site you would conceivably build yourself lies in the only custom module the distribution comes with, Contenta Enhancements. This module primarily does a few things:

  • creates a new, streamlined administration toolbar for a decoupled site,
  • provides some additional local tasks menu items giving easy access to necessary configuration,
  • alters the node view to display JSON instead of HTML, allowing for easy viewing of node structure, and
  • disables certain routes not needed or necessarily useful for a decoupled site.

Because this is a Drupal module, you’re perfectly fine installing it in your own clean Drupal 8 install to try to replicate Contenta along with the contributed modules used.

Key Modules

The following modules make up the underlying Contenta architecture.

Consumers

Consumers is a utility module that allows other modules to define users of the API and then further allows administrators to manage access control for each consumer. 

Decoupled Router

As the module description states, "Decoupled Router provides an endpoint that will help you resolve path aliases and redirects for entity related routes. This is especially useful for decoupled applications where the editor wants full control over the paths available in the consumer application (for instance a React app)."

To further understand the purpose of Decoupled Router, read the great post (and series) by the module creator.

JSON:API (now part of Drupal 8.7 Core)

JSON:API is a plug and play module that fully implements the JSON:API Specification that without configuration exposes your Drupal entities via a REST API.

JSON:API Extras

JSON:API Extras extends the JSON:API module by allowing customizations and management of API endpoints. The JSON:API module does not offer any configuration options.

JSON-RPC

While JSON:API exposes Drupal entities via a REST API, JSON-RPC exposes Drupal administrative actions that would otherwise not be easily accessible or handled using the REST API.

OpenAPI

The OpenAPI is a utility module that allows your Web Services to be discoverable using the OpenAPI standard and thus neatly documented for testing and development when used in addition the OpenAPI UI and either something like OpenAPI UI Redoc or another similar module.

OpenAPI UI

OpenAPI UI helps provide a user interface within Drupal for displaying your OpenAPI standards-based API explorer for your Drupal site.

OpenAPI UI Redoc

This module provides a plugin that implements Redoc for use with OpenAPI UI to display from within Drupal. This is akin to GraphiQL in the GraphQL standard.

preview of redoc in drupalOpenAPI UI using Redoc in Contenta

SimpleOauth

SimpleOauth is an implementation of the OAuth 2.0 Authorization Framework RFC for Drupal allowing you to use Oauth 2.0 for user authentication.

Subrequests

The subrequests module allows aggregated requests and responses to be sent to Drupal. For example, instead of sending a request for a node and then the node’s associated taxonomy terms, it allows you to send a single request that returns all the data you’d need. The goal being to make decoupled applications more efficient by reducing requests. An excellent article on the motivation for this module can be found on Lullabot’s blog.

Installing Contenta

To get started, head over to the Contenta install page. After installing, run: drush runserver 127.0.0.1:8888 to run server, then access 127.0.0.1:8888 to view site.

preview of contenta home screen

Upon logging in, you will find a familiar interface, with some slightly different links available, with all but the “API” link leading to common Drupal administration pages, and the “Advanced Link” exposing the default Drupal administration toolbar.

preview of contenta admin screen

You should be now ready to begin building your decoupled site. In the following posts in this series, I will explore doing just that.

Conclusion

By adding and configuring the above modules to a new or existing Drupal 8 site (I can’t stress enough that you must install modules using composer), configuring CORS (if needed), you should be ready to begin developing your decoupled application using the technology of your choosing so at this point I wish you happy trails!

*P.S. The folks that brought you ContentaCMS also created ContentaJS, “a nodejs server that proxies to Contenta CMS and holds custom code”. It’s certainly not necessary to begin your decoupled journey, but it does provide some handy features that I think could be extremely useful.
 

Aug 06 2019
Aug 06

Author’s Note: No rabbits were harmed in the writing of this post.

This summer, I had the opportunity to attend Decoupled Days 2019 in New York City. The organizers did a fabulous job of putting together an extremely insightful, yet approachable, program for the third year of the conference to date.

In case you haven’t heard of the event before, Decoupled Days is somewhat of a boutique conference that focuses solely on decoupled CMS architectures, which combine a CMS like Drupal with the latest front-end web apps, native mobile and desktop apps, or even IoT devices. Given the contemporary popularity of universal Javascript (being used to develop both the front and back ends of apps), this conference also demands a strong interest in the latest JavaScript technologies and frameworks.

If you weren’t able to attend this year, and have the opportunity in the future, I would highly recommend the event to anyone interested in decoupled architectures, whether you’re a beginner or an expert in the area. With that in mind, here are a few of the sessions I was able to attend this year that might give you a sense of what to expect.

Christopher Bloom (Phase2) gave an excellent performance at his session, giving all of us a crash course in TypeScript. He provided a very helpful live demo of how TypeScript can make it much easier and safer to write apps in frameworks like Vue.js, by allowing for real-time error-checking within your IDE (as opposed to at runtime in your browser) and providing the ability to leverage ES6 Class syntax and decorators together seamlessly.

Jamie Hollern (Amazee Labs) showed off how it’s possible to have a streamlined integration between your Drupal site and a fully-fledged UI pattern library like Storybook. By using the Component Libraries, GraphQL, and GraphQL Twig contributed modules in concert with a Storybook-based style guide, Jamie gave a fabulous demonstration of how you can finally stick to the classic DRY (Don’t Repeat Yourself) principle when it comes to a Drupal design system. Because Storybook supports front-end components built using Twig markup, and allows for populating those components using mock data in a GraphQL format, we can use those same Twig templates and GraphQL queries within Drupal with almost no refactoring whatsoever. If you’re interested in learning more about building sites with Drupal, GraphQL, and Twig, Amazee Labs has also published an “Amazing Apps” repo that acts as a sample GraphQL/Twig sample project.

For developers looking to step up their local development capabilities, Decoupled Days features two sessions on invaluable tools for doing decoupled work on your local machine.

Kevin Bridges (Drud) showed how simple and straightforward it can be to use the DDEV command-line tool to quickly spin up a Drupal 8 instance (using the Umami demo site profile, for example), enable the JSON:API contributed module in order to expose Drupal’s data, and then install (using gatsby-cli) and use a local Gatsby.js site to ingest and display that Drupal data.

Matt Biilman (Netlify) also demonstrated the newly launched Netlify Dev command-line tool for developers who use Netlify to host their static site projects. With Netlify Dev, you could spawn an entire local environment for the Gatsby.js site you just installed using DDEV, which will be able to locally run all routing rules, edge logic, and cloud functions. Netlify Dev will even allow you to stream that local Gatsby.js site to a live URL (i.e., on Netlify) with hot-reloading, so that your remote teammates can view your site as you build it.

As usual, Jesús Manuel Olivas (WeKnow) is always pushing the Drupal community further and further, this time by demonstrating his own in-house, Git-based CMS called Blaze, which is a platform that could potentially replace the need for Drupal altogether. Blaze promises to provide the lightest-weight back-end possible for your already light-weight, static-site front-end. In lieu of a relatively heavyweight back-end like Drupal, Blaze would provide a familiar WYSIWYG editor and easy content modeling with a few clicks. The biggest wins from using any Git-based CMS, though, are the extremely lowered costs and lightning-fast change deployments (with immediate updates to your code repo and CI/CD pipeline).

Jul 29 2019
Jul 29

This year, Drupal GovCon had an amazing turnout. So great that the registration was at full capacity and had to cap attendance at 1,500 people!

Our team had an amazing time exploring Bethesda, from the conference grounds to the thriving community around it. While there we enjoyed conversing with the community, and forging new relationships. We learned many things, and shared our experiences with many others as well. Overall, it was a great environment for exploration and growth.  

From Hook 42 we had a first-time ever Drupal event attendee, an experienced Drupal veteran, and a goldilocks somewhere in the middle community member join forces. With the variety of community involvement just from our team alone, there were many different expectations attending this event and each person had their own goals and takeaways from this experience. We’re excited that an event can bring so many different people together and provide an experience that resonates with many different community members. Here's what we took away from this GovCon this year.

Aimee's Thoughts

GovCon 2019 delivered another great experience for me. I am a huge advocate of GovCon. I have found great value in my time spent here and look forward to returning each year. This camp is such a well run event that consistently delivers an inclusive, supporting and rewarding experience. I very much enjoyed my time there as a speaker, member and participant. I appreciated the structured content as well as the well attended after events where I got a chance to catch up with old friends, and meet many new people.

The sessions line up at GovCon 2019 was packed full of talented and useful information. There was so much I couldn’t attend that I’m especially grateful for the YouTube recordings. A big shout out for Kevin Thull and the team for getting these up!

It was an honor to be able to deliver my keynote, CommYOUnity: Fostering Healthy Contribution, at GovCon. Community is such a vital, core value to Drupal and that community is built on you and me. When we can build healthy relationships and make time to take care of ourselves we’re actively working on taking care of the community.

Thanks again for the wonderful opportunity and great experience GovCon!

Ryan's Thoughts

First, I wanted to give a big thank you to the event staff and volunteers who made GovCon 2019 possible. I am a first time GovCon attendee and had a great time. I knew when and where the sessions I was interested in were and found my way around NIH easily. The great planning and coordination that went in to GovCon made my experience very enjoyable.

Janessa Worrell and Brianna McCullough, from Acquia, gave a great presentation on governance, "Winter is Coming: How to Use Good Governance to Prevent your Organization from Becoming a Game of Thrones". They brought awareness to some of the harder to reach topics that help an organization align to make better project decisions and did it in an entertaining and informative way.

It was a pleasure to meet David Minton and Stephen Pashby from DesignHammer and then later see their presentation on estimation, "Successful Project Estimation: How To Get Your Weekends Back". Their modeling on historical throughput with detailed task tracking is an engaging idea I think we could put to use. 

I really appreciate the community that came together to share their thoughts and experiences and I look forward to my next opportunity to attend.

Lindsey's Thoughts

I’m semi-local to DC, and very familiar with the area so much so that I would come here as a child on field trips and such. I wasn’t coming here with the excitement of exploring the local community and the city, but more so with the intention of bonding with the Drupal community itself. Making connections with people that are experiencing similar situations as I evolve within the Drupal world is very important to me.

I spent most of my time holding down the booth, talking with many people about the great things our team has to offer. It’s a great way for a new Drupal-member to get to know a lot of people. For the first time ever, I experienced the joy of seeing connections I made at another Drupal event, and seeing their faces in the community again. Those bonds are already strengthening and I couldn't be happier! I am getting to understand just how connected our community really is.

When I wasn’t at the booth I attended sessions about accessibility. One common theme in all of them is that the speaker always shared empowering experiences that would resonate with the audience. They weren't necessarily technical, or Drupal related, but they provided a very humanistic connection to an issue that is usually backed by threatening legal concerns. 

I enjoyed hearing Shawn Brackat from Forum One sharing a story of a blind couple receiving a 3D model of an ultrasound, and Catharine McNally from Phase2 sharing her stories about growing up deaf and receiving the first ever study on cochlear implants. These are aspects of accessibility that people really bond with. Being inclusive is more than just avoiding a lawsuit. It’s about making things easier for everyone, and providing ways to accommodate those that do things differently. Everyone experiences things differently, disability or not, and it's important that we keep that in mind as we build digital experiences for the masses.

I enjoyed participating in my first GovCon in a variety of ways. Whether that was sitting at the booth, attending sessions, or dinner with great friends - I have had so many wonderful experiences. I’m already looking forward to next year.

Wrapping Up

The community always goes above and beyond, providing experiences that everyone can resonate with. GovCon did not fall short of those high standards. We’re so thankful to all of the organizers, and happy to have been one of many great sponsors that can help support events like these. All of us had a wonderful time, and we’re happy to be so involved with a community that has a great ecosystem. We’re already planning our next event... we’ll see you in Denver!
 

Jul 26 2019
Jul 26

We’ve recently wrapped up another great Drupal event, at Drupal Camp Asheville. The sponsorship our team provided, in conjunction with the support of many others, helped the camp achieve many goals that we are proud to have been a part of. 

The experiences our team had stood up to the expectations of all Drupal events,

From Hook 42, we had three people who were able to participate this year, and each member of our team had different expectations going in, and learned many valuable things. Here’s what they have to say.
 

Danita’s Experience

Although it was only my second year of attending Drupal Camp Asheville, it already feels like “home.” One of the highlights of any Drupal camp or con or meetup is getting to see old friends and meeting new ones, and this camp doesn’t disappoint. An added bonus was getting to hang out with two Hook 42 colleagues (including Jonathan, one of the camp organizers), something that doesn’t happen often enough with a remote team.

On Friday, I joined a fairly packed room for a full-day training on CSS Grid and Flexbox with Wes Ruvalcaba, Senior Front-end Developer at Lullabot. Along with how to use Grid and Flexbox, Wes shared some tips and tricks he uses when theming Drupal websites. Even though I’ve used both Grid and Flexbox before, I came away from that all-day training with a better understanding of when and how they are “supposed” to be used - and to quit using “floats” for layout!

Sessions I attended on Saturday included one on contributing back to Drupal presented by Amy June Hinelline, Kanopi’s Community Ambassador. It was a good reminder that anyone (not just super-experienced coders) can do something to contribute and that our contributions make the community stronger.

In addition to the trainings and sessions and “hallway track” conversations, the social events and just the location of the camp in Asheville make this a not-to miss camp. I know I can’t wait until next year. 

Jonathan Experience

Another great year at Drupal Camp Asheville. On Thursday we all gathered to play games and hangout at the Wedge. Friday I gave my full-day “Essential Drupal 8 Developer Training”, and it went really well. I had a full class with lots of great questions and comments, and like last year, my voice started to give out. I didn’t record the training this year, but it was basically the same as 2018. Videos, slides, and code examples for the training are all available online.

Saturday we had an amazing group of presenters show off some of their best work and discuss topics they are passionate about. As an organizer, we made a lot of effort ensuring that there were great sessions for almost any topic related to Drupal or Drupal adjacent. We had everything from improving client interactions to an overview of the JSON:API, from understanding Drupal 8’s caching mechanisms to a discussion of emotional labor in communities, and from working effectively as a remote team to data analysis and visualization.

All sessions were recorded and uploaded to YouTube. Full playlist Drupal Camp Asheville 2019 sessions

As an attendee, it was really great to see the old guard and meet some of the new. I had a great chat with a new Drupal developer who is implementing a chat bot for his university, enjoyed tacos and beverages with the creators of Backdrop CMS, and talked about video games with friends as we hiked up to Catawba Falls. It’d be difficult to list each great interaction I had because there were good people and fun conversations happening practically the whole time. 

Biased opinion: I can’t recommend Drupal Camp Asheville enough. Thanks to all the hard work by our Director April Sides, the camp is well managed and a wonderful, casual, and considerate event for everyone. Hope to see you there next year! 

Group photo of drupal asheville attendees waving
 

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 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 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

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

 

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