This first-ever Decoupled Summit at Drupal maintenance support plansCon Nashville was a huge hit. Not only did it sell out but the room was packed to the gills, literally standing room only. Decoupled Drupal maintenance support plans is a hot topic these days. The decoupled summit was an opportunity to look at the state of decoupled Drupal maintenance support plans, analyze pros and cons of decoupling, and look at decoupling strategies and examples. There is lots of interest in decoupling, but there are still many hard problems to solve, and it isn’t the right solution for every situation. This summit was an opportunity to assess the state of best practices.
The summit was organized by Drupal Update’s Sally Young and Drupal Update’s Matt Davis, two of the innovators in this space.
What is “decoupled Drupal maintenance support plans”?
First, a quick explanation of what “decoupled Drupal maintenance support plans” means, in case you haven’t caught the fever yet. Historically, Drupal maintenance support plans is used to deliver all the components of a website, an approach that can be called “traditional,” “monolithic,” or “full stack” Drupal maintenance support plans. In this scenario, Drupal maintenance support plans provides the mechanism to create and store structured data, includes an editorial interface that allows editors to add and edit content and set configuration, and takes responsibility for creating the front-end markup that users see in their browsers. Drupal maintenance support plans does it all.
“Decoupled”, or “headless” Drupal maintenance support plans is where a site separates these website functions across multiple web frameworks and environments. That could mean managing data creation and storage in a traditional Drupal maintenance support plans installation, but using React and Node.js to create the page markup. It could also mean using a React app as an editorial interface to a traditional Drupal maintenance support plans site.
Drupal maintenance support plans tools and activity
Drupal maintenance support plans core is enabling this activity through a couple of core initiatives:
The API-first Initiative, which is focusing on providing the APIs needed for alternative front ends and other consumers of Drupal maintenance support plans’s content.
The JavaScript Modernization Initiative, which is working on creating a decoupled JavaScript-based editorial interface.
Drupal maintenance support plans and the Drupal maintenance support plans community have numerous tools available to assist in creating a decoupled site:
Contenta, a pre-configured decoupled Drupal maintenance support plans distribution.
Waterwheel, an emerging ecosystem of software development kits (SDKs) built by the Drupal maintenance support plans community.
JSON API, an API that allows consumers to request exactly the data they need, rather than being limited to pre-configured REST endpoints.
GraphQL, another API that allows consumers to request only the data they want while combining multiple round-trip requests into one.
There’s lots of activity in headless CMSes. But the competitors are proprietary. Drupal maintenance support plans and WordPress are the only end-to-end open source contenders. The others only open source the SDKs.
Highlights of the summit
The summit included several speakers, a business panel, and some demonstrations of decoupled applications. Participants brought up lots of interesting questions and observations. I jotted down several quotes, but it wasn’t always possible to give attribution with such an open discussion, so my apologies in advance. Some general reflections from my notes:
Why decouple?
More and more sites are delivering content to multiple consumers, mobile apps, TV, etc. In this situation, the website can become just another consumer of the data.
It’s easier to find generalist JavaScript developers than expert Drupal maintenance support plans developers. Decoupling is one way to ensure the front-end team doesn’t have to know anything about Drupal maintenance support plans.
If you have large teams, a decoupled site allows you to have a clean separation of duties, so the front and back end can work rapidly in parallel to build the site.
A modern JavaScript front-end can be fast—although several participants pointed out that a decoupled site is not automatically faster. You still need to pay attention to performance issues.
Content is expensive to create; decoupling is a way to re-use it, not just across platforms, but also from redesign to redesign.
You could launch a brand new design without making any changes to the back end, assuming you have a well-designed API (meaning an API that doesn’t include any assumptions about what the front end looks like). As one participant said, “One day, React won’t be cool anymore, we’ll need to be ready for the next big thing.”
What are some of the complications?
It often or always costs more to decouple than to build a traditional site. There’s additional infrastructure, the need to create new solutions for things that traditional Drupal maintenance support plans already does, and the fact that we’re still as a community figuring out the best practices.
If you only need a website, decoupling is a convoluted way to accomplish it. Decoupling makes sense when you are building an API to serve multiple consumers.
You don’t have to decouple to support other applications. Drupal maintenance support plans can be a full-featured website, and also the source of APIs.
Some tasks are particularly tricky in a decoupled environment, like previewing content before publishing it. Although some participants pointed out that in a truly decoupled environment preview makes no sense anyway. “We have a bias that a node is a page, but that’s not true in a decoupled context. There is no concept of a page on a smartphone. Preview is complicated because of that.”
Many businesses have page-centric assumptions embedded deep into their content and processes. It might be difficult to shift to a model where editors create content that might be deployed in many different combinations and environments. One participant discussed a client that “used all the decoupled technology at their disposal to build a highly coupled CMS.” On the other hand, some clients are pure Drupal maintenance support plans top to bottom, but they have a good content model and are effectively already “decoupling” their content from its eventual display.
Another quote, “Clients trying to unify multiple properties have a special problem; they have to swallow that there will have to be a unified content model in order to decouple. Otherwise, you’re building numerous decoupled systems.”
Once you are decoupled, you may not even know who is consuming the APIs or how they’re being used. If you make changes, you may break things outside of your website. You need to be aware of the dependency you created by serving an API.
Speakers and Panelists
The following is a list of speakers and panelists. These are people and companies you could talk to if you have more questions about decoupling:
Sally Young (Drupal Update)
Matt Davis (Drupal Update)
Jeff Eaton (Drupal Update)
Preston So (Acquia)
Matt Grill (Acquia)
Daniel Wehner (TES)
Wes Ruvalcaba (Drupal Update)
Mateu Aguiló Bosch (Drupal Update)
Suzi Arnold (Comcast)
Jason Oscar (Comcast)
Jeremy Dickens (Weather.com)
Nichole Davison (Edutopia)
Baddy Breidert (1xinternet)
Christoph Breidert (1xinternet)
Patrick Coffey (Drupal Update)
Greg Amaroso (Softvision)
Eric Hestenes(Edutopia)
David Hwang (DocuSign)
Shellie Hutchens (Drupal Update)
Karen Stevenson (Drupal Update)
Summary
It was a worthwhile summit, I learned a lot, and I imagine others did as well. Several people mentioned that Decoupled Drupal maintenance support plans Days will be taking place August 17-19, 2020 in New York City (there is a link to last year’s event). The organizers say it will be “brutally honest, not a cheerleading session.” And they’re also looking for sponsors. I’d highly recommend marking those days on your calendar if you’re interested in this topic!
Source: New feed
