Upgrade Your Drupal Skills

We trained 1,000+ Drupal Developers over the last decade.

See Advanced Courses NAH, I know Enough
Feb 28 2024
Feb 28

Applications are sought for the position of Project Update Working Group member.

Interested parties should create a new issue in the Project Update Working Group issue queue.

Applications are sought for both full and provisional members. Full members must have the ability to opt-in to security coverage for Drupal.org projects (sometimes referred to as the 'Git-vetted' role). Full members of the group must have a record of maintaining core or contributed projects. Please indicate which level of membership you are applying for in the issue.

Applicants must seek two endorsements from other community members. Endorsements must be made on the relevant issue in the Project Update Working Group issue queue.

The initial membership of the working group will be vetted by the Core Committer Team and Security Team. The vetting criteria for membership to the Project Update Working Group is based on an applicant's prior contributions to the Drupal community and their conduct in the community including issue queues, Slack chat, and at Drupal events.

With Drupal 11 fast approaching we hope to have the working group up and running in the coming months.

Applications will close at midnight UTC March 31st 2024.

Feb 28 2024
Feb 28

Drupal’s Layout Builder feature has established a critical content creation and display framework in the four years since its integration into Core. Replacing older, more complex tools like Panels and Display Suite, this integration marked a significant shift towards a more user-friendly, native layout-building experience. Better yet, unlike other JavaScript-based content layout tools, LayoutBuilder retains support for Drupal’s more powerful features like views, accessibility, and multilingual, to name just a few.

Despite its robustness, creating an excellent Layout Builder experience for your content editors typically requires several additional community modules. These modules add layout options, style customizations, granular permissions, content preview-ability, and, most importantly, fewer clicks to get the job done! You can see a list of Additional Modules for Layout Builder on Drupal.org. Knowing which ones to choose and how best to configure them is a challenge of its own. To help solve some of these friction-ridden experiences, Tag1 would like to formally introduce its new Layout Builder Plus Module, which dramatically helps improve Drupal’s content editor experience out of the box!

Layout Builder Plus by Tag1

Animated image walking through various features of the Layout Builder Plus module.  It shows the reduced number of steps to get blocks into regions onto the page, using the “promoted blocks” feature and changing column layouts

After working with several Fortune 500 clients to customize and build compelling site builder experiences using Layout Builder in Drupal Core, Tag1 has turned this work into a community module with the efforts of Tim Bozeman as the project’s lead developer and maintainer. You can watch a quick demo of the module in action here. Additionally, you can find instructions here if you would like to use this with the Umami demo.

Layout Builder Plus introduces a more intuitive user interface (UI), helping better show the content rendered on the page, adding default block icons, and the ability to drag and drop from a searchable block list, to name a few features. It also provides immediate visual reference and feedback for the content creator, reducing the typical five clicks to get a block into a layout down to just one drag-and-drop event!

Additionally, the new “Promoted Blocks” feature is crucial in streamlining content placement by making a curated list of commonly used blocks more readily available to just drop on the page. No more searching for that newsletter signup form block! Another critical aspect of Layout Builder Plus is the inclusion of the much-needed, sortable sections. This functionality allows users to easily organize and manage larger content sections, offering greater flexibility in content arrangement, whereas previously, this was a somewhat painful experience.

Layout Builder Plus also introduces the powerful Nested Layouts feature. This feature allows a content editor to place and organize blocks in a reusable, nested layout that can be moved around the parent layout, where you can duplicate and save it for placement on other pages with section_library! This feature alone will be a huge time saver for Site Builders managing lots of content pages moving forward.

[An animated graphic showcasing the Nested Layouts Feature of Layout Builder Plus in action]

Lastly, the block duplication feature in Layout Builder Plus again increases efficiency by allowing users to replicate blocks quickly with placeholder content. The module's cleaner user interface mirrors the published content, making the editing process more intuitive and user-friendly.

Tag1 is not done building Layout Builder Plus; we are just getting started and will continue to improve on the interface and add intuitive features in hopes that we make it as easy as possible for Site Builders to gain the most out of the Layout Builder experience in Drupal.

Benefits for Content Editors and Developers alike

At Tag1, we have a long history of driving innovation with Drupal and strongly believe in enhancing the platform for everyone to use by not building proprietary add-ons. We know that this makes Drupal great and drives the adoption of our favorite CMS.

Layout Builder Plus is a generous step in the right direction, and we welcome you to use and contribute to its development by reporting issues and identifying desired improvements or, even better, submitting a pull request! (Or two!)

Tag1 can help you build the best content editor experience possible

Drupal's Layout Builder has revolutionized content editing, and at Tag1, we're here to take it a step further. Our experts are ready to enhance your Drupal experience, blending our deep open-source knowledge with innovative solutions like Layout Builder Plus.

Ready for an outstanding content management system? Contact Tag1. Let's work together to craft a solution that's efficient, exceptional, and ideally suited to your unique needs.

Additional Links

Original artwork by Mariano Crivello generated using MidJourney

Feb 28 2024
Feb 28

3. Lullabot Podcast

If you're looking for a podcast that combines news, interviews, and tips about Drupal and Open Source, look no further than the Lullabot Podcast. Produced by the renowned team at Lullabot, this podcast brings you insights from industry experts and Drupal community members.

With a wide range of topics covered, including the latest developments, best practices, and real-world experiences, the Lullabot Podcast is a valuable resource for anyone interested in Drupal and Open Source technologies.

Listen on: Apple

Hosted by: Matt Kleve

4. Drupal Easy

For over a decade, the Drupal Easy Podcast has been providing a weekly review of new developments and announcements within the Drupal community. Led by a rotating group of experienced hosts, this podcast features discussions with notable Drupal community contributors, offering valuable insights and perspectives on various Drupal-related topics.

Whether you're a Drupal hobbyist or a seasoned professional, the Drupal Easy Podcast is sure to enlighten, inform, and sometimes even entertain you with its geeky obsessions and collective experience.

Listen on: Spotify | Apple

Hosted by: Andrew Riley | Anna Kalata | Kelley Curry | Michael Anello | Ryan Price | Ted Bowman

5. Tag1 Team Talks

From Tag1 Consulting, a global technology consulting firm, comes Tag1 Team Talks, a podcast that explores the implementation of open-source technologies. Hosted by Preston So, Michael Meyers, and other industry experts, this podcast delves into the business and technical aspects of various open-source technologies, including Drupal.

With a focus on trends and innovations in the open-source world, Tag1 Team Talks provides valuable insights for developers and technologists. If you're looking for in-depth conversations and expert perspectives, this podcast is a must-listen.

Listen on: Spotify | AppleYouTube

Hosted by: Preston So | Michael Meyers

Listen to theseDrupal podcasts to learn, get the latest news, and hear advice from well-known people in the community. No matter if you're a skilled Drupal developer or a beginner, these podcasts will keep you updated, motivated, and part of the lively Drupal community. Enjoy!

Feb 28 2024
Feb 28

Introduction

Data can lose its value and relevance without effective privacy and consent management. A recent report by Tableau revealed that 48% of consumers had discontinued their purchases or stopped using a service due to privacy concerns.

48%_buyers_stop_using_a_service_due_to_privacy_concerns

Organizations must prioritize consent and privacy management throughout their data ecosystem in today's data-driven world. By leveraging the capabilities of Salesforce Marketing Cloud Engagement, businesses gain access to a comprehensive suite of tools and data models that enable robust consent and privacy management.

Using Different Types Of Marketing Cloud Data Protection And Privacy Tools For Consent Management

Marketing Cloud provides access to several tools that can help create a data protection and compliance plan.

Consent Management Tools

Many data protection and privacy regulations require organizations to honor user requests about their data use. Customers can request that organizations restrict using their data for tracking and analytical processing.

These functions usually occur when deciding what content to deliver to what customer or using that data to predict future behavior. For example, customers might request that organizations not track their messaging and online behavior.

In this case, organizations can create a mechanism for receiving a Do Not Track request, which can suppress subscriber-level events like replies or clicks. 

Consent management tools help organizations obtain consent for all marketing activities and prevent tracking of contacts who request otherwise. Businesses need to take different actions to enable consent management in Salesforce applications.

Application

Action

Email Studio

Configure the Do Not Track attribute for your account. Set the attribute in Email Studio to either store or prevent storage of behavioral data based on subscriber preference.

MobilePush

Implement the latest version of the SDK for iOS and Android. Add the Do Not Track functionality to the app and prompt users to download the latest version.

Marketing Cloud captures the privacy and consent preferences stored on the app.

Personalization Builder

Prevent tracking and profiling in the app to stop Marketing Cloud from recording and storing behavioral data based on contact activities.

Social Studio

Social Studio does not utilize any cookies or other tracking technology for customers. The customer is responsible for managing necessary consents for cookies or tracking technology.

Consent can also be captured by using the Salesforce Consent Data Model. This data can be connected to Marketing Cloud to respect users' consent preferences.

Data Deletion

Data deletion tools help remove contact and other personal information from Marketing Cloud whenever requested.

Application

Action

Contact Builder

Use Contact Delete in Contact Builder to remove contact information from Marketing Cloud.

Personalization Builder

Use the Personalization Builder Privacy REST API to delete a contact’s customer profile.

Social Studio

Regarding Twitter, Facebook, and YouTube, individuals are responsible for deleting public data through their respective social media platforms. Social Studio receives updates from these social networks.

Data Portability

Data Portability tools help provide a copy of contact information to the contact who requests that action.

Application

Action

Automation Studio

Use data extracts to obtain the record based on the contact's ID value.

Personalization Builder

Contact your Marketing Cloud account representative for help.

Social Studio

Subject to specific limitations, it is possible to export managed account data from Social Studio either in the Analyze tab or by using cross-workplace reports. Individuals can also export their social media data directly from the relevant social network.

Restrict Data Processing

These tools help prevent the processing of contact data due to legal reasons.

Application

Action

Marketing Cloud REST API

Use the Contact Restriction REST API to restrict the processing of a contact record. This process prevents further Marketing Cloud activity or modifications of the contact.

Personalization Builder

Use the Personalization Builder Privacy REST API to restrict the processing of a contact’s profile.

Configuring Consent Preferences With The Consent Data Model

Organizations can implement simple and complex consent management practices based on their requirements with the Salesforce Consent Data Model.

What Is The Salesforce Consent Data Model

The Salesforce Consent Data Model is a standard model for managing consent at multiple levels, from global preferences to setting granular controls. This data model considers the user's entire experience.

Any records related to an individual can have related consent preferences within the model, including leads, users, person accounts, and contacts. It provides flexibility to choose the appropriate level of consent management and add levels of granularity as per the organization's needs.

Salesforce_Consent_data_model

The Four Levels Of Consent Management

In the Salesforce Consent Data Model, consent is managed on four levels, including:

Global Consent

Global consent controls all-or-nothing consent settings managed on the individual object. It captures if a customer has approved some communication. Some fields managed by this consent type are:

  • Block Geolocation Tracking: Preference to not track geolocation on mobile devices
  • Don’t Process: Preference to not process personal data
  • Don’t Profile: Preference to not process data for predicting personal attributes
  • Individual’s Age: Indication of whether the individual is a minor or not
  • Don’t Track: Preference to not track the customer’s web activity

For example, if a customer named Rachel Rodriguez gives consent to be contacted with a few conditions, her record will look like this:

Rachel_Rodriguez_Record

Engagement Channel Consent

The Engagement Channel consent is managed on the Contact Point Type Consent object. Organizations can use Contact Point Type Consent records to enter consent preferences of contact types, including email or phone.

For example, Rachel Rodriguez's individual record will be similar to the image below if she decides an organization can email her but not call her.

Contact_Point_Promotional_Email

Contact Point Consent

Whether a customer wants to be contacted is managed through the Contact Point Consent object. It helps set consent at specific contact points. For example, the record will store Rachel Rodriguez's preference to be contacted at her work email address but not her personal email.

Promotional_Email_Brand_Two

Data Use Purpose

The Data Use Purpose object captures consent based on the reason for a communication, including:

  • Legal issues like recall notices
  • Marketing purposes like weekly newsletters
  • Service like warranty support

This is displayed in the data use purpose records. For example, a user can only receive communication for new product updates.

Data_Use_Promotional_Emails

How To Configure Salesforce Consent Data Model In Marketing Cloud

Follow the steps below to configure the Salesforce Consent Data Model to manage consent preferences in Salesforce Marketing Cloud Engagement.

Step 1: Connect Consent Data To Marketing Cloud

Use Marketing Cloud Connect to synchronize consent-related objects to Marketing Cloud in the following order.

  • Contact and User
  • Business Brand, Data Use Purpose, and Individual
  • Contact Point Email, Contact Point Phone, and Contact Point Address
  • Contact Point Consent and Contact Point Type Consent

Connecting_Consent_Data_To_Marketing_Cloud

The synchronized data will appear in the local Synchronized Data Extension folder.

Subscribers_Data_Extensions

Step 2: Connect Consent Data To Subscribers In The Marketing Cloud

Using Brand as a filter, create a query that joins the subscriber’s contact ID with contact point consent records. For example:

Select c.Id, c.Email, cp.EmailAddress, cpc.Name, cpc.PrivacyConsentStatus
From Contact_Salesforce c
Join Individual_Salesforce i On c.IndividualId = i.Id
Join ContactPointEmail_Salesforce cp On i.Id = cp.ParentId
Join ContactPointConsent_Salesforce cpc On cp.Id =
cpc.ContactPointId

After creating the query, determine how to make the information available according to your business requirements. For example, organizations can update or create an automation in Automation Studio and run these queries on a schedule.

Organizations can also write query results to a data extension in a shared folder for the required business units. If required, one can write additional queries or parameters that include the Data Use Purpose record.

Step 3: Retrieve Changes To Subscriber Status In Marketing Cloud

This step is only required to account for native changes in the Marketing Cloud feedback loop and reply mail management processes.

Start by identifying related consent objects in the core and update privacy preferences. The specific consent objects affected depend on how the unsubscribe was received and how the customer manages consent. For example, if a customer only manages consent by contact point type consent, that is the only object impacted.

Use ReasonUnsub to determine the consent object impacted. The default values are:

  • Spam Complaint
  • Unsubscribed from list details on subscriber properties dialog
  • Unsubscribed by ExactTarget RMM service based on subscriber Leave or Reply email
  • Unsubscribed from the Subscription Center
  • Unsubscribed via Import
  • Unsubscribed by Salesforce Marketing Cloud RMM service based on subscriber Leave or Reply email
  • Unsubscribed by subscriber edit API call

Create an invocable action that executes the API to retrieve the Subscriber Status Event. Use complex filter parts and include the date since the last batch execution. For example:


   
      CurrentStatus
      equals
      Unsubscribed
   
   AND
   
      CreatedDate
      greaterThan
      2011-04-07T19:58:33.434707Z
   

To filter on a specific ReasonUnsub value, change the filter to use a different Simple Operator. For example:


   
      ReasonUnsub
      like
      Unsubscribed
   
   AND
   
      CreatedDate
      greaterThan
      2022-01-01T19:58:33.434707Z
   

Use an API call to create a schedule-triggered flow to retrieve unsubscribe events from Marketing Cloud for the last 24 hours.

  • Pick a date and time for the first run of the flow
  • Schedule the flow to run daily

To review all subscribers with an unsubscribed status in the list, create a scheduled-triggered flow to perform weekly refreshes. An invocable action can be used to perform the work of both executions. For example:


   
      CurrentStatus
      equals
      Held
   
   AND
   
      CreatedDate
      between
      2009-01-01T19:58:33.434707Z
      2010-04-07T19:58:33.434707Z
   

Conclusion

It's essential to tailor your consent management strategies to your target audience's specific needs and legal requirements. If you still need help or want to learn more, our experts at Axelerant can help.

We can ensure that your marketing practices align with the applicable regulations and respect the privacy rights of your customers.

Feb 26 2024
Feb 26

Today we are talking about Drupal 7 Long Term Support, common security tips, and support services you can use with guests Greg Knaddison, Aaron Frost, and Dave Welch . We’ll also cover Storybook as our module of the week.

For show notes visit:
www.talkingDrupal.com/439

Topics

  • Drupal 7 EoL
  • Drupal will not stop working
  • Security team perspective
  • Security concerns
  • Extened Community Support
  • Long Term support
  • HeroDevs
  • Never ending support (NES)
    • PHP
    • Hosting
    • Security
    • Contrib
  • Product advisor
  • Colorado Digital Service

Resources

Guests

Greg Knaddison - morrisanimalfoundation.org greggles
Aaron Frost - herodevs.com aaronfrost
Dave Welch - herodevs.com dwelch2344

Hosts

Nic Laflin - nLighteneddevelopment.com nicxvan
John Picozzi - epam.com johnpicozzi
Ivan Stegic - ten7.com ivanstegic

MOTW

Correspondent

Mark Casias - markie

  • Module name/project name:
  • Brief description:
    • The storybook module makes it easier to create a connection between Drupal and Storybook. It adds some Twig functionality so you can write Stories in Twig as opposed to YML or JSON or React
  • Brief history
    • How old: Less than a year
    • Versions available: Alpha4 came out earlier this month
  • Maintainership
    • Actively maintained: Yes
    • Number of open issues: 6
    • Test coverage: no
  • Usage stats:
    • N/A: for development only
    • Maintainer(s):
    • Mateu Aguiló Bosch (e0ipso) from Lullabot.
    • Module features and usage
    • Twig based stories
    • Pulls in Sites theme and base css.
    • So needs some updates to the development.services.yml
    • Also means it is hard to publish a storybook.
    • No need for SDC (but works well with it)
    • Great instructions on the module page
    • Way easier than previous integrations including cl_server.
    • Not as opinionated as previous storybook integrations.
Feb 26 2024
Feb 26

In my previous article I outlined that I really needed to get Drupal 10 sites running in Aegir 3. I had no time to wait around for other solutions, and I was going to try to decouple Aegir from running Drupal sites, so that it wouldn't be tied to Drupal versions.

Since writing that article and actually sitting down to do this work, I realised that it's quite an undertaking, and the approach outlined by Omega8cc in various github issues was worth a second look.

It works!

But it's wild. It comprises three main things:

  1. A custom/forked version of Drush 8.
  2. A custom/forked version of Provision 3.
  3. A custom/forked version of Drupal 10.
  4. (A sneaky fourth is that you absolutely do not want to have site-local Drush)

So...yeah...it's not going to be for the faint-hearted, but I'm going to detail out those three things a little, and how you might want to apply them to your situation.

Custom Drush 8

So the official Drush 8 doesn't support Drupal 10. But, it's actually not that much work to get this up and running, since Drush has pluggable 'engines' that load code based on the Drupal version that's detected when running commands.

Omega8cc has done a great job of doing the leg-work and providing a forked version of Drush, you can see the changes that have been made to support Drupal 10 here:
 

https://github.com/omega8cc/drush/compare/8.4.12...8-boa-micro

Although note, that there are some Aegir specific and non Drush 10 supporting changes in there too, so what I did was to make my own (private) fork of Drush and go through and apply the relevant changes to the files. If you don't know what the relevant changes are, then you probably are better off simply replacing your Drush with the Omega8cc fork, and it'll probably be fine.

Essentially this step is needed so that Drush sees the Drupal 10 codebase, and can interact with it correctly. It's likely that in Drupal 10's lifetime something will change, and Drush 8 will need some more work to be compatible with 10.3 and 10.4 etc.

If you were to run Drush 8 commands at this point, they'd start to bootstrap the site, but would fail with fatal errors. You need changes in Drupal 10 core too...

Custom Provision 3

Provision also makes use of Drush engines to load the correct code for the correct situation, so that if you ask Aegir to install a new site on a platform it'll load up the correct bit of code for the relevant Drupal version.

Again Omega8cc has done all the hard work here and provided the changes you need, but they are a bit harder to pick out of the repo. Try searching for files that contain '_10':

https://github.com/omega8cc/provision

And that should get you the files you need. I will note that unlike the Drush fork above, this really is a heavy fork. You are getting a lot more besides Drupal 10 support, if you can, I'd go for patching this into your existing Provision codebase.

I could add these to official provision 3 on Drupal.org, but without the other pieces they are useless and won't help you. Aegir 3 is essentially unmaintained, so while I've committed some PHP 8 fixes in the last few weeks, I'm not going to commit huge things like this.
I suppose we could have some code maintained in an issue fork or a patch.

This step is need so that Provision will call the correct bits of code at the right time, as far as I can see, these are largely the same as Drupal 9 versions of the engines.

Custom Drupal 10

Now for the big compromise.

The main problem here is that Drupal 10 uses Symfony 6, which has type hints on various interfaces and methods, and Drush 8 uses Symfony 2, which does not.

So, if you load one before the other, then as soon as PHP tries to load the second, it'll die because either the types are there, or they aren't.

This is a bit of a showstopper and there's no decent way to get it to work nicely. Instead, Omega8cc has discovered some band-aids you can slap on and while it'll work, it's brittle!

Omega8cc's fork of Provision automatically tries to apply some of these patches to Drupal 10 platforms, and gives you a nice way to add/remove them. But again, also has a lot of other opinionated changes (to provision), so if you want to know what to do to Drupal 10 core...keep reading:

We need to:

  1. Remove a bunch of typehints from Drupal core's logging mechanisms.
  2. Downgrade psr/log
  3. Patch symfony/console

Removing the typehints

Omega8cc have got a nice patch that does this:

https://raw.githubusercontent.com/omega8cc/boa/5.x-dev/aegir/patches/drupal-ten-aegir-01.patch

And you can apply that using composer patches if you want.

Note that if you have any classes that extend these patched classes, they'll need patching too, so if you have any custom or contrib loggers, you'll need to go sort those out.

Downgrading psr/log

Composer makes this one super easy:

composer require 'psr/log:1.1.4 as 3.0.0'

Will do what you want. It's the companion to the first step, those classes implement these interfaces, so they need to get downgraded too. This might need to get adjusted if Drupal 10 core requires psr/log 3.1.0 or something like that, but the principles should still work.

If your Drupal 10 codebase isn't managed by Composer...well...getta out here and get that sorted first.

Patching symfony/console

Drush 8 only uses part of this package, so we can get away with patching just a tiny bit of it. Essentially you want to remove the 'Input' directory within the package. If you have a build system you could delete the files as part of your build process. Omega8cc's approach is to make the directory essentially unreadable.

Either way the result is that when PHP tries to load some code that uses version 6 of Symfony\console\Input it'll fail to find the code in Drupal core, and instead fallback to the version that came with Drush 8. Luckily this code isn't used by Drupal core, but you'll need to check that your custom and contrib code doesn't use it either, or handles the case when it magically loads code from Symfony 2.

For me and my codebase this was fine. None of our custom or contrib code used the classes or interfaces, so all good.

That's it

For Drupal 10 support in Aegir, that should be it. You can run Aegir 3 in PHP 8.1 and Drupal 7 and Drupal 10 on the same box. Magic.

Make sure you don't have a site-local Drush in your composer require, otherwise, Drush 8 being the great tool that it is will find it, and pass execution over to it, but it's not the same Drush that Aegir has all it's claws/hooks in, so things will go badly quite quickly.

Gotchas

Probably many, we've not actually rolled this out into our production environment yet, but we're close.

The main thing I can think of is that Drupal 10 contrib modules are very much going to assume that there's a modern version of Drush running commands, and not Drush 8, so it's likely that they aren't going to provide Drush 8 commands. You might need to write your own shims that copy/paste large lumps of code, or call through the new style Drush commandfiles, but that means that Drush command hooks won't be working quite right etc.

So yeah, danger if you're doing anything interesting using Drush commands on your sites.

Oh, and I guess it's possible that this will all break hard in the Drupal 10 lifecycle. I mean, it probably won't because it'll always be a foundation of Symfony 6, but you never know, the Drop is always moving and all that.

Thanks to Omega8cc

This was all shown to be possible, and documented in code by the great team at Omega8cc, so thanks very much for the work they are doing. I have nothing against there heavy forks of Aegir, they just aren't for me, hence why I've tried to pull out just the bits you need into this post.

Future

I still think that Aegir 3 could be decoupled from hosting Drupal sites. So that it was hosting 'sites' and then one could have some well-defined way to interact with those sites via some command line tool depending on what they were. However, that's a big effort, and Aegir 3 is essentially unmaintained now, so that's not going to happen. 

A number of others in the #aegir Drupal.org Slack channel have mentioned other alternatives, such as Aegir 5, or getting Drush 12 running Provision commands and running everything with Drush 12 instead of Drush 8, or using some other tool as the outer runner.
I think they are all going to run into the same issues/have to deal with the same thing: abstracting the notion of the 'site'. Provision 3 takes a number of shortcuts to make it really easy to pass data around between itself and the site, and those shortcuts simply aren't possible in Modern Drupal.

However, in case there's someone out there with a big ol' budget, and a desire to keep Aegir 3 going, I think the 'decoupled' Aegir would look something like:

  • A provision where the places that it calls through to functions executed in the Drupal context abstracted out into some kind of site specific 'plugin'. Instead of trying to use the nice Drush functions for calling a 'inner' Drush command, instead the usual command line interface would be used and data simply encoded on stdin/stdout/stderr in a format not tightly coupled to Drush 8 or Drush 12/13 etc.
  • Provision calls into the Drupal site a lot and because it's never needed to be explicit about doing it, it's sometimes hard to spot where this is happening.
  • Some kind of shim package that can be composer required into sites hosted on Aegir that would provide some way for the Provision plugins to call into the Drupal site and get the response it needs. Maybe this would merely provide some Drush commands.

Good luck if anyone ever embarks on such a project! Or contact us if you want a shoulder to cry on to hire us for a project!

Feb 26 2024
Feb 26

The rule of thumb is straightforward — the faster, the better. The speed of carousel sliders in Drupal has a huge impact on how users interact with your content. If adjusted correctly, it will surely drive your platform to the top of SERPs. 
Drupal carousel slider optimization, among other design elements, helps you entice your audience to stay on your site and speeds it up. Customers quickly abandon pages if they don’t satisfy their needs. As research shows, 7% and 11% drops in conversions and pageviews, respectfully, can happen because of a one-second lag between page loads.
In practice, Drupal website owners have a top-notch tool stack to work on the platform’s performance without switching between the apps and content management systems. You can effectively optimize carousel sliders in Drupal and boost your site’s operation. Stay tuned to find out more!

Understanding the Role of Carousel Sliders

Prospective website visitors expect the target platform to be fully responsive, intuitive, and interactive. That’s where Drupal carousel sliders come in:

  • This term defines a coded slideshow to cycle between various pieces of content. This combination of CSS and JavaScript results in 3D graphics for displaying text and pictures. It also works with unique markups and helps get your on-site controls connected smoothly.
  • Working on Drupal carousel slider optimization will lead to drastic improvements in your content cohesion and efficiency, as well as the overall page functionality.

The wrong way to advance your page with carousels will be if you neglect their load on the site’s architecture and productivity. Don’t hesitate to stick to Google’s guidelines to make things more manageable and comprehensible. They will help you make the range of page loading speeds measurable and define what parameters to reach for a good end-user experience:
According to the Core Web Vitals, for instance, the first input on the screen should appear in less than one hundred milliseconds. 
With PageSpeed Insights, you can analyze your site’s speed of operation, and whether its LCP, CLS, or FID leaves room for improvement.

Common Challenges in Carousel Slider Performance

Without a doubt, carousels in web design have several strengths — from driving sales to improving your site’s aesthetics, i.e. displaying lots of content in a compact manner. However, if you don’t optimize the carousel in Drupal, you will have to face the consequences below:

  • First and foremost, the speed of loading will suffer. Users won’t think twice before bouncing off the page if it takes ages for it to load. Given that they commonly include large and heavy-weight pieces of content, the website has to be ready for the challenge.
  • In turn, slow-loading pages will decrease your on-site organic traffic and, therefore, conversions.
  • If your website is overwhelmed with carousels, it becomes difficult to navigate. What’s more, if they are poorly designed and customized, they will seem distracting and irritating to end users.

Selecting the Right Drupal Carousel Module

A carousel’s primary objective is to show a certain call to action while enabling users to navigate through your offers and different types of content smoothly and flawlessly. To get started with creating carousel sliders in Drupal, you can choose one of the following paths:

With the Bootstrap Modal Carousel, you identify the target image gallery and command the site to display its destination pictures automatically. Its trigger mechanism is a mouse click.

Another module to pay attention to is Slick Carousel. It is a great solution to achieve a sleek and enhanced view on your platform, with several complex content layouts included.

6 Ways to Optimize Carousel Sliders in Drupal for Faster Page Loading

Boosting your Drupal site’s efficiency involves several processes. There are several possible technical adjustments and module settings to activate to ensure the dynamics of your carousel sliders don’t potentially destroy your system’s visibility, attraction, and profitability. Keep on reading to get acquainted with functional tools to guarantee end-user satisfaction from their interaction with your web pages.

1. Image Optimization for Carousel Sliders

Large files will slow down your on-site performance. That’s why compressing and resizing pictures of any format is a good idea to make the first step to enhancing your page’s loading speed. Here are a few things you can do:

  • Flex Slider is a multi-functional module that will assist in creating resizable and responsible pieces of content from scratch. These slideshows don’t minimize your power in setting your custom navigation solutions or unique design elements.
  • With the Image Compression module in your tool kit, you can reset the value of your files on the site.
     

2. Minimizing JavaScript and CSS for Performance 

Drupal heavily depends on CSS and JavaScript files and codes, which are used for rendering website pages. Minifying those scripts will improve your platform's operation for sure. In a nutshell, minimization processes are aimed at getting rid of all extra signs and characters from coded files without failing their efficiency. Since browsers, unlike humans, don't require semicolons and whitespace to read the code, such elements can be easily removed.
In Drupal, you can achieve the same effect by aggregating these files. You can activate the distinguished feature in the settings in your administration dashboard. By reducing the size of crucial technical files on your site, you speed it up a lot.
 

3. Lazy Loading for Improved Performance

This method involves delaying the loading process of some webpage elements, particularly graphics until the target user requests them. Contrary to the traditional approach of loading all the content simultaneously, the presented technique commands the browser to avoid loading the on-site resources a visitor doesn’t request. Your target audience will easily access what they need without delays, which will positively influence the general usability of the site. You can customize this feature and its effects in the Lazy-load module.
 

4. Effective Caching Strategies

There are lots of tools to switch the caching mode on. For instance, the Drupal Cache APIs will assist in implementing this function in your site’s custom codes. Diving deeper into the realm of Drupal caching can elaborate your case studies of Drupal slider optimization and reduce the number and complexity of computation steps to take for the desired result:

  • You can speed up cache flushing in the Devel module.
  • Cache Warmer enables micro caching and provides access to the latest on-site pages based on their content freshness.

Caching isn’t a by-default feature in Drupal. Without a web server, database, page, and other formats of caching in the system, your website won’t operate fast and smoothly. Otherwise, to access JavaScript files, images, and other data on the page, separate requests are to be made by a user’s browser for every asset.
 

5. Mobile Optimization and Responsive Design

Google likes mobile-friendly pages, which can help you gain an important competitive advantage over your competitors in the market. With modules like Front-end Performance and Responsive Images, the process of establishing a responsive design for carousel sliders will become more productive and flexible. This is how you optimize carousel sliders in Drupal in a more wholesome and well-thought-out manner.
 

6. Performance Monitoring and Testing

Thanks to Mobile Testing Tools in Drupal, interested parties can effortlessly obtain in-depth and actionable insights to measure their platform’s performance and improve it. The list of modules to add to your stack is impressive, and check whether your effort pays off. It includes such robust solutions as Performance Monitor and Website Speed Monitoring. These features will come in handy whether your efforts to optimize carousel sliders in Drupal are fruitful.

Conclusion

With Drupal website optimization strategies highlighted in this guide, you can boost its performance from both short-term and long-term perspectives. Not only will you succeed in increasing user engagement and conversions, but you will also take your brand’s awareness and credibility to the next level. 
In the long run, faster loading is a cost-saving tactic for website owners as well, simplifying error detection and troubleshooting. By optimizing carousel sliders in Drupal, it is as easy as ABC to gain a competitive advantage over rival businesses in the niche and take the most out of it. 

Feb 26 2024
Feb 26

As experienced sponsors, we have well-tried tips for enjoying the Sprint and maximising your impact on the Drupal community. Find out how to get involved, why contribution is important and how on-the-day collaboration works.

We’re back! Once again, we're running and sponsoring the Code Sprint, this time at DrupalSouth in Sydney. 

Whether you join us in person or virtually, it's a day where we collaborate to work, learn and contribute to the Drupal open-source project and community.

Getting together this way creates new ideas and initiatives, pushing the boundaries of what is possible. Plus, we get to have fun doing it!

When is the Code Sprint?

For full information, check out the DrupalSouth registration form.

How do I get involved?

Registering for the Code Sprint is seamlessly integrated into the DrupalSouth registration process

Attendance is free, and participants of all experience levels are welcome.

Due to its popularity, we advise you to register early and secure your spot!

Participate remotely

Can't be there in person? You won't have to miss out!

Join us virtually through Slack and Zoom to contribute from anywhere worldwide.

Details for connecting remotely will be shared via Slack closer to the event date.

Tell me more about Sprints and why they matter

Drupal is an open-source project reliant on community contributions (from organisations and individuals) to keep it moving forward and improving. 

The Sprint is a focused day of progress, where we achieve tangible results, expertise is recognised and acknowledged, and developers can mentor one another.

Your participation in the Sprint helps to build your contribution levels for the Certified Partner Program

Whether you're a seasoned contributor or new to Drupal Sprints, these recorded sessions from previous events will help you prepare:

Sprints are about more than coding; they're opportunities to connect, discuss common interests, put forward ideas and collaborate on various topics.

Groups will mostly be arranged by topic. e.g. Bug Smash, Media, Drupal 10 porting. Look for a group working on something that interests you, and join in! 

There's no pressure to complete lines and lines of code on the day. We want this to be a positive experience for everyone.

Communication 

Communication during the Sprint will primarily occur through #drupalsouth-code-sprint in Drupal Slack, with dedicated threads for streamlined discussions.

Follow the instructions for how to join the Australian / New Zealand Drupal community in Slack. 

Can anyone contribute?

Everyone is welcome to contribute on Sprint Day, regardless of technical background. Contribution can take many forms, from coding to issue triaging.

Check out the contributor tasks to discover the ways you can get involved. 

Issue Queue

The Drupal.org Issue Queue has issues tagged with 'DrupalSouth' by other contributors. This is where you can also tag issues to add.

Development environment setup

When it comes to setting up a local development environment for working on Drupal, you have options.

For local development environment setup, our pick is Docker Compose. Follow the instructions for installing Docker Compose on OSX, Windows and Linux.

If you don't already have a local development environment for Drupal contribution, you can set up a starter project using this:

composer create-project mstrelan/drupal-contrib

See the README.md for more details. 

If you're more familiar with DDEV, we recommend you look at DDEV Drupal Contrib.

If you experience any issues, join us on Slack beforehand, and we'll happily answer your questions.

Code of conduct

The Sprint Day adheres to the DrupalSouth Code of Conduct, fostering a safe and inclusive environment for all participants. 

Summary

To make the most of the Code Sprint:

We can’t wait to see you there!

Feb 25 2024
Feb 25

Mercè is coming to Drupal Mountain Camp!

Get ready for an exciting opportunity at this year's Drupal Mountain Camp in Davos, Switzerland! Last year, Lille's mascot Lil´Rooster travelled across the local camps and events to meet and greet participants and representatives. You can watch his journey here.

We're thrilled to announce that Mercè, the mascot of DrupalCon Barcelona 2024 and the charming salamander, will be joining us at Drupal Mountain Camp. Named after the traditional festival La Mercè, which coincides with DrupalCon Barcelona, Mercè embodies the vibrant energy and cultural richness of Barcelona and brings a touch of festive spirit to our Drupal community.

How to Win a Free Ticket to DrupalCon Barcelona 2024:

  1. Spot Mercè at Drupal Mountain Camp in Davos, Switzerland.

  2. Share the photo on your X and/or on your Instagram and/or your LinkedIn account and make sure you tag @DrupalConEur in it with the hashtag #DrupalConBarcelona 

  3. The Most Liked Photo Wins.

Note: It is important to tag the account and include the hashtag, if only one of the two is added then this will not be counted towards the competition.

Drupalcon Barcelona Win a free ticket
Feb 23 2024
Feb 23

As excitement mounts for Drupal Mountain Camp 2024, we are delighted to introduce an outstanding roster of keynote speakers who will bring their expertise and insights to the event. This year, Tech enthusiasts worldwide will have a special chance to interact with industry visionary leaders as we proudly reveal our distinguished keynote speakers: Tearyne D. Almendariz, Jutta Horstmann and Preston So.

Tearyne D. Almendariz: Empowering DevOps Teams and their advocates, one deck at a time.

Session: Magic Comes from Pain: 4 Ways that Embracing Grit Will Help you Achieve the Impossible 

Date: Sat 09-03-2024 09:30

Tearyne D. Almendariz

Tearyne is an interdisciplinary-trained frontend web developer, dedicating her craft to the development of accessible, interactive experiences that deliver a company's brand message. 

Tearyne is an avid volunteer in the DFW Tech and Engineering scene, having served for nearly four years with Black Girls Code as a Tech Assistant and as a CORE Team Lead of the Dallas CORE team. She currently serves on the board of the Texas Organizing Project.

Her background includes user experience and user interface design and development, web consulting for small businesses, and intercultural communication. Specialities include accessibility, user experience research, and usability principles.

Jutta Horstmann: Ex-Managing Director (COO, CTO) at eyeo, former IT Consultant, Open Source Expert, Software Engineer, CEO / Founder Data in Transit GmbH

Session: Running the internet, under-funded and under-staffed? How to achieve a sustainable open source ecosystem 

Date: Fri 08-03-2024 09:30

Jutta Horstmann

Entrepreneur, founder, leader, sparring partner and mentor - scaling organizations, driving change, nurturing culture. Feminist sustainability and free software advocate.

25 years of experience in the IT sector: After holding various engineering roles, Jutta founded her own software development & consulting company, Data in Transit in 2006 and grew it successfully over a decade.
Later, 5 years at eyeo saw her in various roles, including COO, CTO and Managing Director. She led the company until the end of 2022, scaling it from 100 to 250 employees. 

Currently, Jutta is taking some time off to unwind and recharge. She is considering writing a book about her learnings and appreciates feedback on that plan.

Preston So: Senior Product Management and Developer Relations Leader

Session: Universal CMS and the end of "pure" headless 

Date: Fri 08-03-2024 13:00

Preston So

Senior product, developer relations, and engineering leader with 20 years in software technology and 8 years of experience leading product, design, engineering, and developer relations functions. Previously leader of product, design, engineering, and developer relations functions at organizations such as Oracle, Acquia, Time Inc., and Gatsby. 

Author of Immersive Content and Usability (A Book Apart, 2023), Gatsby: The Definitive Guide (O'Reilly, 2021), Voice Content and Usability (A Book Apart, 2021), and Decoupled Drupal in Practice (Apress, 2018). Editor at A List Apart and former columnist at CMSWire. Named "probably the smartest person working in this industry right now" by Web Content Management author Deane Barker in 2020 and a top influencer in Onalytica's "Who's Who in Digital Experience" in 2021.

In Conclusion

The keynote speakers – Preston So, Tearyne D. Almendariz, and Jutta Horstmann – bring a diverse range of expertise, each contributing a unique perspective to the broader conversation around Drupal and the future of web development. Be prepared to be inspired, informed, and engaged as we embark on this exciting journey together at Drupal Mountain Camp 2024. Get ready to explore the peaks of possibility and the depths of innovation in the world of Drupal!

Feb 22 2024
Feb 22

Join us on 7 - 10 March 2024 at Drupal Mountain Camp if you are interested in learning about the system that is the platform for many governments, organizations and universities worldwide.

Mountain Camp Keynote session with 4 panelists in the front that have a discussion in front of a slido.com Screen. In the foreground participants that listen to the discussionPicture from the keynote at Drupal Mountain Camp 2019

After the summer edition in 2022, the Drupal Switzerland community invites to another gathering in Davos full of workshops, contributions, sessions and winter fun.

Liip is proud to present to present on a variety of topics:

Mountain Camp Conference Room. A person with a muslim hat looking at the screen in the front and many other participants in a conference room. You can see a person with a video camera recording the front rowPicture from the conference room at Drupal Mountain Camp 2019

I'm particularly excited about the line-up of keynote speakers:

A cheerful-looking woman sledges down at night-lit slope. Another person sledding in the backround with a running dog next to itA typical post-conference social activity, sledding down the Swiss alps in Davos

Thanks to sponsors like Platform.sh, dropsolid, Acquia, soul.media, Unic, Happy Coding, MD Systems, Joinbox, Tag1 Consulting and Liip, the 4-day conference is brought to you at a comparably low price, with tickets available for CHF 100 per ticket.

Drupal Mountain Camp wouldn’t be possible without a team of dedicated volunteers.

Do you want to learn more about Drupal? Do you want to connect with others who are passionate about open-source software solutions and the open web? Do you have a Drupal story to tell? See you at Drupal Mountain Camp 2024!

Feb 22 2024
Feb 22

Changes in the digital world are inevitable and necessary. For Drupal users and developers, one of the key moments is migrating the system to its latest version. In this blog post, I focus specifically on the process of upgrading to Drupal 10, taking you step-by-step through how to prepare for it, what to check, and what actions to take to make the transition as smooth and seamless as possible.

Why Drupal 10?

The new version of Drupal was officially released on December 14, 2022, marking an essential step in the continued development of this content management system.

Upgrading to Drupal 10 is a matter of accessing new features and improvements and an important aspect of your website's security and stability. Support for Drupal 9 ended on November 1, 2023, making an upgrade not only recommended but, in some cases, necessary.

Differences between Drupal 9 and Drupal 10

Drupal 10 brings several improvements aimed at making work easier and improving security. Instead, it doesn’t introduce a complete change in the system's structure so that the transition from the previous versions doesn’t force the user to adapt to an entirely new environment.

Here are some fundamental changes compared to the previous version of the system:

  • Olivero - new default frontend theme: Olivero replaces Bartik as the main frontend theme, introducing a fresh and modern design.
  • Claro - a new default administrative theme: Claro replaces Seven, offering a more transparent administrative interface that is designed for efficiency and convenience of use.
  • Partial replacement of jQuery by JavaScript: this change reflects a trend in web development, where JavaScript is steadily displacing jQuery due to its performance and flexibility.
  • CKEditor upgrade to version 5: The latest version of CKEditor has been completely rewritten. It offers great possibilities for expansion and integration with modern technologies.
  • Removed support for PHP below version 8.1: Drupal 10 requires PHP version 8.1 or higher.
  • Symfony version 6.2: Unlike its predecessor, which supported this framework as early as version 4, Drupal's latest release requires Symfony version 6.2. This is a major step in improving the security and optimization of websites based on this content management system.

Removed modules and themes

Another significant change in the latest version of Drupal is the removal of some themes and modules that already had a "deprecated" status in Drupal 9. They are still available as contributed modules but are developed separately and aren’t part of Drupal core. Below is a list of them:

Deleted modulesRemoved themesAggregatorSevenCKEditor (version 4)BartikColorClassyHALStableQuick Edit RDF 


Required PHP and database versions

Drupal 10 has specific system requirements that you must meet to ensure the smooth operation of the platform. In addition to PHP version 8.1 or higher (8.1.6 is recommended as a minimum), you also need to make sure you have the correct database version. I present a list of compatible versions below:

DatabaseVersionsRequired extensionsMariaDB10.3.7 and higherPDOMySQL/Percona5.7.8 and higherPDOPostgreSQL12 and abovepg_trgmSQLite3.26 and abovejson1


Microsoft SQL Server and MongoDB are also supported through separate contributed modules.

Preparing for a Drupal upgrade

I recommend creating a website and database backup before proceeding with the upgrade. This will allow you to quickly restore your web page in case of any problems. Also, ensure that your hosting supports the PHP and database versions required by Drupal 10, as I wrote above.

Migration from Drupal 8

In November 2021, support for Drupal 8 ended, resulting in no further security updates and technical support for this version. So, it's worth thinking about migrating to a newer system.

For Drupal 8 users planning to migrate to Drupal 10, an initial upgrade to version 9 is necessary. This is an essential step in the migration process, allowing a smooth adaptation to the latest standards and features "ten" offers. Once this first phase of the upgrade is complete, you can proceed to the next steps. For more information and tips on upgrading your system from Drupal 8 to 9, check out our article on how to properly take care of a Drupal upgrade.

Migration from Drupal 9 to 10

If you’re upgrading from Drupal 9 to 10, you should be prepared for the whole process to consist of many steps. I describe each of them below to make it easier for you to perform the migration yourself.

1. Upgrade PHP to version 8.1

If you don't already have this version or higher, you need to proceed with the upgrade. Before starting it, check that all modules and themes on your website are compatible with the newer PHP version. Useful tools for this process are PHP Codesniffer and PHP Compatibility.

2. Upgrade Drupal 9 to the latest version

The next step is to upgrade Drupal 9 to a minimum version of 9.4.4 (however, the latest version, 9.5.11, is recommended). To do this, you can use the following commands: 

composer update "drupal/core-*" --with-all-dependencies
drush cr -y
updb
drush cex -y


3. Uninstall themes with "deprecated" status

The Classy, Bartik, Stable, and Seven themes have been removed in the latest version of Drupal. So before upgrading, uninstall them from /admin/appearance. However, if you have any themes based on the above, you can install their contributed versions using the following commands:

composer require drupal/seven 
composer require drupal/classy 
composer require drupal/bartik
composer require drupal/stable


4. Migration to CKEditor 5

Migrating the editor to CKEditor 5 is a process that can be more complicated than a standard upgrade, mainly because CKEditor 5 was written from scratch. The new architecture brings many advanced features and improvements. However, due to a complete code rewrite, not all plugins available in CKEditor 4 will be directly compatible with the new version.

Before migration, it’s important to carefully check the compatibility and availability of the plugins you’re using and possibly rewrite them for the latest version of the editor. You can read more about this in the CKEditor documentation

If all plugins are compatible, you can proceed to the following steps:

  • First, go to /admin/modules and install the CKEditor 5 module.
  • Then go to /admin/config/content/formats and click the "Configure" button next to each format you want to change the editor.
 In the Drupal admin panel, you can configure the CKEditor 5 editor for the plugins you use.
  • Change the editor in the box marked with a red arrow below and click "Save" at the bottom of the page. Proceed in this way for each format that needs changing.
Before migrating your system to Drupal 10, you need to set up the CKEditor for each plugin you use.
  • In the last step, go to /admin/modules/uninstall and remove the CKEditor module.

5. Update modules using Drupal Upgrade Status

Before starting the upgrade, installing the Drupal Upgrade Status module is also recommended. The main task of this tool is to analyze the compatibility of currently installed modules and themes with the standards of the new system version. This allows users to quickly identify elements that need to be upgraded or modified before carrying out the migration process.

The first step is to install and enable the module: 

composer require drupal/upgrade_status 
drush en upgrade_status 

Then go to /admin/reports/upgrade-status, select the modules to check, and click the "Scan selected" button. 

The Drupal Upgrade Status module allows you to scan your system for incompatible modules.

After the scanning process is complete, you’ll receive feedback with a list of modules incompatible with Drupal 10.

In my case, there is a problem with the Custom module. As you can see in the image below, the Drupal Upgrade Status module itself suggests a solution to the problem. In this case, it’s an error related to the core version in the info.yml file. I corrected the errors in the code and scanned it again - I recommend the same to you.

Example of Custom module problem with Drupal 10 detected by Drupal Upgrade Module.


Resolve compatibility problems until the bar in the upper right corner indicates 100%.

Scanning the website with the Drupal Upgrade Module allows you to detect errors before upgrading.


For your custom modules, you can easily make changes to the code yourself. Most often, contributed modules need to be upgraded to the latest versions supporting Drupal 10.

Things get complicated when the module you’re using doesn’t yet support Drupal 10. There are several solutions to this problem. One of them is a plugin for Composer that allows you to install modules that aren’t yet compatible with Drupal 10. Below, I suggest how to do it.

The first step is to install the plugin:

composer require mglaman/composer-drupal-lenient

Then, add the module you want to update using the command:

composer config --merge --json extra.drupal-lenient.allowed-list '['module name']'

The final step is to create a patch to add compatibility of your module with D10 and upload it to composer.json.

An example of the command showing the creation of a patch for module compatibility with Drupal 10.


If you’ve successfully passed the entire process, you can proceed to the next stage of the upgrade.

6. Upgrade Drupal Core to version 10

Before upgrading Drupal core, it's a good idea to review composer.json and remove outdated patches that are incompatible with the newer version. After completing this process, implement the next steps.

Type the command in the terminal:

composer require 'drupal/core-recommended:^10' 'drupal/core-composer-scaffold:^10' 'drupal/core-project-message:^10' --update-with-dependencies --no-update

If you’re using core-dev, use this one:

composer require 'drupal/core-dev:^10' --dev --update-with-dependencies --no-update

Then raise Drush in composer.json to the latest version:

composer require 'drush/drush:^12' --no-update

Run the command:

composer update

If the versions in Composer work without any errors, run:

drush cr -y
updb
drush cex -y


7. Website testing

After upgrading to Drupal 10, it’s important to conduct thorough website tests in a local environment. Make sure that all key functionalities and website elements are working correctly. You should check essential functions such as forms, navigation, module performance, or integration with external services. It's also a good idea to review the website thoroughly from a visual perspective and look at logs to detect potential errors.

8. Deployment to test and production server

Once the website has been thoroughly tested in a local environment, the next step is to deploy it to a test server. This is a recommended action, as it allows further testing to be carried out in conditions similar to the actual usage environment.

After successful testing on the test server, the deployment phase to the production server follows. This is the final phase of the upgrade, during which the website is launched in the target environment and becomes available to all users. It’s worth ensuring that this process is carefully planned and executed. This will succeed in minimizing downtime and potential disruptions to website availability.

Remember to thoroughly check your hosting for Drupal 10 requirements once again before deploying to a production server, and make sure you’ve backed up your web page and database.

List of potential problems during the Drupal upgrade

You may encounter several different problems when upgrading your system to Drupal 10. Take a peek at my list to know what to expect and how to deal with them.

1. Functions removed and marked as "deprecated"

In Drupal 10, many features that worked in Drupal 9 have been removed or marked as "deprecated." This can cause potential errors in logs. The solution to the problem is to improve the code or write patches for the modules in which they occur. An excellent tool to assist in this process is the Drupal Upgrade Status module described earlier.

2. AccessCheck() required

As of Drupal 10, all content entity queries must include a call to the ::accessCheck() method before they’re executed. This is a system requirement to enhance security and access control.

3. The jQuery once function

The jQuery once function has been removed from Drupal 10 core, but it’s still present in many community-supplied modules, which can result in errors: 

Uncaught TypeError: $(...).once is not a function


Potential solutions:

  • Change core/jquery.once library to core/once in *.libraries.yml of the module or theme.
  • Change the $.once() function to once() in js files.

4. Modules incompatible with Drupal 10

A common problem when upgrading is the incompatibility of custom and contributed modules with Drupal 10. I described potential solutions to such issues in the paragraph on the Drupal Upgrade Status module.

5. Dependencies in Composer

Attempting to update is quite often blocked by dependencies of various modules in Composer. A helpful tool in resolving such conflicts will be the commands, which I describe in more detail in the next paragraph.

List of useful commands

To simplify your actions in Composer, I’ve prepared a list of practical commands to use depending on the situation.  

1. Composer why-not (you can also use composer prohibits)

This command displays a list of dependencies preventing updates. Application example:

composer why-not drupal/core ^10

2. The --no-update flag

Allows you to add a new dependency to composer.json without immediately updating it and installing new packages. Application example:

composer require 'drush/drush:^12' --no-update

3. The -dry-run flag

It allows you to simulate the update process without actually making changes. The Composer will show what actions will be taken during the update but will not make any changes to the actual files or dependencies of the project. Application example:

composer update --dry-run

Drupal 8 or 9 upgrade to 10 - summary

The process of upgrading to Drupal 10, while requiring some effort and commitment, is an investment that can bring significant benefits to your website. It’s not only a step forward in taking advantage of the latest features and improvements but also an essential aspect in improving security and bringing your website up to the latest web standards.

Hopefully, this guide will make it easier for you to go through the process and provide you with all the necessary tools to do it effectively and without much difficulty. However, if at some point you decide you need professional help upgrading your website to Drupal 10, our experienced developers can perform a complete upgrade or assist you with the migration phase of your choice.

Feb 22 2024
Feb 22

Introduction

This article offers insights on how and where to find jobs, and the fundamental steps to get the job that aligns with their professional goals.

Some people remain stuck where they are to avoid the hassle of finding new jobs, even when they desperately want to leave.

No wonder there. Job searches can be overwhelming.

It was for me, and it's the same with most people I've encountered who went job searching. 

The thrill of new opportunities, the uncertainty of the future, and the occasional rejection can do that to people. 

In this article, I'll share practical strategies to help you find the job you want—that matches your aspirations, skills, and career goals.

When To Start The Job Search?

You might've noticed that there are certain months when hiring booms.

And months when hiring freezes over. Radio silent.  

So, it's important to know when to start the whole process. You don't want to begin looking for a job when all the positions have already been filled.

Be Mindful Of Hiring Patterns

Learn when companies in your industry and country usually start hiring. For instance, companies in the US usually start sharing their open positions from October to December according to the latest International Labor Organization report. In India, that happens from May to July after the start of a new fiscal in April.

Time Of Week

Job application activity peaks at the week's start, especially on Tuesday, making it strategic to send applications early in the week. Many positions receive hundreds of applications within 24-48 hours, and recruiters hit the pause button to process those first.

Avoid Holiday Seasons

If you've worked in an office, you know people look forward to holiday seasons to take time off work. Few companies would hire during those times. Post holidays, however, are a good time to send in your job application. 

Why Do You Want A New Job?

Everyone looking for a job has a reason.

And it's imperative to know what your reason is so that you can select opportunities that align with your needs.

As Simon Sinek says, Start With Why. 

Here are a few questions to help you understand your motives for seeking a new job.

  • Professional growth: Are you seeking a new role to advance your skills and take on more challenging responsibilities?
  • Values alignment: Are you looking for a workplace that better aligns with your personal values and professional aspirations?
  • Work-life balance: Are you striving for a better work-life balance?
  • Learning opportunities: Do you want to work where the organization invests in their people's learning and skills development?
  • Company culture: Are you dissatisfied with your current organization's culture and would like to be a part of a more empowering workplace?
  • Financial considerations: Are you primarily motivated by the potential for better financial growth and stability?

You may have reasons entirely different and specific to you.

However, knowing your reason(s) will increase the likelihood of finding a position that aligns with your goals.

You may also realize that you didn't want to change jobs and were only doing it because others were doing it, making you feel insecure and fearful.

Where To Look For A New Job?

There was a time when people would find jobs in newspapers and brochures.Thankfully, we've got better avenues to search for the jobs nowadays.

Here are some places you can look for a new job:

  • Industry-specific job boards. Platforms like Indeed, Monster cater to various industries and have customizable search parameters. FlexJobs has postings for remote and flexible jobs. But I'd suggest starting with LinkedIn, as more recruiters and job seekers making a beeline to it. And you get all these cool insights into the job market, too.
  • Attend industry conferences, webinars, and meet-ups to connect with professionals, build relationships, and stay informed about potential openings.
  • Explore Best Place To Work companies from your industry to identify which companies you can apply for. You can always directly check out their open positions on their website and contact their recruiters via LinkedIn if you know what you're looking for.
Click here to apply for the Python staff engineer role at Axelerant

How To Look For A New Job?

Once you know your reasons and have identified a few potential positions to target from your job search, it's time to apply for jobs. 

This part, where you apply for jobs, requires a blend of digital finesse and real-world networking.

How To Look For A New Job_

Research The Organization And Its Culture

Before applying or attending interviews, thoroughly research the company, its values, and workplace culture. 

Explore the company's website, read recently published articles, and follow them on social media. Check Glassdoor reviews, too.

If something feels off, make points to clarify during the interview.

But if a lot seems off, you're better off not applying there. It will save you time and energy that can be better spent elsewhere.

You can also tailor your application according to their values. For instance, if the company values innovation and collaboration, tailor your application and interview responses to these cultural aspects.

Leverage LinkedIn Effectively

Most hiring managers look for candidates using LinkedIn. 

Unlike most job search portals, LinkedIn allows you to contact recruiters directly.

Optimize your LinkedIn profile to showcase your skills, experiences, and career aspirations. You can take a course to learn how to do this. 

Here are some steps you can take right away: 

  • Use the right keywords in your industry and job domain. Or the keywords for the job you're trying to get.
  • Include a professional summary; write in the first-person narrative—that's how you own your story
  • Use short, concise paragraphs and bullets to highlight key skills, accomplishments, and results
  • Connect with professionals in your industry
  • Join relevant groups and engage in discussions to expand your network

Network Strategically

Connect with people in your industry and the job roles you want to be in.

This step takes a continuous effort and genuine interest in people.

It's not a quick, immediate fix for when you need a job.

Your network will include people in your industry whose work and character you admire and learn from.

One way to identify the people you want to connect with, on LinkedIn or other socials, is to see where they work and what that work entails.

If you have applied to an organization or plan to apply, connect with your potential colleagues and have casual (with a hint of professional tone) conversations with them.

Ask them about the organization, their experience, and their work. Share your aspirations with them, too. 

Axelerant team members connect easily

Tap Into Your Network for Referrals

Use your professional network—consisting of people you've connected with strategically—to seek referrals within their companies once you build a rapport.

If you have a connection at a company you admire, express your interest and inquire about potential opportunities.

Referrals often carry significant weight in the hiring process.

Plus, if the company has a referral program, the person referring you gets a bonus if you make it in. Quid pro quo done right. 

Engage In Informational Interviews

An informational interview is a great way to gain insights and advice about your desired career path. 

It's a friendly meeting with a professional, perhaps someone whose work you admire, to learn about career paths and work experiences. 

Unlike a job interview, the focus is on gathering valuable information, expanding your network, and building relationships. 

Requesting these interviews can lead to potential job opportunities and a better understanding of your desired field.

But not everyone would be willing to engage with you; be prepared for rejections and stalling.

Vivek out having lunch with UN colleagues

Craft Tailored Resumes And Cover Letters

Recruiters and hiring managers usually spend a minute or less browsing a resume.

So you want to highlight your achievements, experience, and skills that align with the role you're applying for.

And make the resume as skimmable as possible.

Include facts and numbers to highlight the impact of your work in your past position.

For instance, if you were a web developer, highlight how your contributions increased the clients' website traffic, engagement and conversation rates, etc.

Showcase Transferable Skills

Transferable skills are applicable across various roles and industries. They are abilities and knowledge gained from past experiences that can be used in any job, such as time management, prioritizing, problem-solving, good verbal and written communication, etc. 

These differ from core job skills, like coding for an engineer or accounting for a chartered accountant.

These skills show hiring managers that you're adaptable and versatile. 

For example, if you're transitioning from a project management role in IT to a similar position in marketing, emphasize skills such as organization, communication, and the ability to meet deadlines. 

Surabhi planning an offsite

Build An Online Portfolio

There are tons of websites that you can use to create your online portfolio.

Explore creative portfolios on Behance to get a reference. 

Once you get a general idea, build a simple and elegant portfolio with Wix, Weebly, WordPress.com, or Cargo. And add your work that you're proud of.

It allows you to display your skills, experience, and accomplishments to potential clients or employers easily and effectively, anywhere in the world, anytime. 

You can even include your portfolio link in your resume, guaranteeing a better interview chance. 

For instance, graphic designers can display their designs, writers can feature published articles, and programmers can link to their GitHub repositories.

Set Up Job Alerts

Job portals and professional networks have this incredible system for job alerts. 

Anytime a recruiter posts a job opening in your industry and interested domain, you get a notification on your chosen device.

To get the most out of this feature, set up your job alert with the right keywords, or else it can get annoying after a while.

For example, a software engineer would use keywords like Software Development, Programming, Coding, Web Development, Full Stack Development, Front-end Development, etc.

Here's how you can do it on LinkedIn.

Follow Up Thoughtfully

Not many people will send a thoughtful follow-up email after the interview.

If you feel that the organization you interviewed for is a place you can work in, write a follow-up email or drop a LinkedIn message to the hiring manager. 

Don't make it too long or flowery. The goal is not to fawn over the person.

Express your gratitude for the opportunity and reaffirm your interest in the position by briefly highlighting how your skills and experience align with the company's needs.

That's sure to make you stand out in their mind.

How Do You Deal With Job Rejection?

Many people do not talk about the toll job searching can take on a person.

You can read Arzoo Tomer's story here, where she narrates her journey of dealing with interview rejection at Axelerant. 

Arzoo worried about her future, sitting in front of the laptop

After tens of rejections, you might receive one or two job offers aligning with your goals.

These rejections eventually add up, creating self-doubt and a dent in confidence.

And when one internalizes rejections, their brain activates its threat response, releasing stress hormones like cortisol.

Here are some steps you can consciously take to protect your well-being and peace while searching for jobs:

Practice Self-Compassion And Self-Care

Recognize that job searching can be challenging. Be kind to yourself and celebrate small victories, like submitting a tailored resume or securing an informational interview. 

And remember self-care, whether through exercise, mindfulness practices, or activities that bring you joy. 

Create A Support System

Share your journey with friends, family, or mentors. Having a support system provides encouragement, insights, and a valuable outlet for expressing your thoughts and feelings.

Set Realistic Goals

Break down your job search into manageable goals. Don't target applying to 20 companies in one night.

Setting realistic and achievable milestones helps maintain motivation and prevents feelings of overwhelm.

Establish A Routine

Maintain a daily routine to provide structure and stability to the process.

Set a particular time for job searching activities within the day, as you'd probably have many other things to take care of—like your current job responsibilities! 

A well-organized day keeps stress at bay.

Build Your Growth Mindset

A growth mindset allows you to view setbacks and rejections as opportunities for growth and realignment—instead of personal failures. But it does need some practice and reframing of our internal dialogue to see substantial results. Here is a video by psychologist Carol Dweck that explains this concept in more detail.

[embedded content]

Finding a job that you deserve and aligns with your professional aspirations can be difficult.

But if you go at it with patience and the right strategy, you'll land the job you've always dreamed of.

Click here to apply for the Python staff engineer role at Axelerant
Feb 22 2024
Feb 22

Unveiling the Drupal Mountain Camp 2024 Schedule!

The schedule for Drupal Mountain Camp 2024 is live, featuring an impressive line-up of keynote speakers and featured sessions. After a thorough and meticulous selection process, we've curated a diverse schedule with sessions aligning with the camp's theme, ensuring overall quality, relevance, and inclusivity across various tracks.

Explore the detailed schedule to plan your agenda and make the most of this exciting event: https://event.drupalmountaincamp.ch/drupal-mountain-camp-2024/schedule/

Regular tickets are still open.

Come join us for an event full of learning, networking, and fun in the picturesque setting of Davos, Switzerland.

Feb 21 2024
Feb 21

Authored by: Nadiia Nykolaichuk.

Whatever specific kinds of content your website needs — articles, news, testimonials, products, user profiles, events — fields help organize them into predefined structures or templates. This ensures consistency in how all items of a certain type are displayed and managed, and gives you ultimate flexibility in content modeling.

Achieving the perfect structural harmony through Drupal fields is now easier than ever before: the interface for creating, configuring, and re-using fields in Drupal has been revamped from the ground up to become incredibly user-friendly. The most remarkable part of the work done on the new Field UI is included with Drupal 10.2. Below we explore some of the best tweaks of the new interface in comparison to the old one. 

Unlocking Drupal fields: an essential cheat sheet

Before we dive into the changes the new Field interface is bringing, let’s run through the key concepts of Drupal fields.

Fieldable content. The word “content” can be used here as a general term, but officially, Drupal has different entity types with a fieldable structure, which means they can be organized into fields. They are content types, media types, user accounts, taxonomy terms, block types, menu items etc.

Fieldable content structure in Drupal.Fieldable content structure in Drupal.

Field types and field instances. Fields are classified into types based on what kind of data they can store. This includes text, images, numbers, dates, references to other data types (for example, the author of content), and more. Drupal provides several standard field types out of the box that cover the most common use cases. Contributed and custom modules can add their field types. Each specific field is an instance of a certain type.

Field settings. Each field has general, field-level settings. Examples of these settings are required/non-required status, default values, and allowed values (maximum file size, file types, and more).

Field display. You can also configure how your field looks in a specific content type or even in a display mode within a content type (for example, a teaser of articles). The “Manage display” and the “Manage form display” tabs of a content type are designed to configure each field display for the front end and back end, respectively. Among other things, you can hide or show the label (such as the word “image”), and configure formatters and widgets: 

  • Field formatters. They determine how the field data is displayed to users as they view content on the front end. This might include trimming text to a certain length, displaying dates in different formats, and more. 
  • Field widgets. They define how website editors enter data into the field. This might include a select list, checkboxes, radio buttons, autocomplete, a file upload widget, and more. 

Drupal’s new Field UI: utmost user-friendliness of field creation

The steps for creating fields used to be a little overwhelming and not always straightforward, but the tides have changed. Drupal creator’s keynote at DrupalCon Lille 2023 demoed a revamped field creation interface.

Delivering his presentation in the form of a fascinating fairy-tale about the Drupal village, Dries Buytaert mentioned the new Field UI as part of the promise given to the villagers to “create tools that are easy to use.” He invited Tim Plunkett (tim.plunkett), Drupal core developer and initiative coordinator, to introduce the new interface.

In Tim’s demo, we can see a handy modal window with the available field types. At the time of writing this article, the modal is not yet ready. It is part of the future roadmap, alongside keyboard accessibility and other nice improvements currently in the works. 

The planned modal functionality for the Field UI demoed at DrupalCon 2023.The planned modal functionality for the Field UI demoed at DrupalCon 2023.

Tim Plunkett told the audience that in early 2023, their team sought to better understand the user flow and specific pain points that contributed to the perception that Drupal was hard to use. They started with user research and, after analyzing and summarizing the feedback, they began working on two specific areas:

Despite more work still going on, the bulk of the revamped UI has already been gradually introduced in Drupal 10.1 and 10.2. The new modern interface makes everything easier to understand, eliminates overwhelming steps in the workflows, and helps users make more informed choices.

For example, as opposed to using the old dropdown menu, users can now quickly choose the needed field type thanks to user-friendly field grouping with icons and simple summaries. They can also specify additional details on the same form using clear explanations about them.

The old field creation interface vs. the new field creation interface introduced in Drupal 10.2.The old field creation interface vs. the new field creation interface introduced in Drupal 10.2.

As far as field re-use, there is a new handy button for this and a page where users can discover all the details about each field before choosing to re-use it.

The old field re-use interface vs. the new field re-use interface introduced in Drupal 10.1.The old field re-use interface vs. the new field re-use interface introduced in Drupal 10.1.

In the next part of the article, we will compare in every detail the old ways and the new ways of field creation and field re-use. 

Detailed field creation comparison: the old and the new UI

1. Field creation in the old UI

Whenever you need to create a new field via the traditional interface, you go to the Manage fields > Add field page of a content type, and see a long dropdown menu of available field types. You select the field type not always knowing for sure if it’s the right one. Then you give it a label for administrative purposes and click “Save and continue.” 

The dropdown for selecting a field type when adding a new field in the old UI.The dropdown for selecting a field type when adding a new field in the old UI.Providing the field label when adding a new field in the old UI.Providing the field label when adding a new field in the old UI.

Then you get redirected to the next step of the settings that enable you to additionally select between the data type (if there’s any choice available) and set the allowed number of values to unlimited if needed. 

The middle page of field settings during field creation in the old UI.The middle page of field settings during field creation in the old UI.

After clicking “Save field settings,” you arrive at yet another configuration page. It enables you to customize the label the way you want it to be displayed to users on the front end. You can also optionally provide a help text, check the “Required field” checkbox, and specify the default value. Finally, you can click the “Save settings” button, which marks the end of the process. 

The final page of field settings during field creation in the old Field UI.The final page of field settings during field creation in the old Field UI.

2. Field creation in the new UI

As you start adding a new field with the revamped Field UI available in Drupal 10.2, you can give your field a label and proceed to choose your field type. The available field types are introduced in user-friendly groups. Each group has an icon and a brief and simple description for better understanding. In Drupal 10.2 core, when no additional modules are installed, there are 11 field-type groups, which is a pretty reasonable number to avoid overwhelming the users. 

You select the field type group and an additional “Choose an option below” section appears at the bottom of the page. It allows you to select a specific field type (if the group includes more than one). In our example where we chose “Date,” there is a choice between such field types as just “Date” and “Timestamp.”

And instead of a “blind date” in the Date field, the new Field UI lets you make an informed decision about adding it. 

Field grouping and basic settings in the new UI.Field grouping and basic settings in the new UI.

By clicking “Continue,” you arrive at the next page of the setup, which is luckily also the last one. It enables you to edit the field label the way you want it to look for users and select the data type if there’s any choice available. You can also optionally make the number of values unlimited, provide a help text, make the field required, and provide the default value for it. Click “Save settings” and that’s it.

The final page of field settings during field creation in the new UI.The final page of field settings during field creation in the new UI.

Detailed field re-use comparison: the old and the new UI

1. Field re-use in the old UI

Next to the “Add a new field” dropdown on the Manage fields > Add field page of a content type, there is also the “Re-use an existing field” dropdown. It lists all fields without any information of where they are used. 

The dropdown for re-using an existing field in the old UI.The dropdown for re-using an existing field in the old UI.

When the field type is selected, you can specify the label.

Providing the field label when re-using an existing field in the old UI.Providing the field label when re-using an existing field in the old UI.

By clicking “Save and continue,” you get redirected to the setup page. 

The final settings page for re-using a field in the old UI.The final settings page for re-using a field in the old UI.

2. Field re-use in the new UI

The new interface has a handy button “Re-use an existing field” that appeared back in Drupal 10.1.

The “Re-use an existing field” button in the new UI.The “Re-use an existing field” button in the new UI.

After clicking the button, you see a modal window with the list of available fields. You can see their machine names and types, and a quick summary of essential information about them (like where they are used and what number of values they have). You can use a search box to search for a specific field or field type. Once you have chosen the field, click the “Re-use” button next to it.

Information about each field for re-use in the new UI.Information about each field for re-use in the new UI.

You’ll get redirected to the settings page to complete the setup.

The final settings page for re-using a field in the new UI.The final settings page for re-using a field in the new UI.

Final thoughts

Each Drupal innovation is a huge step toward a brilliant future where CMSs are increasingly user-friendly. The revamped Field UI and other new functionalities look amazing and offer lots of advantages to users. There is perhaps only one disadvantage — when comparing the old and the new experiences, it’s very difficult to come back to old ways again. The good news is there’s no need to — update your Drupal website and benefit from all the new enhancements!

Feb 21 2024
Feb 21

In the ever-evolving landscape of modern technology, a critical conversation has been unfolding around the environmental impact of our digital advancements. The spotlight has more recently been sharply focused on the primary offending sectors like cryptocurrency and artificial intelligence, revealing a concerning narrative about their substantial energy consumption and carbon footprint. This narrative also extends to the broader tech realm, encompassing the vast and intricate web of digital solutions we have all come to rely on.

Amidst this backdrop, the IT sector, including software development, is becoming increasingly recognized for its significant carbon footprint. Recent estimates suggest that its CO2 emissions are around 4% of global totals, comparable to the aviation industry. This alarming statistic underscores the urgent need for sustainable practices within the sector.

Organizations like the Green Software Foundation and The Green Web Foundation are at the forefront of addressing these challenges. They are leading the way in developing standards and best practices for greener software development. Their focus on software efficiency and energy-aware design is crucial in reshaping how the industry approaches sustainability.

Drupal is a leading open-source CMS that powers 1% of the entire Internet, including 6.6% of the top 10,000 sites, and the Drupal community has a sustainability initiative as well. The community estimates the carbon footprint of Drupal.org, carefully follows the environmental commitments of our partners like GitLab, and tracks software issues that have an impact on sustainability. The Drupal project is also a recognized Digital Public Good based on its role in helping to attain the UN sustainable development goals, which include environmental impact. But there's much more we can and should do.

In the context of these developments, there is an opportunity to examine how we can optimize our websites and web applications in production and during development. The advent of more advanced development pipelines over the past decade has presented us with a prime opportunity to proactively reduce unnecessary resource-consuming patterns in our code and execution at runtime. Put very simply, better-performing applications are better for both business and the environment.

Today, we want to present what we believe to be a significant next step. We'll discuss Gander, an automated performance testing framework for Drupal, and how it contributes to the path toward a more sustainable future with Drupal.

Gander: Integrated Performance Testing for Drupal

Gander, an open-source automated performance testing framework, represents a continued collaboration between the Google Chrome team and Tag1 Consulting to optimize Drupal's execution. As a tool specifically designed for Drupal, which powers millions of websites and applications globally, Gander's integration into Drupal’s CI Pipeline is a game-changer.

The tool provides performance testing during the development of Drupal core that helps to catch any performance regressions introduced by new development and gives a measurement to the impact of optimization work that did not exist before. Ensuring that performance (and therefore sustainability) is always considered in the Drupal roadmap, paying dividends to every software end user. It also empowers anyone running Drupal to incorporate performance testing into their projects, where we know that reducing friction in the user experience and enhancing user engagement will improve conversion rates and give them a stronger competitive position.

The introduction of Gander represents a paradigm shift in the way Drupal approaches performance testing. Traditionally a manual and reactive process, performance testing now becomes proactive and automated with Gander, benefiting Drupal core maintainers and, ultimately, the end-users of Drupal.

Furthermore, Gander sets a precedent for integrating performance optimization tools in the open-source CMS community as a whole. WordPress is also implementing an automated performance testing framework in collaboration with the Google Chrome team, and we hope that our experience with Gander can help accelerate their work.

Drupal, GitLab & Gander: A Leap in the Right Direction

Many mature open-source platforms were built before modern developer tooling stacks were available. Drupal was no different, but the Drupal Association made a significant investment to move the Drupal project to GitLab in recent years for its code management and community contributions. This represents a significant stride towards enhanced development and quality assurance processes and a strategic decision to embrace a more collaborative and integrated approach vs. the previously custom-built solution that was starting to age and lacked contemporary development features.

GitLab, known for its robust DevOps capabilities, made it possible to introduce Gander, an automated performance testing framework, into Drupal's pipeline alongside the existing QA system, a solution that Tag1 also helps support and maintain as a partner of the Drupal Association.

Gander's initial development focus was on optimizing Drupal Core and ensuring that the core functionalities of Drupal receive dedicated attention for performance enhancement. However, the framework's design is not limited to just Drupal Core. By using GitLab’s “runners,” Its architecture allows for easy extension to contributed and custom code development.

This flexibility means that the entire Drupal ecosystem can benefit from Gander's performance optimization and efficiency, ultimately contributing to Drupal's sustainability initiative. Integrating Gander into the Drupal project is not just a step but a leap in the right direction, fostering an environment where continuous improvement and efficient development are paramount.

A Closer Look at the Science Behind the Energy Savings

The Software Carbon Intensity (SCI) model is increasingly becoming the standard in integrating carbon impact assessments into software business operations. Renowned organizations, including Google, utilize this model to help gauge the environmental footprint of software, focusing on energy consumption and total greenhouse gas (GHG) emissions. This method aligns well with the growing emphasis on Environmental, Social, and Governance (ESG) policies, prompting companies of all sizes and types to evaluate the environmental impact of their digital activities in alignment with their broader ESG commitments.

However, directly applying the SCI model to assess Gander’s specific impact on Drupal currently involves some complex challenges. Carbon impact calculation is influenced by a diverse set of factors, such as server energy consumption patterns, multiple vendors across the stack (Hosting, CDN/WAF, APM, SEIM monitoring, etc.), the efficiency of different data centers, and hardware variety, to name a few. These aspects complicate any precise SCI-based assessment of Gander's sustainability contribution at this time.

While the complexities of measuring Gander's environmental impact are currently challenging, its overall benefits in performance optimization are evident, particularly given Drupal's vast global usage across millions of websites. Enhanced application performance typically reduces energy consumption, indicating a significant environmental benefit. As cloud and service providers enhance the accessibility of relevant metrics, we anticipate a future where integrating SCI or similar environmental impact measurements into Drupal's development and production processes becomes more straightforward. This advancement would allow for real-time visualization of environmental impacts in dashboards, build runtimes, and admin interfaces, providing a tangible and measurable view of the ecological advantages gained from performance optimization.

Future Prospects

Looking ahead, Gander's role in Drupal's ecosystem is poised for expansion and enhancement. Most importantly, we want to align with the goals set forth by the community project around the Sustainability of Drupal. Future developments include more performance testing of Drupal core, including testing of merge requests and active branches, thereby ensuring continuous improvement in performance and scalability, highlighting that investing resources early in the development cycle translates into an exponential efficiency gain on this investment downstream.

Additionally, Gander plans to extend its capabilities to the realm of contributed modules and distributions. We would like to see rapid adoption by the community and look forward to seeing tailored performance tests written and run regularly by these project maintainers. This expansion will improve the quality of individual modules and contribute to Drupal-powered sites' overall efficiency across the web.

Near future enhancements like image optimization detection and database request load counts in Gander could further amplify these benefits, reducing load times and energy usage and will help solidify Drupal's position as a leader in sustainable web development.

Conclusion: Promoting Gander's Core Purpose

In summary, Gander stands as a testament to advancing Drupal's capabilities, primarily focusing on automated performance and scalability. It's a tool that benefits Drupal developers and the vast community of end-users and site builders, ensuring that Drupal's performance is consistently elevated. Gander's role extends beyond mere technical enhancements; it's about fostering a more efficient, responsive, and sustainable digital ecosystem.

We encourage everyone in the Drupal community and beyond to explore Gander to see its impact on website performance firsthand. Your involvement and feedback are crucial in shaping a more sustainable and efficient future for technology. Together, let us embrace and contribute to this innovative journey with Gander, enhancing Drupal, the broader digital world, and the real world we all share.

We want to thank the Google Chrome team for their investment in the sustainability of open-source software, the GitLab team for their tooling, which enabled us to integrate Gander into the Drupal development cycle, and the Drupal Association for their collaboration in making this vision a reality for the community.

Huge thanks also to Adam Silverstein (Google, WordPress), Tim Lehnen (Drupal Association), Michael Meyers, Mariano Crivello, and Janez Urevc for contributing to this blog post.

Image by JackieLou DL from Pixabay

Feb 21 2024
Feb 21

Starting today, the Drupal 11.x branch is used for building the next major Drupal version, Drupal 11. This means that major version specific changes can now happen on the Drupal 11.x branch. This includes dependency and requirements updates and removal of deprecated API and extensions. Details are available in the allowed changes during Drupal core release cycle document.

Drupal 11 is planned to be released either on the week of June 17, week of July 29 or week of December 9, 2024, depending on when beta requirements are completed.

A 10.3.x branch was created to work on the upcoming minor version. Drupal 10.3.0 will be released on the week of June 17, 2024.

Issues should remain targeted at the 11.x branch and will be backported when appropriate.

Feb 21 2024
Feb 21

Introduction

Choosing a team's new Jira test management tool can be challenging, as one needs to consider a few key factors. The ideal test management tool should include test automation and observation testing. It should be easy to use, have robust test management capabilities, and have an efficient user interface.

Keep reading to find which tools fit these criteria.

What Is Jira

Jira is an open-source bug-tracking tool that supports developers and testers to keep track of the status of a reported bug via Jira tickets. Jira is a project-tracking software that helps in planning, tracking, and managing projects with ease.

It offers several benefits.

  • Jira provides planning and roadmap tools so teams can manage stakeholders, budgets, and feature requirements from day one.
  • Jira integrates with various CI/CD tools to facilitate transparency throughout the software development cycle. A live production code status surfaces in the Jira issue when it's ready to deploy.
  • Integrated feature flagging tools allow teams to roll out new features gradually and safely.
  • Jira helps create tasks for team members to work on and complete details, due dates, and reminders.
  • It helps with subtasks to break down larger items of work. Users can create sub-tasks within the parent task to break down the unit of work into digestible pieces for various team members. 
  • Jira also provides a comfortable view of all tasks on the board to visualize the progress of the tickets easily.

What Is Test Management

Test Management refers to planning how testing will be done compared to all requirements like execution and analysis. During test management, reporting is also done to summarize the status of all quality assurance activities.

Test Management helps the software get rid of costly setbacks. This approach helps reduce waste and implement measures during the testing phase, which speeds up the process. Test management, if done correctly, also provides benefits like:

Eliminating Data Duplication

While managing test cases, there is a high possibility of duplication. Test management tools should be used to avoid such confusion, as these tools allow testers to verify the same information during testing. When test management tools are used, it reduces the total time of execution by getting rid of duplicate data.

Conformance To Standard

Organizations that try to keep up with intended standard levels document the test and its associated results. The test management tools help maintain such records for reference. The records are also kept for different versions of software released at different environments and times for a better understanding of the software to be delivered.

Reduction Of Communication Gap

The test management tools enhance the traceability of bug status. It helps the testers and developers interact via the comments section. It also makes it easier to track the assignment of tasks and status updates.

Analyzing The Need For Test Management Tools

Apart from making it easier to achieve the benefits mentioned above, a practical test management tool enables businesses to manage the entire testing process. It eliminates the need for multiple software that handles individual testing steps.

It allows easy collaboration on projects, so teams can ship high-quality products and deliver services that meet customer needs. Beyond this, the right test management tools can help teams lead smoother, more consistent projects that contribute to the organization's profit.

Test Management Tools For Jira

There are several test management tools for Jira available in the market. Most of these tools differ in their user interface, usability, integrations, and pricing. And some of the most popular test management tools for Jira are:

Selecting The Right Test Management Tool

With the many choices available in the market, it can be challenging to select the right test management tool for your team. But to help speed up the process, some factors can be considered, including:

Integrative Nature

A testing tool must integrate itself with the existing tool stack. Testers should ask if the tool integrates with the bug or issue-tracking software.

Flexibility

The system should be flexible enough to handle a variety of styles of development and different projects. A tester might have a specific project in mind while selecting a tool, but one should avoid over-specializing.

Task Tracking And Assignment

A key benefit of test management tools is the ability to assign and track tasks across the team. Your team might already be using a system like Jira or Trello to do this, but it is also helpful to do this in a test management tool.

Traceability

It is vital to trace test executions and outcomes. This means a test management tool should help track test runs, and issues, verify bug fixes, and record successful tests.

Test Automation

Many teams skip using excel spreadsheets even though it allows for test automation and automation within the test management process.

Comparing Popular Test Management Tools

Find a detailed comparison between the top five test management tools available in the market right now.

Comparing_popular_test_management_tools

Axelerant's View On Test Management

The experts at Axelerant ensure proper regulation of testing tasks and processes to be followed along with frequent updates to the customer on the progress. This is done by focusing on the following tools.

BrowserStack

BrowserStack Test Management is one of the latest tools for unified test management. Teams can easily track test cases and test runs in Jira with two-way binding. This allows for updating the status and tracking the progress to achieve end-to-end traceability with Jira two-way binding. Other key features:

  • Easily import test cases from TestRail or Zephyr Scale using an API token.
  • Create test cases with pre-defined templates.
  • Supports 15+ frameworks such as TestNG, WebdriverIO, Nightwatch.js, Appium, and Playwright.
  • Integrates with Jenkins, Azure Pipelines, Bamboo & CircleCI
  • Monitors historical data, coverage metrics, and testing trends across test cases.

Zephyr

Zephyr is more than a test management solution. From creating test cases and plans to define user requirements and generating reports, Zephyr Enterprise arms testers with the insights, flexibility, and visibility necessary to deliver software faster with fewer bugs. A few keys features are:

  • Premium enterprise support
  • Bi-directional Jira integration
  • Enterprise-grade test planning and auditing
  • End-to-end traceability
  • Flexible support for third-party automation frameworks
  • Legacy ALM migration path and transition plan

Zephyr

Zephyr1

TestLink

TestLink is one of the best open-source test management tools. It helps in planning, reporting, testing specifications, and requirement tracking. Other key features of the tool are: Reports and charts are available to track the project's progress, while additional features include assigning keywords specifying requirements and events log.

  • Events log
  • Assigning keywords-specific requirements
  • Charts support
  • Metrics support
  • Test creation and execution
  • User-friendly UI
  • Defect recording

Testlink

TestRail

TestRail provides comprehensive test case management to help organize testing efforts and get real-time insights into testing activity. Powerful reports and metrics enable QA teams to increase productivity and deliver fast feedback. The tool also comes packed with other features like:

  • Easily track the status of individual tests
  • Measuring progress with informative dashboards and activity reports
  • Comparing results across multiple test runs, configurations, and milestones
  • Tracking team workload to adjust assignments and resources
  • High customization with cloud-based or on-premise installation options
  • Integrates with defect tracking and collaboration solutions such as Atlassian Jira, FogBugz, Bugzilla, Axosoft, GitHub, and TFS; and with leading test automation tools, including Ranorex Studio

Testrail

QMetry

QMetry helps extend the QMetry Test Manager tool's integration with Jira. The add-on empowers users to manage testing projects within Jira. It also enhances the potentiality of Jira projects to carry on the entire test cycle smoothly. In addition to standard Jira issue types, testers can create test scenarios, test cases, and test run issues if the QTM add-on is installed and configured with Jira. Other features of this tool are:

  • Authoring, cloning, reusability, and establishing links inside Jira with native BDD support
  • Cross-project reporting with dashboard gadgets and Confluence integration
  • Scalable and flexible with ready-made integrations for CI/CD tools and Open REST APIs
  • Create, retain, and manage versions of test assets
  • Minimize testing efforts with test data parameterization
  • Granular user and group-level permissions to ensure secure use

Qmetry

Xray

Xray is a Jira add-on for test management. The tool is budget-friendly and enables testing per the assumptions of BDD. It integrates seamlessly with automation tools and DevOps through APIs.

Xray works on both Cloud and Server. Its most significant benefit is that it builds on existing Jira features, which means that the tool doesn't invent many new rules, isn't siloed, or needs unique integrations.

The tool also comes with a few other features, including:

  • Has traceability between requirements, tests, defects, and executions
  • Organizes tests in folders and test sets
  • Tracks progress with test plans
  • Integrates with CI

Read more to learn how to use Xray in an agile environment.

Conclusion

Test management tools make it easy to manage the development process of both simple and complex software. On top of this, these tools are easy to integrate and help establish efficient and flexible processes. The experts at Axelerant use these tools to quality engineer digital journeys.

Feb 21 2024
Feb 21

Introduction

This article offers the benefits and ways of practicing kindness within organizations and teams.

People deserve and expect kindness. It’s human nature. 

Whether it’s at work or home (or in any other place).

Kindness makes all the difference between a workplace people want to join and one that gets a bad rep on Glassdoor.

The culture within teams, the well-being of its people, and even the quality of work produced take a hit in the absence of kindness. 

And so, consciously practicing kindness is non-negotiable for long-term success.

What Does Kindness Mean?

Kindness is acting from a state of mind where one wants what's best for others—with empathy, consideration, and much humility—without expecting favors in return.

(Quid pro quo exchanges don't count as being kind.)

When one chooses to be kind, they let go of their ego, envy, and selfish behavioral and thought patterns.

Kindness is often confused with being nice, rooted in a yearning to be liked and accepted by others. 

One can continue to be nice and not care about others' well-being or growth.

And even granting people what's rightfully theirs, like letting teammates go on leave.

What Does The Opposite Of Kindness Look Like At Work?

The opposite of kindness at work looks like fear, insecurity, and heaps of self-centeredness.

Scenario 1:

Here's a recent incident that an acquaintance faced at a reputed company.

A woman came down with a fever at work. It was 11:30 AM, and she decided to soldier on and take half a day off. 

At 1:30 PM, she requested leave from her manager.

Manager: "Have you finished today's assignment yet?"

Woman: "No, I started it this morning. But I'm almost done."

Manager: "Good, then it won't take much time. Please finish the assignment and then take the leave." 

Scenario 2:

A virtual meeting room in one of the biggest global IT giants.  

I heard the feeble voice of a man (possibly over 40 years old)—speaking directly from the hospital bed—in a scrum meeting. The man had suffered a heart attack the day before.

If this wasn't enough, someone had the gall to ask when he would "tentatively" be able to rejoin work.

When people don't practice kindness within teams, it creates a culture of viewing human beings as little more than mere resources.

Apply at Axelerant by clicking here. We believe people grow better with kindness and support.

The Importance Of Kindness In The Workplace

The practice of kindness can help create emotionally mature organizations.

By transforming its team members, right from the top.

According to the American Public Health Association, practicing kindness can:

  • Improve one's mood and self-esteem 
  • Boost immune system 
  • Lower blood pressure 
  • Relieve anxiety by increasing the body's release of feel-good chemicals, like dopamine and endorphins

Studies show that it also brings happiness and a sense of meaning to people's lives.

At an organizational level, research indicates that acts of kindness can be linked to higher productivity, efficiency, and lower attrition rates. 

These are precisely the results that leaders want in their organizations.

Boosts Team Morale

Kindness is a powerful morale booster, especially during high-intensity work. 

Showing kindness, for instance, by appreciating and recognizing the small efforts that usually go unnoticed and taken for granted, strengthens team bonding.

When teammates (especially leaders) show kindness in their interactions, it inspires people to do better, resulting in high-quality work that people can be proud of.

Team members happy together

Creates And Sustains Psychologically Safe Spaces

When people in an organization consciously practice kindness, it creates a psychologically safe space. 

Team members feel secure in voicing their opinions, taking calculated risks, and exploring innovative solutions. 

Feelings of fear, ridicule, and negative consequences gradually decrease. 

People also feel empowered to provide honest feedback and challenge the status quo to remove harmful or defunct practices.

Fosters Fearless Creativity

A by-product of knowing the existence of kindness in one's team and having a psychologically safe environment is fearless creativity.

Because the fear of judgment—or any kind, for that matter—stifles creativity.

Fear acts as a barrier to the free expression of ideas and originality. 

People run and chase what they are told to and avoid speaking up for fear of consequences.

It can cost an organization dearly, as they get stuck in a rut, doing the same things repeatedly and expecting better results.

Manjula working with a smile on her face

Enables Smooth, Frictionless Collaborations

We've all had the "fortune" of conversing with unkind people.

Imagine that as the norm in the workplace.

A single insensitive person is enough to muddy the collaborative spirit of a team—especially when they are in a leadership position or are protected by someone in a leadership position.

When team members are consciously kind to each other, everyone feels supported and seen. 

Conversations happen organically and smoothly. 

Without friction or constantly walking over eggshells.

Even when the stakes are high and deadlines near, a kind and collaborative team spirit is a buffer against stress.

George appreciating Pragathis kindness

Builds Loyalty And Reduces Attrition

People are likelier to stay in organizations where leaders prioritize kindness.

It builds a strong loyalty when people feel treated fairly and respectfully—core components of kind behaviors at work.

Finding the right people takes much effort and resources, especially for an organization like Axelerant, where culture is paramount.

Many organizations also invest in role-specific training right from onboarding.

For instance, Axelerant's annual education benefit lets people upskill through professional courses.

When they leave abruptly, all that resource and training is wasted.

Practicing kindness is an investment in reducing attrition and building organizational loyalty.

How To Practice Kindness In The Workplace? 

Even with the right intention, people often need help figuring out how to start being kind at work. 

Treat others as they would like to be treated themselves.

Here are some examples of kindness in the workplace that can help one start their kindness journey at work, and in life.

How to practice kindness at the workplace

Ownership Of Work

Work ownership is an integral part of practicing kindness within a team—because it lays the foundation for people to be kind.  

It requires embracing work with a sense of responsibility beyond mere task completion.

When people own their part, end to end, they give others the freedom to do their best work.

This lightens the workload and creates an atmosphere of reliability and trust. 

The burden of success gets distributed organically, too.

It becomes easier for people to trust that their teammates are putting in their best effort. 

People don't just feel accountable for their tasks but are deeply connected to the team's wins. 

Michael recognizing a team members work ownership

Choosing Trust By Default

Trust is foundational to practicing kindness at work or in any group.

The general wisdom about trust is that it needs to be earned. Through sweat, toil, and steadfast dedication.

And so, professional relationships often begin erring on caution and suspicion.

Breeding distrust of people's motives and abilities.

And distrust makes teammates do unkind things—questioning each other cynically and jumping to conclusions at first chance.

Always assume positive—or neutral—motives, even in challenging situations. 

And have faith that your team members can work through a problem and produce great work.

This practice is an intentional choice and takes effort to cultivate.

It creates a workplace culture where trust is not "earned" but freely given. 

A culture that values the inherent goodness in every team member.

Practicing Empathy

Empathy can bring authenticity and understanding into workplace relationships. 

Being empathetic to others' problems or experiences helps us relate to them and, in turn, allows us to be kind. 

Empathy involves putting oneself in someone else's shoes and creating a safe space where they feel heard and validated. 

For example, one of your colleagues might need help adapting to the new work environment after joining.

Recollecting your own experiences of being a new joiner and empathizing from that mind space would allow you to understand their situation and help them better. 

Empathy helps us see team members as fellow humans navigating the complexities of professional life—just like us.

Interview practise session

Building Bonds On Mutual Respect

The link between respect and kindness is quite obvious.

Seeing and respecting team members as human beings is a must for one to be kind. 

But it doesn't stop there. 

People must realize that each team member's work is valuable and deserves respect. The team needs their contributions to reach its goals effectively and qualitatively. 

Plus, it boosts a sense of pride, confidence, and ownership when there's mutual respect in a team.

Manifesting Humility

Being humble is harder than it sounds.

Even when someone praises one for being humble, one's humility takes a dip momentarily. Sneaky business.

When team members are humble, they leave their arrogance and ego out of conversations. 

They don't need to assert dominance to make themselves feel important. 

They don't feel that the organization, and all its people, revolve around them.

Humble people freely acknowledge their mistakes, opening them up to learning and growth. And more approachable, too—because we all goof up. 

Humility allows one to take constructive feedback without considering it a personal attack. It makes the workplace so much better and kinder.

Extending A Helping Hand To Others

Helping others is one of the best examples of practicing kindness.

It forces one to truly see their team members, go beyond the pigeonhole view of finishing one task after another.

A team wouldn't feel much like a team if nobody bothered to notice and extend a helping hand to those who needed it.

Here are some things you can do to make your colleagues feel cared for, looked after, and seen:

  • Offer to shoulder a part of their workload, or help streamline their process if someone seems swamped with tasks
  • Share ideas about creative tasks if you feel someone is feeling stuck 
  • Organize a mini-workshop or a casual skill-sharing session
  • Remind people to have food on time; bring them something from the canteen if deadlines keep them glued to the chair
  • Be adaptable in your collaboration approach

You may not be able to extend help during the rush-hour frenzies. But reaching out whenever you can is a good start.

Sharing Feedback And Recognition

When done simultaneously in a healthy balance, feedback and recognition foster kindness.

I don't mean feedback shared immaturely that shatters the receiver's confidence.

Feedback that is specific, kind, and coming from a space of helping others improve and grow.

That's what we practice here at Axelerant. When in doubt, people reach out to their coach to share feedback that adheres to a positive intention and our core values. 

And recognition should always be given in the open.

Sana praising team members

Self-Care And Introspection

Without self-care and introspection, even the kindest of people can become perfect monsters, making others' lives as miserable as theirs.

Being kind to others is tough when one isn't kind to themselves. 

It involves taking care of one's well-being. 

Keeping emotionally, mentally, and physically fit. Learning to manage stress and navigate life's complexities.

Everyone struggles with some aspects of life that make it harder to be kind to others. 

It could be sticking to a routine for someone, and being spontaneous for the other.

That's why self-care and kindness practice has to combine with introspection. If possible, daily. 

To realize where one stands with oneself and others in the kindness quotient. And change where it's needed.

Building Systems To Check Unkindness

A culture of kindness is hard to create and harder to maintain.

It demands effective, well-thought-out, and evolving systems to check unkind behaviors. 

To make this a reality, organizations should: 

  • Implement clear policies against hurtful behavior
  • Establish seamless conflict resolution mechanisms
  • Foster a culture intolerant of disrespect
  • Provide training and coaching for practicing kindness

And build in periodic check-ins to address concerns promptly. 

Start Your Kindness Journey Today

Work doesn't need to be a dreadful, prickly place packed with friction.

It can be energizing and rewarding when teammates practice kindness consciously. 

And a practice lies in action.

Start being kind to yourself and the people around you at work (and outside of it). Take one small step daily.

It's time we strive to create kinder workplaces—because everyone deserves kindness.

Apply at Axelerant by clicking here. We believe people grow better with kindness and support.
Feb 20 2024
Feb 20

Introduction

In August 2020, Citibank's lending operation made a huge digital banking error. 

Instead of the intended interest payment of $7.8 million, the complete sum of $900 million was sent due to a user interface blunder.  

This incident is one of Citibank's most significant digital banking mishaps, highlighting the importance of flawless user experience design and robust internal processes as the blunder resulted from a lapse in user interface design of the banking software, leading to an unintended transfer and later, legal issues.

Citibank fiasco

While bad design has several drawbacks like the Citibank fiasco, good design tends to deliver great business value. 

According to a Forrester research, investing in user experience delivers a 99% ROI for every $1 spent. The same research states that good UI can increase conversion rates by up to 200%, and good UX can double this — up to 400%. 

ROI of UX

The Business Benefits of Effective Design

An effective design offers several business benefits, ranging from enhanced brand perception and competitive advantage.

Enhanced Brand Perception And Recognition

Establishing an improved image for the brand helps elevate its perception and recognition by the target audience.

First Impressions Matter

Great designs create a positive first impression, shaping how customers perceive a brand, product, or service.

For example, Netflix utilizes original content production and personalized recommendations algorithms to create a highly addictive streaming experience.

  • The Netflix Logo: The simple red "N" logo is instantly recognizable and has become synonymous with streaming entertainment. Its minimalist design and bold color make it visually striking and easy to remember across various marketing materials and devices. This reinforces brand presence and strengthens recall among potential and existing subscribers.
  • The Ta-Dum Sound: The iconic "ta-dum" sound effect plays before every Netflix original program. It is used in trailers and marketing campaigns, creating a unique identity and reinforcing brand recognition.
  • Viewers-First Concept: The Netflix homepage provides a sense of home to users. The elements, such as - recommended movies and similar shows, continue watching, offer comfort, familiarity, and a sense of ownership over one's viewing experience. It positions Netflix as a platform for personal enjoyment and self-expression, fostering positive associations with the brand.
  • Netflix and Chill: This popular, unofficial slang term positions Netflix as a platform for leisure activities and social bonding, creating a sense of community and belonging.

[embedded content]

Trust And Loyalty Is The Key

Consistent and attractive design fosters trust and loyalty for customers. They tend to recognize and remember well-designed brands, creating emotional connections and encouraging repeat business.

Dropbox’s clean interface, focus on security, and user-friendly file sharing capabilities have made it a trusted cloud storage solution. Their design emphasizes ease of use and reliability, building confidence among users. 

Dropbox's interface provides a sense of order, facilitating user navigation and minimizing confusion. By prioritizing clarity, Dropbox cultivates user trust, as individuals are more likely to feel in control and understand platform operations. 

Intuitive interactions further contribute to user-friendliness, reducing the learning curve and encouraging confident engagement.

Another key trust-building feature is Dropbox's granular control over file sharing permissions, allowing users precise authority over access levels.  

The platform's commitment to security is transparently communicated, emphasizing encryption, two-factor authentication, and robust data privacy policies. Visual cues, such as icons highlighting security features, reinforce the commitment to user data protection, building trust through clear visual communication. 

The results are evident as Dropbox announced its First Quarter Revenue of $611.1 Million, up 8.7% year-over-year; on a constant currency basis, up 11.6% year-over-year showing the business value of the brand, aided by great design.

Dropbox Revenue

Premium Perception and Pricing

Well-designed products and services tend to attract a premium price. Customers tend to associate good design with higher quality and value and are willing to pay more for a superior experience. According to Adobe, 70% of customers say it’s very important for an organization to deliver a unified, seamless experience at any point of interaction.

Tesla’s sleek, minimalist vehicle design and futuristic interiors differentiate it from traditional car brands. Innovation like autopilot features and seamless charging infrastructure help the brand create a unique user experience. As of 2023, it is one of the leading brands in the USA.

Leading US Brands Worldwide 2023

Competitive Advantage And Market Differentiation

Brands can gain a strategic advantage by highlighting unique features through design.

Solving-Customer-Problems Solving Customer Problems

Design thinking, a core aspect of effective design, focuses on understanding user needs and challenges. By creating innovative solutions that address real problems, brands can gain a competitive edge and attract new customers.

Slack introduced a dynamic communication platform with interactive channels, emojis, and playful branding. Acquired by Salesforce for $27.7 billion, Slack is quickly becoming the go-to tool for workplace collaboration.

Here are some results from the brand’s first quarter fiscal report of 2022:

  • Total revenue of $273.4 million, up 36% year-over-year
  • Added over 13,000 net new Paid Customers, for a total of 169,000
  • Over 950,000 connected endpoints on Slack Connect, up 265% year-over-year

Microsoft Teams Vs Slack Active Users

Standing-Out-from-the-CrowdStanding Out from the Crowd

Effective design differentiates brands in a crowded marketplace. Unique and functional design elements make a brand memorable and increase recall among potential customers.

Duolingo provides gamified language learning with bite-sized lessons and a competitive spirit. A simple interface makes it a hit with the users. It comes as no surprise that during the third quarter of 2023, Duolingo had approximately 24.2 million daily active users. This was an increase of more than 63 percent year-over-year, as well as a quarterly growth of around 13 percent.


Duolingo-DAU

Integrating Design Within Organizations For Business Success

Building a design-centric culture isn't about building a design team and expecting miracles. It's about fostering a collaborative environment where design thinking takes the center stage. Here's how to integrate design for business success.

Cultivating-Design-AwarenessCultivating Design Awareness

Training and empowerment for all employees, not just designers.

  • Design Fundamentals Workshops: Offer interactive sessions across departments, demystifying design principles and their impact on business goals.
  • Empathy Breaks: Facilitate short, team-based activities where employees experience user challenges firsthand, building understanding and empathy.

Collaborative-SpiritCollaborative Spirit

Design is all about collaboration and not working in silos. 

  • Cross-Functional Design Teams: Integrate designers seamlessly into product development, marketing, and customer service teams for holistic problem-solving.
  • Design Perspectives: Gather diverse stakeholders for interactive brainstorm sessions, ensuring different perspectives contribute to design decisions.

Design-Led Product Development-1Design-Led Product Development

It is the user's needs, which should drive product direction, not the other way around.

  • Persona Development Workshops: Collaboratively build user profiles to understand their motivations, pain points, and decision-making processes.
  • Rapid Prototyping Sessions: Quickly create and test low-fidelity prototypes with real users, iterating based on their feedback.

Measuring Design Impact-1Measuring Design Impact

Demonstrate the ROI of design through tangible metrics.

  • Conversion Rate Optimization (CRO) A/B Testing: Experiment with different design elements on your website or app to identify what drives conversions.
  • Customer Satisfaction Surveys: Track how design changes impact user experience and brand perception.

By continuously fostering a culture of continuous learning, collaboration, and experimentation businesses can get the most value out of their design. 

How Axelerant Helped Optimize Conversion Personalized Red Hat’s Developer Portal

Axelerant collaborated with Red Hat to redesign their developer portal with the aim to offer an experience-based outlook and a brand new learning experience for developers. 

The Ask

  • Restructuring the information architecture of the website that works in favor of desired user journeys on the website
  • Creating a roadmap for the portal’s business objectives through design
  • Breaking the “free-software” outlook that Red Hat had carried among its developer audience so far

Our Approach

Our approach was backed by the Design Thinking and How Might We frameworks. This ensured that the portal would be able to solve the problems that users are seeking to solve. We divided our approach to the projects into three segments.

  1. Information Architecture & Navigation Redesign 
  2. Website Redesign 
  3. Usability Audit 

Results

With a new information architecture and navigation model in place, the Red Hat Developer portal is now able to offer a brand new learning experience for developers. It is better equipped to enable its users to track and make sense of their learning journey on the website. 

By personalizing all possible touch-points, Red Hat’s developer portal now offers enhanced user experience and keeps its users engaged. Older experience had too many options in terms of learning resources. Too much, unstructured cognitive load.

Learn more about the importance of business value of design by connecting with our team.

Feb 20 2024
Feb 20

Agiledrop is highlighting active Drupal community members and interesting projects through a series of interviews. In this one, we spoke with Henk Beld, Solutions Architect at the web hosting company amazee.io of which Agiledrop is also a proud partner. He shared his journey of discovering Drupal and its vibrant community, as well as some important thoughts on the best path forward for the Drupal project.

1. Please tell us a little about yourself. How do you participate in the Drupal community, and what do you do professionally?

I have worked with Drupal since 2009 and helped organize DrupalJam in the Netherlands for two years. I have always promoted using Drupal and open source software throughout my career. As of the 1st of January this year, I am a Dutch Drupal Association board member. I currently work as a Solutions Architect at amazee.io, solving our customers' more complex hosting needs.

2. When did you first come across Drupal? What convinced you to stay, the software or the community, and why?

I came across Drupal in 2009 while working at a DIY product wholesaler with 300+ stores. Back then, they had Sitecore, but that needed to be updated, and after evaluating many CMS systems, I chose Drupal. We had a small team with a limited budget, and Drupal was the CMS that checked most of the boxes and had a wide variety of available modules.

We built all the new sites with available modules with limited to no customization. Ultimately, there was a corporate website and intranet, and every store had its own landing page with custom information. In the last year I worked with that company, we started publishing products and working towards e-commerce. I’m happy to say that they still use Drupal.

Overall, I liked Drupal, and because of that, I went to many DrupalCons and other meetups and made many friends in the community.

3. What impact has Drupal made on you? Is there a particular moment, e.g. from a Drupal event, which has really stuck with you?

Drupal has greatly impacted my life, and I get to work and have fun with amazing people working on great projects at notable global companies. I’ve been to places worldwide that I would not have seen without Drupal. It all started with DrupalCon Copenhagen, but it really kicked off at DrupalCon Prague in 2013, where I applied at Acquia, ending up in the enterprise world of Drupal.

4. How have you seen Drupal evolve over the years? What do you think the future holds for Drupal?

I have been out of the developer side of things for quite a while. Still, Drupal has evolved massively over the years in a good way, especially from version 8 up with the adoption of the Symfony Framework, Mobile & Multilingual, and API first.

The headless trend will progress, but integration of emerging technologies will also be necessary. I recently came across Sylius, an interesting open source e-commerce framework built on Symfony where both Drupal and Sylius could serve a headless frontend.

5. Why is Drupal such a great platform for enterprise?

Drupal stands out as an exceptional platform for large enterprises due to its comprehensive range of features tailored to meet complex needs. Its multilingual and multisite capabilities are indispensable for organizations operating across multiple countries, enabling seamless support for various languages. 

Its modular and highly customizable architecture offers unparalleled flexibility to tailor the site according to specific enterprise requirements. Also, the Drupal API-first approach facilitates smooth integration with various third-party applications and enterprise systems, including CRM, ERP, and marketing tools, streamlining operations and enhancing functionality.

Regarding scalability and performance, Drupal is designed to effortlessly manage high-traffic environments and large data volumes, ensuring enterprise websites remain efficient and scalable. 

The introduction of cache tagging in later versions further enhances performance by allowing targeted cache flushing for specific content updates. Security is another cornerstone of Drupal, featuring robust security measures backed by a dedicated security team and a community-focused approach to address vulnerabilities promptly.

6. What are the projects and initiatives within Drupal that you are most excited about and would like to highlight or promote?

While my current role has evolved beyond hands-on development, my engagement with the industry allows me to stay informed about key trends. One notable trend is the growing emphasis on decoupled Drupal architectures. Drupal is just great as a robust content management backend, offering comprehensive out-of-the-box features that perfectly fit as a backend for frontend technologies like React and Angular. This synergy enables developers to create dynamic, user-centric web experiences.

Another critical area of focus is the migration and upgrade path for existing Drupal sites, especially those still on Drupal 7. The availability of sophisticated tools and streamlined processes for migrating to newer versions of Drupal, such as 8, 9, and 10, is a game changer. Tools like that take care of a smoother transition for site owners and reinforce their commitment to Drupal by offering a clear, manageable pathway to leverage the latest technological advancements without the need to switch to alternative content management systems.

But as also highlighted at DrupalCon Lille, investing in Marketing initiatives will be very important! For instance, I see enterprises switching to Adobe Experience Manager more and more. I think Drupal should look more at collaborating with other open source projects, where possible, to strengthen its position in the broader tech landscape.

7. Beyond Drupal, what are you excited about this year? Either a new technology or a personal endeavor.

I’m looking forward to seeing what the year brings from a work perspective! With the massive focus on AI/LLM in 2023 and all the tools, I am curious about what will filter out in 2024. I see many more prominent companies starting to look into using AI/LLM in their company. One of those is also data sovereignty. I see companies are really prioritizing how to keep their data secure.

I recently attended and volunteered at State of Open Con in London. I saw the impact of open source around the globe on AI development, for example, and also heard about the challenges around legislation and open source. I really recommend listening to the event’s informative keynote, “The Open Society and its Enemies” by Professor Neil Lawrence.

On the personal side, I am close to finishing the long renovation project of our house and barn, intending to have an excellent workspace and all the energy requirements running on solar panels. I had a five-year plan, and it looks like I can just make it :)

Feb 19 2024
Feb 19

Today we are talking about CKEditor 4 End of Life, Moving to CKEditor 5, and what you can expect from CKEditor 5 now and in the future with guest Wim Leers. We’ll also cover CKEditor 5 Premium Features as our module of the week.

For show notes visit:
www.talkingDrupal.com/438

Topics

  • CKEditor 4 end of life June 2023
  • Issues people might see if they are still on CKE4
  • Why a third party library and not roll our own
  • Are there other alternatives
  • Why did Drupal decide on CKEditor
  • Drupal 10 moved to CKE5 How should people update
  • Upgrade gotchas
  • What's new in CKE5
  • What is on the roadmap regarding Drupal and CKE5
  • Is there going to be a CKE6
  • Native Web Components
  • Does CKE in core affect Gutenberg

Resources

  • CKEditor 4 End Of Life
  • Drastically improve the linking experience in CKEditor 5
  • Drupal Image ability to opt in to SVG image uploads
  • Native
      and

      Guests

      Wim Leers - wimleers.com Wim Leers

      Hosts

      Nic Laflin - nLighteneddevelopment.com nicxvan
      John Picozzi - epam.com johnpicozzi
      Ivan Stegic - ten7.com ivanstegic

      MOTW

      Correspondent

      Martin Anderson-Clutz - mandclu

    • Brief description:
      • Have you ever wanted to offer your content creators advanced capabilities like real-time collaboration? There’s a module for that.
    • Module name/project name:
    • Brief history
      • How old: created in Sep 2022 by Wiktor Walc, although recent releases are by Wojciech (vOYchekh) Kukowski, both of CKSource, the company behind CKEditor (Wiktor was on episode 372 https://talkingdrupal.com/372)
      • Current version available: 1.2.5 which works with Drupal 9 and 10
    • Maintainership
      • Actively maintained, latest release in the past month
      • User Guide available, link is in the README
      • Number of open issues: 16, 8 of which are bugs
    • Usage stats:
    • Module features and usage
      • To me, the most compelling features enabled by this module are the ones that turn your Drupal WYSIWYG into a robust collaboration tool, similar to what users may be used to in tools like Google Docs or Office 365
      • Real-time inline comments and changes from multiple users
      • Track changes to suggest ways the content could be improved
      • A history of changes made in the WYSIWYG, independent of the saved Drupal revisions
      • Tag users with @ mentions to have them notified
      • There’s also a Productivity Pack to enhance your WYSIWYG, and again some of these will be familiar to users that also use popular online collaboration tools
      • A document outline that uses heading within your content to make navigation for moving quickly within the document
      • Can generate a linked Table of Contents, which will automatically update as headings are added or changed
      • Slash commands to execute actions
      • Enhanced Paste from Office, to preserve complex incoming content structures, but with clean HTML as the result
      • And more!
      • Another premium feature is the ability to export to Word or PDF, and it can also restore full screen editing, a feature that didn’t make the transition from CKEditor 4 to 5, as part of the open source offering
      • Finally, it also includes an AI Assistant that provides yet another interesting way to empower your content authors to leverage AI tools for their writing, including the ability to change the style, length, or tone of selected content using pre-made prompts, or generate content with custom queries. It also works with a number of different models out of the box, so you’re not restricted to ChatGPT
      • The module is open source but using these premium features does require a subscription. The pricing will depend on the number of active users and which features you need, so if you’d like more information you can use the contact form at ckeditor.com
      • Also worth mentioning here that the team at Palantir has released a YouTube video of an open source collaborative editor that they’re calling Edit Together. It’s based on the ProseMirror rich-text editor framework, and the blog where they announced it mentioned a mid-2024 release, but that was back in Jul 2023 and I haven’t been able to find any updates since then
Feb 17 2024
Feb 17

For the example we are going to implement an area that will present some links and text in a custom way, not sure if it's really usefull, but that not the point of this article.

The Plugin system

For the first post on the plugins I will introduce briefly on the concept. For those that already been using Ctools plugins system, you already now about the plugin system purposes.

For those who doesn't know about it, the plugin system is a way to let other module implements her own use case for an existing features, think of Field formatter : provide your own render array for a particular field display, or Widget : provide your own form element for a particular field type, etc...

The plugin system has three base elements :

Plugin Types

The plugin type is the central controlling class that defines how the plugins of this type will be discovered and instantiated. The type will describe the central purpose of all plugins of that type; e.g. cache backends, image actions, blocks, etc.

Plugin Discovery

Plugin Discovery is the process of finding plugins within the available code base that qualify for use within this particular plugin type's use case.

Plugin Factory

The Factory is responsible for instantiating the specific plugin(s) chosen for a given use case.

Detailled informations : https://www.drupal.org/node/1637730

In our case Views is responsible of that implementations so we are not going further on that, let see now how to implement a plugin definition.

The Plugin definitions

The existing documentation on the plugin definitions are a little abstract for now to understand how it really works (https://www.drupal.org/node/1653532).

You have to understand simply that a Plugin in most case is a Class implementation, namespaced within the namespace of the plugin type, in our example this is : \Drupal\module_name\Plugin\views\area

So if I implement a custom views area Plugin in my module the class will be located under the location module_name/src/Plugin/views/area/MyAreaHandler.php

To know where to implement a plugin definition for a plugin type, you can in most case look at module docs, or directly in the source code of the module (looking at an example of a definition will be enough)

In most cases, the modules that implement a Plugin type will provide a base class for the plugins definitions, in our example views area provide a base class : \Drupal\views\Plugin\views\area\AreaPluginBase

Drupal provide also a base class, if you implement a custom Plugin type, for the Plugin definition : \Drupal\Component\Plugin\PluginBase

Your custom plugin definition class must also have annotation metadata, that is defined by the module that implement the plugin type, in our example : \Drupal\views\Annotation\ViewsArea

In the case of views you will also need to implement the hook_views_data() into module_name.views.inc file, there you will inform views about the name and metadata of your Area handler.

Hands on implementation

So we have a custom module let's call it module_name for the example :)

We will create the class that implements our plugin definition and we are gonna give it this Plugin ID : my_custom_site_area.

We save this file into module_name/src/Plugin/views/area/MyCustomSiteArea.php

Now we just have to implements the hook_views_data() and yes this is the end, you can use your awesome views area handler into any view and any area.

Define this hook into the file : module_name/module_name.views.inc

Feb 16 2024
Feb 16

Crafting the digital landscape has never been more intuitive than with Drupal's Entity API. Developers wield the power to forge bespoke content types and intricately weave data relationships for these types, all effortlessly. 
This is not just a system; it has a lot of capabilities and a comprehensive API that makes the art of form creation, data validation, configuration, and even the orchestration of routes. The web realm becomes a canvas for innovation, and Drupal stands as the master artist's palette, inviting exceptional content and curating unparalleled web experiences. 
For enterprises seeking the zenith of scalability, adaptability, and impregnable security, Drupal stands tall, its architecture a bastion of strength, integration as seamless as an artist's brushstroke. Ready to embark on your digital odyssey with us, the Golems team

What is Drupal entity API?

In order to provide a single approach for handling entities and their properties, Entity API is extending Drupal's core. In addition, it gives a CRUD controller that enables the creation of new types of entities more easily.
Additionally, the CRUD (create, show, update, delete) controller makes it possible to detect and repair errors swiftly. Developers prefer Drupal's Entity API because: 

  • The system provides structured data management and categorizes various types of information (articles, products, users, etc.)
  • Flexible in content customization. Developers have the opportunity to create specific fields and properties. 
  • Consistent programming interface. Drupal's Entity API allows interacting with various types of entities easily 
  • Entity relationships and connections. Entity API can establish relationships between different users, nodes, and taxonomy terms. 
  • Language variety. Drupal's Entity API has multilingual support, which is why developers have tools to translate and publish websites that are easily understandable for users worldwide.
  • Theming. The system is designed to be comfortable for developers, so it has a customizable interface and various themes. The developer has a lot of control over the appearance of content on a website.

Key types of entities available in Drupal

Entity API entity is a data unit (similar to object-oriented programming). Each of them has its own properties and set of fields. The main types of entities are:

  • Nodes. This type represents content items (articles, blog posts, pages)
  • Users. Those are individuals who interact with websites and their content. Users have certain traits: “roles,” and “permissions” to customize and determine access to a website and its parts.
  • Taxonomy terms. Tools to categorize and structure website content.
  • Custom entities. Developers can create entities with different properties that don`t belong to nodes, users, or taxonomy terms. 

5 useful Drupal Modules to Expose Your API

1. Drupal 8/9 Core Web Services (RESTful Web Services)
This module allows the use of RESTful resources and configures which content types are exposed. This module supports customization of output format (JSON, XML) and controls access to them.
2. JSON: API
This is a powerful module for creating API on Drupal 8 and later. The main feature is exposing entities as JSON data following specifications. The main advantage of this feature is a more structured approach to API creation.
3. Services 
This module is available from the Drupal 7 version. The main feature is exposing data types (REST, XML-RPC, JSON, etc.). Custom endpoints and controlled access are also included in this module.
4. GraphQL 
The module exposes GraphQL (as query language). Using query language gives the opportunity to reach and request needed data. GraphQL heavily improves data control and manipulation in terms of website development.
5. RESTful Web Services 
It includes RESTful services and additional functions such as data exposure using classic HTTP methods like GET, POST, PUT, and DELETE, resource configuration, additional output formats, and hooks.

Leveraging Entity API for Site Development

Drupal's Entity API includes a CRUD controller, which simplifies the querying of databases for each website. The advantage of using this featuIt'sIt's Core is that you're not dependent on additional investment modules. This is easy to handle programmatically, while views are a little tricky to handle in code. We haven't done any performance measurements, but EFQ is simpler than View. We consider it will have better performance overall.
You can make arbitrary connections and collect almost any kind of data. It is also relatively easy to expose new data to the View. There's a module to do it. It has a user interface and is much more user-friendly than doing everything in code.

Top Tips for Efficient Entity Querying

Queries are an essential part of any website development and performance plan. This feature increases usability and makes it easier to create complex queries. Using the Drupal Entity Query API, developers can efficiently structure query entities such as nodes, users, and taxonomy terms. Developers can optimize queries to ensure that users receive website content promptly. 
1. Using an entity loader 
Entities bundling can reduce the number of database queries compared to loading individual entities (e.g., using node_load() or user_load()). 
2. Specifying only required fields 
It reduces the data retrieved and facilitates development by identifying only required fields (using the fieldCondition() special method).
3. Caching
Use Drupal's built-in caching features to store and retrieve query results without re-accessing them.
4. Referential Optimization 
Filtering data by reference fields is very efficient using the entityCondition() method. This feature reduces the need for unused tables and generally improves query performance.
5. Avoid using too many compounds
Too many connections can negatively affect performance and cause the system to run slowly. Therefore, limiting the number of JOINs to what is needed for efficient queries is very important.
6. Use indexes
Developers should index all queries in the central database. For extensive databases, indexes can significantly speed up data retrieval.
7. Drupal is frequently updated and optimized 
New versions often include features that improve query performance. It's also good to keep an eye on new module releases as they can improve overall performance.

Conclusion

Gain more from Drupal's Entity API. Today, Drupal specialists briefly described the main tips to create a more robust and effective website, whether developing custom content, improving queries, or adjusting entity relationships.
In addition to modules, developers can use querying tips to improve and make more efficient databases for websites. 
Key takeaways of Drupal's Entity API:

  • Structured data management, which allows to put less time and effort to create and manage databases
  • Content customization and comfortable interface. Entity API is convenient for both the developer and the user
  • Queries efficiency
  • Flexibility 

We encourage you to put your newly acquired knowledge to use. Try out the Entity API, put the optimization methods to use, and watch how your Drupal projects improve. Do you have a query or a triumphant tale to share? Please feel free to remark below. Let's continue the discussion and work together to harness Drupal's Entity API's power to build outstanding web experiences.

Feb 16 2024
Feb 16

The Drupal Association announced in June 2023 that support for Drupal 7 has been extended for an additional 15 months from November 2023 to January 2025. While this is welcome news for many IT departments that were scrambling to move off of Drupal 7 by November, it isn’t the reprieve that it first appears to be. 

It’s important to recognize that delaying the decision to upgrade to Drupal 7 could have a very real and negative impact on your organization. At the top of this list is security. When the Drupal Association announced that Drupal 7’s end of life was being extended a final time, it also announced that support for Drupal 7 after August 1, 2023 would change in significant ways. Read this article to learn about the top ways security will be impacted by staying on Drupal 7. 

Changes to Security Updates for Drupal 7

Not all security issues will be addressed proactively with a security update release the same day an issue is announced. The Drupal Security Team may choose to not fix some moderately and less critical issues rather than report them to the public issue queue for the community to address. Without a patch or update to fix the issue, this can cause vulnerabilities to become publicly known. This, in turn, makes it easier for a site to be hacked or defaced, its users exploited, or their data to be compromised.  

Module Implications

After August 1, 2023, the modules used to build and maintain Drupal 7 may no longer receive updates. Modules may be flagged as insecure or unsupported if the module maintainers have not sufficiently responded to requests of the Drupal Security Team. If this happens, the module will not be unflagged or marked as secure/supported ever again.

Say Goodbye to Some Security Advisories

Another security risk with Drupal 7 is that the security team will no longer issue security advisories alerting Drupal 7 site managers about security issues with unsupported libraries that are used by many Drupal 7 sites. This means that a library you are using, such as CKEditor 4, may have a security issue and it would be up to you to determine if your site is impacted and to fix the issue. 

Security Shouldn’t be a “Hope for the Best” Scenario

With these changes to the security coverage for Drupal 7, site administrators will need to be more vigilant than before when it comes to securing their sites. Drupal 7 site owners are advised to keep a close watch on the Drupal Security Advisories page and the Drupal 7 Core issue queue for items that may impact their site’s health, security, and reputation. When an issue appears that needs to be addressed, businesses may not have the luxury to wait for a fix to be produced. Be prepared to fix issues that may arise if a security patch isn’t immediately available for Drupal 7. When site security is on the line, one cannot hope for the best.

Ensure Security With Drupal 10

Security issues alone should be motivation to proceed with the migration to Drupal 10. Upgrade to Drupal 10 today to ensure the security and longevity of your website. While Drupal 7’s end-of-life has been extended, it’s crucial to understand that relying on an outdated CMS version can pose serious risks to your organization. With limited proactive security updates and the potential for unsupported modules and libraries, delaying the upgrade could leave your site vulnerable to hacking and data breaches. 

Take the leap to Drupal 10 and embrace a modern, secure, and feature-rich platform that aligns with current technology trends. For more information on Drupal 7 and the features you may be missing out on, check out this article

Feb 16 2024
Feb 16

Many organizations depend on Drupal to build digital ecosystems. As a powerful content management system (CMS), it works well as one of the cornerstones of a composable architecture—but it can also function as its own standalone composable architecture. A composable approach has several benefits, including making it easier and more efficient to build out new channels (e.g., new websites or landing pages). It also empowers the business— especially the marketing team—to create and deliver content to customers where and when it is needed. This frees up developers to work on projects that deliver the most value. 

Here, we outline some of the best practices to build out a digital ecosystem using Drupal.

Tips to Build Reusable Front-End Components 

Using a tool like Drupal means that companies will benefit from the experiences and recommendations from the broader Drupal community, as ideas are shared and discussed widely. With our own clients and contributions to the Drupal community, as well as considering the enterprise tools available, we’ve identified a number of recurring practices that can help make this process easier.

Use Layout Builder to Create Reusable Components

To build new channels efficiently, composable approaches seek to move building pages and channels out of the developers’ hands and into the marketers’ hands. A great way to do this is to build flexible, reusable front-end components. Drupal is well-equipped in this area. Layout Builder has been part of Drupal core since Drupal 8, and the Drupal community continues to add features and refine the experience to enable ambitious site builders. 

Layout Builder allows developers to build components and templates that give marketers greater flexibility to build pages without the need for developer intervention. If a new landing page is needed, a content editor can quickly assemble the page from the reusable components and get it published quickly. 

Provide an Enterprise-Grade UX with Acquia Site Studio

While Layout Builder is a great choice for building out reusable components, Acquia Site Studio provides an enterprise-grade user experience, which makes it even better. With Site Studio, marketers can not only build out new content using reusable components and templates, they can update styling to the components as well. Site Studio makes it efficient for developers by providing a user interface (UI) kit that includes components and helpers to get the build started. Acquia Site Studio makes building reusable components a breeze.

Create Efficient Development Processes with CI/CD

Building reusable components is an important aspect of a composable approach, but it is also important to have an efficient development process. A key component to having an efficient development process is creating a continuous integration/continuous delivery (CI/CD) pipeline. CI/CD pipelines make the development process efficient by automatically enforcing coding standards, testing the new code to ensure quality, and creating deployment artifacts so the code is always ready to be deployed. 

It has never been easier to create a CI/CD pipeline. All the major cloud-based source code version control providers offer tools to make doing so very easy. Once the CI/CD pipeline is built out, the process is automatically kicked off when a developer commits a change to the code base. If the process detects any issues, the developer gets immediate feedback and can fix those issues. All this automation makes the development process quicker so if there is a new feature or an enhancement to an existing feature that is needed, the development team can deliver it quickly. 

Use Composer to Manage Drupal and Dependencies

Another key component to an efficient development process for Drupal projects is using Composer to manage Drupal and all other dependencies, like libraries, modules, and themes and their dependencies. Using Composer makes it easy to ensure all the needed dependencies are installed and ensures that all developers are using the exact same version of all the libraries, modules, and themes. This helps prevent issues where it works in one developer’s environment, but not in another developer’s environment. 

Simplify the Development Process with Acquia Code Studio

Acquia has developed tools such as Acquia Code Studio that help developers create an efficient development process. Code Studio includes everything needed to have an efficient development process from a zero-configuration CI/CD pipeline to automatically created feature branches to easy to create merge requests and more. In partnership with GitLab, Code Studio helps keep the development tasks on target from feature request through production deployment. Acquia has done all the heavy lifting to build out a solid, efficient development process so you don’t need to.

Isolate Your Business Logic 

Another idea to keep in mind when using Drupal as a composable solution is that business logic should be isolated as much as possible. Business logic in this sense means not only the code needed to implement business processes, but also any data mapping needed to integrate with other platforms. In a truly composable architecture, business logic would be built in the orchestration layer to keep the ecosystem front-end and back-end agnostic. With composable Drupal, Drupal acts as the orchestration layer, but that does not mean the business logic should go just anywhere. 

Whether you are implementing a traditional Drupal theme or using Drupal as a headless CMS, the business logic should be out of the theme layer. With a traditional Drupal theme, a good indication that you kept business logic out of the theme is if you can create a drop-in replacement for your theme. Whether you use a traditional Drupal theme or a headless implementation, the code should be narrowly focused on presentation. 

Any business logic that is needed should be isolated to and grouped in custom modules. The more centralized the business logic is kept, the easier it will be to update or replace various parts of the system, like platform integrations, in the future. 

Future-Prep Your System

Often developers will talk about future-proofing what they are building. However, the future is hard to predict. (Any developer that has been asked for an estimation knows this to be true.) Without being able to predict the future, we cannot future-proof our system. We can, however, future-prep our system. 

Isolating the business logic is a great example of future-prepping. By isolating the business logic, companies can minimize the disruption in the system as changes are inevitably needed. Marketing teams may not have a need for an email marketing system, but that could easily change in the future. Building a system that can efficiently adapt to ever-changing business needs can give you an edge.

One of the attributes that I like about the Acquia Platform is that it is both built to be open, yet is also well-integrated. Because of the open nature of both Drupal and Acquia, you can build a best-of-breed system. And, if you already have a platform that is working well, it can easily be integrated into a Drupal-based solution built on Acquia. But, if as your needs grow, you find yourself needing to do more with customer data or need additional help managing your digital assets, Acquia has products like CDP and PIM that can be easily plugged into your existing platform. In short, Acquia’s products make it easy to grow at your pace.

Empowering Organizational Agility through Composable Architecture with Drupal

A composable architecture provides organizations with the agility to react to their ever-changing business challenges. Using Drupal as a composable platform can help you achieve that agility. The key is to put the power to freely create new content and channels in the hands of marketers—so that developers can focus on building more tools that deliver value and make the process of development reliable and efficient. 
 

Feb 16 2024
Feb 16

At DrupalCon North America in June 2023, the Drupal Association announced that support for Drupal 7 has been extended for an additional 15 months from November 2023 to January 2025. However, if your website and digital experience platform is important to your company’s objectives to compete and win digitally, do not wait to migrate. 

Drupal 7 will be 14 years old when it is finally retired in January 2025. Over the past 14 years, web trends have changed dramatically. Drupal 7 did receive some small enhancements over time, but no major core features were released in Drupal 7’s lifetime. This means that Drupal 7 has been a functional relic since Drupal 8’s release in November 2015! If your organization is using Drupal 7, you are missing out on many innovations that have been added into Drupal since that time. Here, we outline some of the features that modern Drupal has to offer.  

Flexible and Modular Architecture Approach

Drupal is now highly flexible and can be customized to meet the specific needs of an enterprise. It offers a modular architecture approach that allows for the integration of external systems as well as adding new features specific to the business’s needs. Drupal can scale to handle high traffic volumes and large amounts of content, making it suitable for enterprise-level projects.

Effortless Integration

Most people see Drupal as simply a content management system (CMS), but in fact, it also offers powerful marketing capabilities. Drupal 10 integrates effortlessly with services to provide functionality like segmentation, personalization, A/B testing, marketing automation, and analytics. When functioning as a core component of your digital experience platform, Drupal can easily tailor marketing campaigns, deliver targeted content, and measure the metrics that matter to engage the audiences you are seeking.

Multichannel Capabilities

Drupal 10 enables marketing departments to deliver consistent and engaging digital experiences across multiple channels, not just web. Drupal’s multi-channel capabilities allow businesses to seamlessly deliver content to websites, mobile apps, social platforms, IoT devices, and more. This empowers them to reach audiences with the right message at the right moment. While all of this is possible with Drupal 7, it is cumbersome to implement and maintain.

Strong Search Engine Optimization 

Drupal 10 has features that contribute to strong search engine optimization (SEO). It provides clean HTML 5, semantic markup, and URL structures that can positively impact search rankings. Drupal also offers essential SEO modules such as XML sitemap generation, meta tag management, and redirects, which elevates site visibility in search engines.

Efficiently Manage Complex Content Ecosystems

Drupal excels as a CMS, providing powerful tools for creating, organizing, and publishing content. It offers a user-friendly interface, advanced workflow management, version control, and multilingual capabilities. These features enable enterprises to efficiently manage complex content ecosystems across multiple channels and touchpoints.

With Drupal 10, web teams can create and deliver custom content quicker and easier than ever. Current versions of Drupal embrace new technologies and trends in the digital space. It evolves with the industry, regularly releasing updates and new versions that incorporate the latest innovations. This ensures that enterprises using Drupal can stay ahead and take advantage of emerging technologies and best practices. 

Easy Security Updates 

Rather than jumping through hoops to implement security updates in Drupal 7, developers can run a single command to implement security updates for your site. This reduces the effort to update the site to keep bad actors at bay.   

The ease of updates with Drupal 10 even goes beyond security updates. When Drupal core and contributed modules are updated with new features or bug fixes, they are available to your site using the same command. Starting with Drupal 8 and continuing into Drupal 10, the system uses Composer to manage package and library dependencies. This takes the guesswork out of knowing what underlying code is needed to make your site operate. Learn more about how Composer makes your site more secure and your developers’ lives easier. 

Upgrade to Drupal 10 Today

Organizations still using Drupal 7 are missing out on the flexibility, customization options, scalability, and marketing capabilities available in the newer versions. Drupal 10 allows for the management of consistent and engaging digital experiences across various channels, enhances search engine optimization, and enables web teams to deliver content more efficiently. Interested in learning more about the features and benefits of Drupal 10? Check out this article

Feb 16 2024
Feb 16

Organizations with established workflows and data oversight protocols typically have firm opinions on how those processes should work, look and feel. Replatforming a website or application to Drupal 10 is an exciting opportunity to rethink aspects of your process and business logic, but sometimes you want to just go with what you know.

In a recent project, Bounteous helped a client replatform several sites. In these older platforms, page content was built URL by URL, subjected to a three-step approval process, and promoted to the live site. The client’s expectation was that every page—and more importantly, every asset on that page—would be individually reviewed and approved. 

But how does one moderate embedded assets or shared content in Drupal? Items such as media entities and custom block content can be configured to use a content moderation workflow, but the process is independent of the page nodes on which they’re placed. Client stakeholders—site users responsible for reviewing and approving site content—don’t care about Drupal’s data models or reusable content strategies. Stakeholders want to experience their new or updated content exactly as the end user will.

This is a perfectly reasonable expectation, and it aligns with one of Bounteous’ guiding principles: Quality Assurance testing is a proxy for the customers’ experience: test from the end-user’s perspective. Drupal is a magical Swiss army knife, kept polished and sharp by a robust open source community, so with a bit of clever development and care we can meet this expectation. Improvements in Drupal 10 make this effort even easier going forward.

Basic Workflow Setup

Workflows became part of core in 8.9.x. Within a workflow configuration, one can create moderation states, create transitions between those states, enable Content Moderation Notification and create email rules to be triggered by those transitions.

image

The notification emails may include tokens relative to the content entity being transitioned from moderation state to state. If our entity is intended to be viewed as an independent page, with a URL, then we can include a link to “/node/XXX/latest” and “please review here” in our notification email to our stakeholder.

If the content being moderated is a shared content type, designed to be embedded and viewed in a different page, we would use a different token: we use business logic and entity query results (inspired in part by contrib module Entity Usage) to discover and render links to every URL on which this shared content is found. This shared content may be media entities, custom block content, and even node content in a View.

image

The stakeholder visits and reviews the updated content in situ—the context in which the end user will experience the content. To ensure that end users do not see these updates until approved and published, we use revision-handling techniques in our render cycle that, thanks to some newly merged work in Drupal 10, are now more standardized.

D10 Enhancements

An entity, with apologies to Gertrude Stein, is an entity is an entity, yes?  Entity API allows us to treat custom blocks, media, and taxonomies as if they were nodes – fieldable, translatable, and revisionable.  True, but the methods for handling revisions developed at different rates, and are not uniform from type to type. A patchwork of patches and contrib modules (Media Revisions UI, Block Content Revision UI) had sprung up to handle gaps and inconsistencies.

The road from patch to merge for a standardized revision UI was long and twisty and included assists, encouragement, and reviews from some of Bounteous’ own. The machine name of the revision message text field in media entities is revision_log_message, while it is revision_log for nodes and blocks. But today, developers creating their own specific workflow solutions will have a consistent set of methods they can use to get and compare revision ids. Less time on patches and workarounds means more time focusing on their specific challenges.

image

Media

Suppose we have a media entity with a URL alias of “/download-this-month-data” and a file named “/doc/month_01.xls” in a field. A content editor will create a new draft revision, upload a file named “/doc/month_02.xls” into the field, and save this revision as “Ready for Review.” Our stakeholder is sent a notification and asked to review this change on the homepage where we have a “Call To Action” linking to “/download-this-month-data”.

How can we ensure that, when clicking the link, our stakeholder user downloads “month_02.xls” for review, while our customers, our anonymous users, continue to receive “month_01.xls” until the update is published? 

We created a RouteSubscriber that would send ‘entity.media.canonical’ type requests to a custom controller. Our controller checks for revisions and permissions. 

image

If there is a revision more recent than the default revision and if the user has appropriate permissions, then we load that specific revision. The controller writes a new DocumentResponse directly to the file attached to that revision, including appropriate caching and headers. This nifty work was inspired by Media Alias Display.

Blocks

Suppose a custom block of content has a new draft revision with updated text. For any user visiting a page with that block, the default revision will (by default) be rendered. How do we render that latest revision for an authenticated user?  With an old-school hook_alter().

We’re interested in user-generated content blocks as opposed to non-moderated, system-generated menu- or webform- blocks, so we implement hook_block_view_BLOCK_BASE_ID_alter() with BLOCK_BASE_ID = “custom_block”. Again, we check for revisions and permissions.

image

If we need to override the default block render with the latest revision, we add a pre_render callback to the block render array. The callback function loads the latest block revision, renders the block and overwrites the render array’s content key with the new markup.

Views

Suppose we have a node type that does not have an individual detail view, it is only ever rendered as a listing in a view. When we create a revision for review, we do not want to send the stakeholder to “/node/N/latest”, we want them to review the updates on the view page.

image

We ensure all the appropriate views were built using Content revisions in the Views UI. The sets node_revision as the base table and builds in all the necessary table JOINs. We implement a custom filter plugin that adds a where clause to the query() method, depending on user’s permissions.

image

When configured to return revisions, Views UI only allows you to Show: Fields under Formatting. Fortunately, you do still have the option under Fields to render the entire entity using a view mode. Note that this requires a patch which only a PHP unit test away from the finish line. Finally, we add an unpublished_flag class to the row container field in hook_preprocess_views_view_fields() if the row’s entity is not the default revision. 

image

The fun is multiplied when considering entities which themselves reference other entities. For instance, a block of content is placed on a page in a paragraph entity with a Block Field instance. That block_content entity itself references another page node or media entity. Data from that second node or media entity is what we ultimately render on the page as a tile, but we flag that tile (to authenticated users) as unpublished if either the custom block entity OR the referenced entity are unpublished.

Front End Rendering

When we render these entities with unpublished flags, we add a CSS class that signifies to our stakeholder the block or view listing is showing updated or unpublished information. This can be in the form of a colored border or background or overlay. 

Another class can implement a floating overlay that offers links to directly update the moderation status of the entity, leveraging implementation of contrib module Content Moderation Link. We recommend enhancing the user experience by inserting modal forms into the process, giving the stakeholder the opportunity to add custom messaging in the Revision Log field, and offering a conditional confirmation page, reiterating that publishing a change to this shared entity will affect pages X, Y, and Z.

Bounteous created custom solutions for most of this work, but we note several interesting modules in the community that are following similar paths, such as Moderation Note, and Content Moderation Info Block

There are so many content types with so many points of entry to create solutions. Because of this, the continued standardization of an entity-agnostic set of tools for revision handling is a welcome enhancement. When creating a robust workflow process for your site-builders, remember to treat stakeholder users as the distinct population they are. Address their specific needs and empower them to keep site content correct, timely and safe.

Feb 16 2024
Feb 16

Businesses need to react quickly to changes and the wants and needs of their customers. While this has always been true, it has become increasingly evident since the COVID-19 pandemic hit and the disruption to businesses was massive. Overnight, brick-and-mortar businesses were forced to build or expand their digital footprint. The companies that had built their digital infrastructure with modular and open platforms had a huge advantage over their competitors.

One of the latest trends in the digital experience space is composable architecture. Using a composable architecture provides organizations with the ability to add new channels and add or replace digital capabilities quickly. The speed, agility, and flexibility that composable architectures provide better prepare organizations to adapt to changing technological and consumer trends.   

What is Composable Architecture?

A composable architecture is one that uses a modular approach that effectively separates the digital experience channels (e.g. website, mobile app, digital signage) from the back end platforms (e.g. Commerce, CMS, Search). Two of the key principles of composable architectures are: composable architectures are front-end agnostic and composable architectures are back-end agnostic. Being front-end agnostic allows a composable architecture to be omni-channel. Being back-end agnostic allows a composable architecture to be omni-capable. These two principles are the key to the flexibility provided by a composable architecture.

To achieve those two principles, an orchestration layer is used to separate the front-ends from the back-ends. The orchestration layer is responsible for integrating with the back-end systems, applying business logic and processes, and providing an interface to provide the data and content to the front-end applications. To satisfy those responsibilities, the orchestration layer is built using packaged business capabilities (PBCs). PBCs allow the data and content to be retrieved from the back-end systems, processed, and returned to the front-end applications in an organized way. There is no one way to build and organize the PBCs, which provides additional flexibility. 

Using a composable architecture results in a system that is flexible and agile. Adding a new channel, platform, or PBC can be done with a faster time to market. The back end developers can focus on exposing more functionality and platforms. The front end developers can focus on composing solutions to best meet the end users’ needs. The architecture is able to adapt to the ever-changing business needs. In essence, composable is headless at scale.

Composability Within Drupal

You may be wondering, if composable is the future, how does Drupal fit in? Drupal has been around for a long time, and during that time, it has continued to evolve. In many ways, as Dries Buytaert points out, Drupal has evolved to be a composable digital experience platform on its own. The goal has always been to allow developers to build flexible systems with a modular approach to allow their organizations to quickly adapt to their customers’ needs. 

Drupal was an early adopter of the headless movement. Modules to expose the content via REST APIs using JSON and GraphQL have been available since Drupal 7 and many of these modules are now incorporated into Drupal core. Indeed, there are many recipes and starter kits that make building a headless Drupal site easier. 

Being modular is a key attribute of a composable architecture. The ability to build solutions from reusable components provides agility and speed in building a new experience. The Drupal platform is modular. Drupal core comes with a variety of modules used to build most Drupal sites. In addition, the Drupal community has built thousands of modules that extend Drupal core allowing developers to extend the functionality even further. Developments like Project Browser are making it easier to find and use these modules. 

One of the key benefits of a composable architecture is the ability to seamlessly integrate different back-end systems to create a best-of-breed solution. To deliver the customer experience that is demanded by their customers, organizations need to bring together data and functionality from a variety of platforms. Third-party integration modules are one of the key areas covered by the extensive pool of Drupal community contrib modules. With these modules, Drupal developers can build a composed solution within the Drupal platform that brings together data and functionality from a variety of platforms.

Part of the promise of a composable architecture is the ability to quickly bring together an experience. Having a low-code/no-code tool available can really speed up the process and this is where the Drupal platform shines. Layout Builder is a Drupal core module that gives editors the ability to build pages using drag-and-drop capabilities with prebuilt components built by the developers. Products like Site Studio from Acquia take low-code/no-code building to the next level. The business is free to innovate at the speed it needs to innovate.

In many ways, Drupal provides a composable solution. Drupal provides out-of-the-box support for a headless website. It’s built with a modular approach, is open and makes it easy to bring together many systems, and provides low-code/no-code builders that make it simple to compose solutions. And while Drupal can provide many of the benefits of a composable solution, it does not quite reach the full potential of a truly composable solution. 

Composability With Drupal

A truly composable architecture is a modular solution where the front end and back end are completely separated by an orchestration layer. A composable architecture is more flexible, scalable, and efficient than a monolithic architecture. This results in huge benefits to the organization. As there is a need to add an additional channel to the digital experience, the builders have the flexibility to build it exactly as needed by leveraging the already built components. And, as the organization’s needs change, those components can be updated in one spot to efficiently distribute those changes. As the need to scale arises, the back end systems can be swapped out and scaled up without disrupting the digital experience channels.

Drupal has a long history of being used as a headless CMS. For the better part of the past decade, Drupal has been used to power some of the most innovative and powerful headless experiences. Beginning in Drupal 8, Drupal core provided  REST and JSON:API support giving developers the option of using Drupal in a coupled or headless manner. In addition, Drupal provides GraphQL support by installing a community contrib module. 

Drupal really excels as a CMS when it comes to complex authoring workflows and complex content modeling. Drupal has a mature feature set that makes building workflows and complicated data models easy. There is great flexibility and power to be leveraged with Drupal.

By using Drupal’s headless capabilities, Drupal can be a key part of a composable solution. Content administrators are comfortable using Drupal and developers can harness the power of Drupal. In a composable architecture, Drupal’s many features can be used while also using other platforms for their strengths. The best-of-breed model leverages the best of all worlds. 

Composable architectures are a powerful approach to building headless at scale, and Drupal is a powerful tool that embraces many concepts of a composable architecture when used by itself. But Drupal is not limited to that. As organizations look to unlock the value of all their systems, Drupal can be a key component of a composable architecture.

Check out this blog to learn more about how composable is powering transformative digital experiences.

Feb 16 2024
Feb 16

Every iteration of Drupal brings a multitude of security improvements, accessibility improvements, and a host of new features created by the Drupal community. Drupal 10, released in December 2022, brings impressive UI improvements that give a beautiful refresh to the admin interface and default theme. 

Since the launch of Drupal 8 in August 2015, Drupal has continued to evolve and add new features that keep it in lock-step with modern development practices. One of the biggest changes that took root in Drupal 8 is the integration of Composer, a PHP-based dependency manager. Composer is a powerful tool that can be used to install modules, upgrade Drupal, and even check compatibility between modules and dependencies used across your project. Understanding how to leverage Composer to upgrade your Drupal codebase is an absolute necessity. Fortunately, Composer is easy to master. 

In this article, we will give a brief overview of how Composer tracks your project’s dependencies in composer.json and composer.lock. We will then discuss leveraging Composer and community-built tools to ensure compatibility between your code and the latest updates. Finally, we will cover using Composer commands to upgrade Drupal and address conflicts.

If you are running an older version of Drupal such as Drupal 7, check out this article for tips on upgrading your website from Drupal 7 to Drupal 8+. 

Key Composer Principles

Composer is a PHP-based dependency manager that is used to track and download things like Drupal modules, Symphony libraries, and even Drupal core itself. Composer uses semantic versioning to communicate compatibility between different package versions. A change in the major version (such as from Drupal 9.x to 10.x) means that there are potential incompatibilities that developers may need to address when upgrading a project. 

Composer uses a composer.json file to track our project’s explicit dependencies as semantic version ranges. For example, your project may require drupal/core:>=9.4 which tells Composer to install Drupal core version 9.4 or greater. Each one of the modules and themes used by your project will have a corresponding line in composer.json.

Each one of our project’s dependencies will have its own dependencies. For example, the Drupal Commerce module requires the Address module as well as a non-Drupal PHP library used for currency formatting. When we download the commerce module, Composer will also download the Address module and Currency formatting library. 

As Composer resolves each of these dependencies recursively, it builds a full list of 3rd party dependencies used across your project (including dependencies of dependencies).  The fully resolved dependency tree is then stored in the composer.lock file. This file contains the metadata of each dependency, including the location the package is downloaded from, any PSR-4 autoloading information, and a hash that references the exact version of a dependency. When other developers and CI pipelines run the composer install command, Composer reviews the composer.lock file and downloads all of the listed dependencies to your project.

Assessing Upgrade Compatibility

Incompatibilities can take a few different forms. In the case of Drupal 10, there were 8 modules, and a theme removed from core (some were moved to the contrib space, others deleted). We also see various deprecated functions removed from the core completely. If your project relied on any of these you will need to take action to resolve the incompatibilities.

The Drupal community maintains a module called “Upgrade Status” which can be used to give you a full picture of your upgrade path. This module gives you a series of tools that can be used to scan a Drupal installation for deprecated module usage. It also scans your codebase for calls to deprecated functions, or incompatibilities in info.yml and composer.json files.

# Install the latest dev version of Upgrade Status
composer require drupal/upgrade_status:4.x-dev --dev

One of the most powerful tools that comes with Upgrade Status is called  “Drupal Check”. Drupal Check uses static analysis with PHPStan under the hood to find calls to deprecated functions. Drupal-check is a great tool to help find errors in code in a performant manner, and is the type of tool you should have built into your CI pipeline. I would be remiss if I didn’t call out Acquia BLT, which has Drupal Check built in!

Upgrade Status has a dependency on Drupal Check. This means Composer will automatically install Drupal Check alongside Upgrade Status during the composer require command. We can also explicitly require just Drupal Check via a similar  composer require command.

# Require Drupal Check explicitly
composer require mglaman/drupal-check
# Run drupal-check
php vendor/bin/drupal-check  

Running Drupal Check will output a list of potential code issues for you to check and resolve before performing the upgrade. Any calls to deprecated code can be resolved using Drupal’s change records. Drupal’s codebase will also usually emit PHP notices containing details on how to resolve the deprecation moving forward. 

PHP Version Upgrades 

Drupal 10 requires a minimum of PHP 8.1, which is a far cry from the minimum of 7.4 required for Drupal 9. PHP 8 brings impressive optimizations and changes to language constructs. Composer allows us to specify PHP version as a project dependency in the same way we require other dependencies. This forces Composer to check whether our packages are compatible with PHP 8. 

composer require php:"^8.1"  --no-update

We are also able to require a specific version of PHP to be running on the host machine. This will give developers a heads-up if the PHP version running on their system hasn’t been upgraded to the appropriate version.

composer config platform.php 8.1

Most PHP 7.4 code is compatible with 8.x, but it is always a good idea to review backwards compatibility via change notices and the tools outlined above.

Upgrading Drupal Core With Composer

Finally, it's time to upgrade Drupal! Using Composer, we can explicitly require Drupal 10 using the composer require command. This will update our composer.json and add Drupal 10 as an explicit dependency. We also pass the --no-update flag to prevent the full dependency resolution process from running. This gives us a good spot to “save our work” before we embark on the upgrade process. 

composer require drupal/core:"^10.0" --no-update 

This require command tells Composer that the minimum acceptable version of Drupal core is 10.0. The package to place an explicit version requirement on will vary from project to project. If your project was set up using the instructions on Drupal.org, this version requirement would go on the drupal/core-recommended package. You can find the package to place the version constraint on by inspecting your composer.json file.

composer require drupal/core-recommended:"^10.0" --no-update 

Finally, we can upgrade all of our dependencies by running the command:

composer update

This command takes the information in our composer.json file and attempts to resolve the dependency tree. As it does this, it will analyze all your project’s dependencies, including PHP version, and determine if there is a way to satisfy all of your dependencies. This process usually isn’t straightforward, and you may end up with conflicts. This is ok! In fact, this means Composer is doing its job properly in spotting conflicts.

The conflict output will be something like the following:

- Root composer.json requires drupal/devel ^4.0 -> satisfiable by drupal/devel[4.0.0-rc1, ..., 4.x-dev].
- drupal/core-recommended[10.0.0-alpha4, ..., 10.0.0-alpha5] require symfony/var-dumper v6.0.8 -> satisfiable by symfony/var-dumper[v6.0.8].
- Conclusion: don't install symfony/var-dumper v6.0.8 (conflict analysis result)

In this case, Composer is telling us devel is causing a conflict with Drupal core on one of their mutual dependencies - symfony/var-dumper. After visiting the Devel module page we can see there is a newer version of devel that is compatible with Drupal 10. We can require the new version of this module, then re-run the update process.

composer require drupal/devel:^5.0 --no-update
composer update

This resolves the version incompatibility for the devel module, and we would continue on to resolve other conflicts posed in the update process. Resolving these conflicts may require a few different approaches. Sometimes it requires using the dev version of a module, other times it might require submitting your own patch to Drupal.org. The Upgrade Status module does a lot of this legwork for us, but understanding and resolving Composer conflicts is an important skill in modern Drupal development.

From here the process is rinse and repeat - run Composer update, analyze conflicts, and resolve with the appropriate approach. 

Historically, upgrading between Drupal versions has been fraught with challenges that require extensive development and testing. Since the introduction of Composer and community tools like Upgrade Status and Drupal Check, upgrading has become near trivial. With a little bit of configuration and know-how, Composer can be used to upgrade everything from PHP versions and contrib modules, to Drupal core itself,all while finding incompatibilities and potential issues.

Understanding and using Composer appropriately is the key to successful upgrades and maintenance of modern Drupal projects.
 

Feb 16 2024
Feb 16

In a modern DevOps world, a large part of the deployment pipeline is automated across multiple tools. Most DevOps pipelines validate, test, build, and deploy code, all automatically. It can be tempting to trust the system to just handle these steps. When something goes wrong, how long does it take you to find out? Does your QA team often wonder why a ticket that is marked for them to test doesn’t seem to actually be available? This is where ChatOps comes in. ChatOps turns your chat messenger into a communication hub for the team and the automated DevOps pipeline. Acquia’s Build & Launch Tool comes with Slack messaging built in. This guide will walk you through a basic ChatOps set up with BLT and Slack.

Getting Slack Ready

To use Slack as your hub for automated messaging, you’ll need a channel that can receive messages via a webhook. There are two schools of thought: some prefer using a separate channel, dedicated to devops messaging; other teams prefer having the devops messages right in with the rest of the team chat. Which is right for your team is largely a matter of preference.

Teams that prefer to have devops messaging in a separate channel usually do so because devops messaging can get repetitive and clutter the general chat with messages, obscuring real discussion between developers. Placing devops messages in their own, dedicated channel allows team members to set appropriate levels of notifications without interfering with the team's normal discussions.

On the other hand, some teams prefer to have devops right in the middle of everything. It’s important to know when things are happening in the repository and when deployments are under way. Having devops messages appear in the main team chat forces everyone to be aware of what’s happening in case.
Regardless of your decision, you’ll need to setup a webhook to receive messages. Slack makes this very easy.

  1. Create a new Slack app or open the settings for an existing one.
  2. Select the Incoming Webhooks in the left navigation and click Activate Incoming Webhooks if it is not already enabled.
  3. Click Add New Webhook to Workspace. Pick the channel you want to send devops messages to and click Authorize.
  4. You’ll receive a unique webhook URL; hold on to this for later.

Connecting Slack to Acquia BLT

BLT is a wonderful way to automate a large part of your Drupal maintenance on Acquia. It is easy to configure via YAML files and has a large number of built-in scripts that require little to no setup and provide great benefit. Even better, Acquia BLT has a Slack connection built-in, you just have to provide your webhook URL in the configuration file!

Adding Slack communication to your BLT operations is as simple as editing the blt.yml file. Just add this configuration to your blt.yml and push the code to Acquia. Make sure you use your unique webhook URL from the previous section.

slack:
  webhook-url: “https://my.slack.webhook.url/########”

Once this configuration is deployed to Acquia you should start seeing messages in your Slack channel like the message below.

Bonus: Connecting Your Code Repository

Acquia BLT provides chatops for an important part of your devops pipeline. It helps cover that “last mile” where code is actually deployed to Acquia. What about the rest of your pipeline? Chatops can bring in the rest of your code operations as well, truly making Slack the hub for your team's devops pipeline.
Git is the most commonly used version control system and most of the major Git remote providers already have Slack apps. This list includes Bitbucket, GitHub, and GitLab. Connecting each of these apps is generally very simple!

Bitbucket

Bitbucket makes this wonderfully simple. First, install the Bitbucket Cloud Slack app. With the app installed, you can subscribe any channel to any repository with a simple slash command.

/bitbucket connect

This will connect the channel to your repository and open a browser tab where you can select the relevant events in Bitbucket. By default nearly everything is selected, providing a robust view of your repository activity.

GitHub

GitHub also provides a helpful Slack app. Installing the GitHub for Slack app will provide a slash command, subscribing the channel to repository activity.

/github subscribe [repository name]

The GitHub for Slack app will post in the subscribed Slack channel with any repository activity. This will keep your development team aware of any changes or actions required.

GitLab

GitLab doesn’t provide an app integration for notifications but it can use the webhook you generated earlier! To set up the Slack notifications service, follow these steps:

  1. Go to your project settings and select Integrations. 
  2. Select Slack notifications.
  3. Select the Active checkbox in the Enable integration section.
  4. Select the triggers you would like notifications for.
  5. Enter the webhook URL you created earlier.
  6. Select Save Changes.

GitLab should now send notifications to the same channel that Acquia BLT notifies!

That’s How It’s Done!

Setting up ChatOps with Acquia BLT is that easy. This messaging will appear for database copies and backups, deployments, and code switches. If you also connected your code repository, you should have a complete picture of your code and deployment activity. Now your team will have a consistently up-to-date awareness of your Acquia application status!
 

Feb 16 2024
Feb 16

Acquia has been very busy developing new features for Site Studio over the past year, making it an even more compelling answer to Drupal core's Layout Builder functionality. With Site Studio, you get everything you need for site building, whether it’s an atomic design based component library, or more traditional, locked down page structures; Site Studio offers it all. While Layout Builder was a massive addition to Drupal earlier in the version 8.x lifecycle, it hasn’t kept up with the way users look to construct pages. Its setup and user interface is clunky at best and requires a lot of extra additions through other Drupal elements, such as custom block types, paragraph fields, etc. in order to truly be useful to content editors and marketing managers. 

The drag-and-drop, low-code solution has been receiving regular updates every few months. The biggest of these changes is the ability to create custom components in code. We’ll discuss that major change as well as some other highlights from Site Studio 6.9. Additionally, we’ll also catch you up on some other new updates from other previous releases that you may have missed. Let's take a look at a few of these enhancements!

Custom Components for Acquia Site Studio 6.9

This feature, released recently in version 6.9 of Site Studio, provides developers the ability to define custom components entirely in code. Prior to this, a developer would need to use the Site Studio backend to drag and drop elements into a layout canvas, and from there configure all the various elements (by adding CSS styles, HTML attributes, etc.) using the Site Studio UI. While this process often works well when building simple components, it can quickly become cumbersome and limiting for more complex components.

With this new update, developers can build custom components entirely in code and the process is simple. You first create a directory in your theme or module where you will store your component. In that directory you create a .yml file which defines what assets need to be included with your component (ie, your CSS and JS), and then you specify what kind of template will be used to render your component. You can choose from rendering via a standard HTML template, a TWIG template, or a JavaScript template. Optionally, but probably recommended, you can add a form.json file to define what the edit form for the component should look like (more on that in just a bit). So your custom component file structure may look something like the following:

/path/to/my-theme/

  /custom-components

    /card

      card.custom_component.yml

      form.json

      card.html

      card.js

      card.css

This new functionality is a game changer for developers who feel bogged down by having to work within the Site Studio UI, or who feel they are not able to take advantage of Site Studio to build richer, more complex components. With this new approach, it is now trivial. Check out this example of how to build a React-powered component! In a custom component, the necessary React code can simply be attached as a dependency in the component's definition, just as you would with a React-powered custom block.

Beyond the process of building a component, another advantage to this approach is that component definition is taken out of Drupal config. Exporting Site Studio components to config (as an enormous JSON file) has always been troublesome, if only because code review of the config is nearly impossible (but for other reasons as well). Now, pull requests will include links to markup, JS and CSS that can be reviewed easily and coherently. Furthermore, collaboration between developers on a single component is now possible without exporting and importing config. This really does elevate the experience considerably for developers.

Finally, this opens up the development process to those who are not familiar with Drupal (or maybe even those who do not have access to Drupal). All development can happen outside of the CMS, with the exception of building the form that will be used by content authors. For that process, Acquia has provided a Custom Component Builder where a developer can use the layout canvas to design an authoring form for their component. Once built, the JSON for the form can be exported and added to the component directory. This may be the most cumbersome part of what is otherwise a very slick and exciting new way to build components in Site Studio.

component form

Custom Elements Can Be Containers

Site Studio allows users to create custom layout canvas elements, which is nothing new.  Now, we can make custom elements behave as layout containers, meaning users can place nested elements side of a custom element, further making it a powerful feature for builds that require some custom code additions.

Accessibility Improvements

Site Studio comes with a handful of interactive components that can be used out of the box to create things such as sliders, accordions, and even drop down menus. These components include all the JavaScript necessary to power the component. However, in the past we have found that some of these components lack certain accessibility features, and as a result we end up rolling our own custom components and including our own JavaScript plugin (or writing our own JavaScript, if necessary).

Release 6.6.0 included a number of substantial updates to the built-in slider component, addressing a number of accessibility issues. The updates are based on the excellent work by Accessible360 on their Slick slider replacement.

A couple of the more notable improvements include:

  • Users can define an `aria-label` for the Slider container, providing a place to include descriptive text for screen reader users.
  • Instructions can be provided for screen reader users on the Slider container. This can be very helpful as it provides a way for screen reader users to learn how to navigate the slider.

These two properties are not visible by default, so when adding a new slider, you will need to edit the slider container and then click Properties -> Accessibility, and then check the Accessibility checkbox:

accessibility

You will then see an accordion item in the slider container's edit form with fields for "ARIA Label" and "Screen reader instructions:"

slider_fields

With these changes, site builders can feel confident that adding an out-of-the-box slider will be both functional and accessible, without having to get their hands dirty writing any JavaScript.

Copy Token Button

The layout canvas now includes a button to allow users to copy token values. This sounds like a tiny update, but this is a huge improvement in the user experience for site builders. Previously, you would have to manually type in the name of a token, an operation obviously prone to error.

copy token

Undo / Redo Layout Canvas Buttons

Another new feature added to recently is the ability to undo / redo changes in the layout canvas. This feature adds two buttons to the top of a layout canvas allowing you to go back and go forward with your changes.  This is another minor change that goes a long way to improving the component building experience. Like with any undo/redo feature, there is a risk of manually deleting data by using the buttons inadvertently.

New UI Kits

Though not strictly a new feature in Site Studio, Acquia is now offering two new UIKits for Site Studio users. Think of these UIKits as Bootstrap for Site Studio. They offer site builders a way to quickly populate a site with pre-built and styled components for things like modals, sliders, tabs, etc. These new UIKits also come in two flavors called the Primitives UIKit and the Sections UIKit. Let's take a closer look at these two and see what the difference is!

Primitives UI Kit

The Primitives UIKit is intended to provide maximum flexibility for site builders and designers. This kit comes with a comprehensive set of content components and layout components that can be mixed and matched and combined to create an endless variety of designs. The components are granular and discreet - think cards, videos, testimonials, stats and sliders. When combined with the Visual Page Builder, content authors have a drag-and-drop interface which allows them to build very complex pages, and they are able to do so quickly and efficiently. This kit is best for sites with varied content that would benefit from the flexibility that it provides. Content editors using this kit would likely benefit from some training in how to combine the various components in the most effective way and would be trusted to do so consistently.

Sections UI Kit

If you want to get a site up and running as quickly as possible, and you do not have highly-customized designs, the Sections UIKit will likely be what you are looking for. Rather than providing a collection of discrete components as in the Primitives UIKit, the Sections UIKit instead provides a collection of pre-built "page sections" that can be mixed and matched as needed. Where the Primitives UIKit includes a "map" component and a "text" component, the Sections UIKit includes a "Text and map section" where the discrete components are already combined into one page section. By stacking page sections on top of each other, content authors can very easily build landing pages full of rich content with very little training.

Acquia has made some significant improvements to Site Studio in the last year. Most importantly, the support for Custom Components is going to be a game changer for a lot of developers, and will significantly expand what kind of sites can be developed using this platform. We look forward to using this new functionality and pushing its boundaries. 

Growth and Maturity

Site Studio was already a powerful tool in Acquia’s impressive line of products, but it continues to grow and improve. The addition of the custom components feature alone opens up Site Studio to a much larger potential user base. At Bounteous, we will look to dive in further into these new features and look forward to where Acquia takes Site Studio in future.

As with any Drupal updates, it's recommended to fully test these new features and fixes (as applicable) on your site's development environment before deploying to production. You should also have a backup of any code or databases before upgrading. Version 6.9 of Site Studio is not backwards compatible.

For additional information on Site Studio, check out some of our other posts:

Feb 16 2024
Feb 16

As a developer, building a partially or fully headless Drupal site can feel like a daunting task. There are always more questions than answers when getting started. Like with any new site build, determining the build path in the beginning is crucial to ensure your site is scalable. Acquia offers a site starter kit called Acquia CMS, which is a pre-packaged version of Drupal and an enterprise content management system.

To improve headless applications and make API management and site building easier for front-end developers using Acquia CMS, Bounteous collaborated with Acquia to co-develop a Headless Dashboard module for Acquia CMS. This module is currently in beta but will be able to get you up and running via Next.js with a Headless site with relative ease. Let’s take a look! 

Acquia CMS Headless Users

In Acquia CMS Headless, there are two general types of users:

Content Managers

Whom the CMS is built for, manage the structured content that gets served to third party consumers such as node.js websites, front-end apps, IoT integration (e.g. smart displays) and native mobile applications.

Developers

Who build those third party consuming applications. They need to use the CMS to:

  • Setup consumer identity, permissions and access
  • Setup data models for consumption
  • Access API documentation based upon the defined data model of the CMS.

These developers are commonly working with javascript/typescript frameworks such as React, Next, Vue and Svelt and do not need to be PHP or Drupal developers (the technology Acquia CMS is built on).

Accessing the Headless Dashboard

The headless dashboard can be found as a drop-down from the Tour menu item in the admin menu navigation.

 

Headless Dashboard Overview

API Endpoint and Documentation

At the top of the dashboard, you’ll see access to the default endpoint: json:api. json:api is a standardized format for communication over APIs. There is wide support for json:api across many languages including drupal-jsonapi-params: A library for building query parameters when connecting with Drupal CMS’s JSON:API.

All of Acquia CMS’s data model can be accessed through the json:api endpoint and you can access the documentation for that endpoint through https://www.openapis.org/: a standard for API documentation. It comes in with two UIs: Redoc and Swagger UI.

Viewing the article content type from the default content model in Acquia CMS through the Redoc API endpoint documentation inside the CMS.

API Access

With Acquia CMS users and roles, you can customize how consumers authenticate with your API (using API keys) and what parts of the API they can access (using users and roles).

By default, Acquia CMS is setup for OAuth authentication using OAuth consumers. From the API Keys panel in the headless dashboard, you can create new consumers and determine which users and roles a consumer should represent.

Note: In Acquia CMS, permissions are granted to roles.  Roles are granted to users and a user is associated with an OAuth consumer. Whatever permission that user has will then be permitted to the consumer also.

Any user assigned the Headless Role, they will also be listed here in the dashboard under API Users. This way it is quick to see all the users that represent your API consuming third party applications.

Next.js sites

Out-of-the-box, Acquia CMS comes ready to integrate with Next.js for Drupal: a library for native integration between Next.js and Drupal over the json:api endpoint. Acquia CMS also has a next.js starter kit here (see tutorial).

Knowing about your Next.js sites helps:

  1. Know how to route site preview* for a given content type to the right next.js site
  2. Provide the required environment variables for the next-drupal application.
  3. Handle content invalidation at the Next.js application when updates occur in the CMS (experimental feature).

If you’re interested in using Next.js, check the Next.js starter kit check box in the Acquia CMS Tour setup. This will precreate the Next.js site, user, roles and configuration ready to integrate with your next.js application.

* Next.js site preview is not fully available in the Acquia CMS Headless beta release. For it to work, you must have “headless mode” disabled so that node pages will be rendered by the CMS.

Get Started with Acquia CMS Headless

If you’re a developer building with Acquia’s headless CMS, the headless API dashboard makes working with Acquia CMS easier than ever. Try it out now! 

Visit dev.acquia.com for more information.

Feb 16 2024
Feb 16

Building the best Drupal websites starts with the best Drupal tooling. Nearly all modern Drupal websites are built using a “local environment” which gives developers a place to create exciting new features without affecting the production environment.

Getting a local environment configured and using it to perform daily tasks often requires a plethora of custom scripts and tools built by a DevOps guru. Tools like Drush and Lando make this process exponentially easier, but there is often still a need for custom scripts to simplify the lives of developers. The less time a developer spends on maintaining a local, the more time they can spend developing world-class web experiences.

As the Drupal practice at Bounteous has grown, so has our tooling. What was once a hodgepodge of custom, client-specific bash scripts, have evolved into reusable, pluggable tooling that can transfer from project to project - all built on Acquia’s Build and Launch Tool (BLT). 

BLT is a Drupal-specific extensible toolset designed to help you build, test, and deploy your code. It provides a vast array of commands to get you up and running quickly, including commands to configure your local, sync databases, or even run post-deployment tasks like config import. The majority of the BLT can be configured via a single YAML file, allowing you to hit the ground running on any sized Drupal project.

Compatibility with Drupal Sites

BLT can be installed via composer (a tool used to manage 3rd party PHP libraries) and it operates in a similar fashion to Drush. When installed, you are provided a new CLI tool at vendor/bin/blt which is used to trigger BLT commands. This CLI tool requires that your system be able to run PHP scripts, which is also needed for Composer and Drush commands. BLT frequently invokes Drush commands to complete its tasks. 

BLT comes configured “for Acquia” out of the box, but it doesn’t require an Acquia subscription to be used. At Bounteous, we use BLT for various clients and side projects, including Drupal sites hosted on custom infrastructure or by other Drupal providers like Pantheon. BLT’s flexibility and pluggability make it the perfect tool for any Drupal site hosted on any platform.

However, where BLT really shines is when it is used in conjunction with Acquia hosting. BLT’s default settings.php file comes baked with Drupal hosting best practices - including memcache and config split settings. It will also recognize when the tool is being used on Acquia hosting and automatically include the appropriate settings needed to connect to the platform. This means configuring your Drupal site for Acquia is as simple as configuring BLT!

Acquia BLT Plugins

BLT is built on Robo, a customizable and extensible PHP task runner. New commands can be easily installed via 3rd party packages, or through your own project’s configuration - blt recipes:blt:command:init will configure this for you. We have implemented custom BLT commands for everything from Acquia Cloud Site Factory (ACSF) management to Acquia Cloud IDE configuration.

Acquia and the larger Drupal community maintain a plethora of plugins that extend and enhance the BLT toolset. There are numerous integrations with local environment tools such as Lando, DDEV, and DrupalVM. Acquia also provides a number of plugins that offer better integrations with Acquia products. For example, there is a plugin for ACSF which provides commands to initialize and validate required settings files. 

Acquia keeps a list of plugins in their knowledge base which you can find here.

Installation & Configuration of Acquia Build and Launch Tool

Installing BLT is as simple and easy as installing Drupal’s contrib modules. We won’t cover the initial set-up of a new Drupal codebase (drupal.org has helpful guides on this), but assuming you have an existing codebase, BLT can be easily installed via composer.

composer require acquia/blt

During the initial installation of BLT, a YAML configuration file will be generated in your project root at blt/blt.yml. This file contains important metadata about the project and options that drive much of the behavior of the tool. The following is a snippet from the BLT configuration that drives the bounteous.com website. These settings are used in many places throughout the tool, and give us some basic information about the name of the project.

project:
 machine_name: bounteous
 human_name: 'Bounteous.com'
 # Used for enforcing correct git commit msg syntax.
 prefix: BCE

BLT Local Environment Setup

To work on a Drupal website, most developers use a “local environment” such as Lando or DrupalVm. Most of the common local environments in use by the Drupal community have a corresponding BLT plugin that can be leveraged to quickly configure and boot your local. These plugins are optional but are often handy when working on the initial configuration of a process. In the case of Lando, Mike Madison maintains a composer package that will perform the configuration (including adding a lando blt command) for us.

composer require --dev mikemadison13/blt-lando -W
blt recipes:vm:lando

Once your local environment is configured and booted, you can begin the setup of your Drupal site. There are a few different strategies we can take to set up Drupal with BLT. For existing sites, we typically sync the database from our staging environment to our local environment. BLT also supports installing a fresh site from existing config or from an install profile. The following is the local environment configuration for bounteous.com which we use to sync the database from our dev environment (the @bounteous.dev drush alias) to a local Lando environment.

# This will be used as the local domain for all developers.
 local:
   hostname: '${project.machine_name}.lndo.site'

# Sync db strategy
# drush sql-sync @bounteous.dev @self
# Valid values are install, sync, import.
setup:
  strategy: sync
drush:
# Set our source db.
  aliases:
    remote: 'bounteous.dev'
# optionally disable sanitizing data.
  sanitize: false

This configuration is used during the blt setup and blt sync commands.

BLT Frontend Compilation

No Drupal setup is complete without a frontend build process! BLT offers command hooks that allow you to execute custom commands at various points in the setup process. In the case of frontend hooks, they offer a way to execute our npm commands inside of our theme directly. Bounteous.com uses npm to compile the theme, but we can also use any other CLI tool here such as gulp. We can also specify the directory to run these commands in so that we don’t need to worry about execution context.

command-hooks:
 frontend-reqs:
   dir: ${docroot}/themes/custom/bounteous
   command: 'npm ci'
 frontend-assets:
   dir: ${docroot}/themes/custom/bounteous
   command: 'npm run build'

This configuration is triggered during the blt frontend command.

Drupal Setup

Once you have your local environment running and your blt.yml configuration set, it’s time to run the setup process! This will make any final tweaks to the codebase needed to bootstrap and install Drupal including:

  • Running composer install.
  • Creating a local settings.php file that points drupal to the appropriate database.
  • Running frontend tasks via blt frontend.
  • Running a database sync or running a site:install command.

This process can be triggered via the setup command:

blt setup

Once setup has been successfully run, a developer will have a functioning local Drupal site! 

Quick & Painless

Acquia BLT offers a quick, painless way to run and maintain a Drupal environment.
What was once the wild west of Drupal DevOps scripts has settled and matured into Acquia’s Build and Launch Tool. BLT offers many commands out of the box that allow us to get up and running quickly on a project. Its configuration and installation are dead simple, its internals are well thought out and easily customizable. BLT has been an integral part of many Bounteous Drupal builds. 

For more information on BLT, check out the following:

Feb 16 2024
Feb 16

Drupal 10 will be arriving summer of 2022. Much like the update from Drupal 8 to Drupal 9, this update will be a smooth transition for any well-built and maintained Drupal site. Since Drupal 8, the maintainers of Drupal have implemented a predictable approach to releasing new versions of the CMS. This benefits everyone that builds, maintains, or manages a Drupal site by giving us a clear path for updates from one major version to another.

In many cases, this update is trivial for developers and can be performed with a few simple steps. For site administrators and content creators, it's a seamless transition that brings in new features and enhancements that makes managing Drupal sites easier and faster.

The first beta version of Drupal 10 will be released alongside a beta version of Drupal 9 (either 9.4 or 9.5, depending on Drupal 10's readiness). The release of these together is intentional and reveals the commonality between these two major versions of Drupal. When Drupal 10 drops, it will essentially be the same as the last minor version of Drupal 9, with a few key differences that will benefit site managers and developers.

Deprecated Code Removed

Drupal core code and libraries that have been identified as "deprecated" in Drupal 9 will be removed. Throughout the life of Drupal 9, improvements have been made to the code that runs the framework. When an enhancement is made in the code, there's likely some other code that can be retired. 

That retiring code can't be immediately removed as it may break functionality in a site's custom code or contributed modules, so this code is marked as deprecated to communicate that it's being removed in the next major version of Drupal. This gives developers ample time to update their code to be compatible with Drupal 10.

An example of deprecated code in Drupal core in Drupal 9 is the class "NodeAddAccessCheck." This helps determine if a user has permission to add a new Drupal node (content entity) to the site. This is being removed in favor of "EntityCreateAccessCheck" which performs the same function but is used to check for permissions to add any entity type rather than just nodes. This streamlines the codebase and makes writing code that needs to check user permissions more consistent. 

Another type of deprecation that Drupal needs to account for is when external code and libraries Drupal uses are going end of life. Drupal leverages the Symfony framework "under the hood" to provide a lot of functionality that's common to almost every website—things like managing cookies, handling and routing incoming requests, and services. This gives us a great starting point for building Drupal core rather than having to reinvent the wheel for each of these components. Drupal 9 uses Symfony version 4, which is slated to go end of life in November 2023. Drupal 10 will use Symfony version 6, which brings the latest enhancements of Symfony to Drupal and will help to keep the system secure.

Some of these may seem like trivial updates to Drupal 10, but these improvements help with site security, performance, and consistency from page to page in the admin UI. Together this makes Drupal 10 easier for content creators and site administrators to carry out their work on the site.

Changes to Some Drupal Defaults

When installing Drupal for a new website application, there are a lot of settings that implement the out-of-the-box look and functionality of the site. When installing a new site in Drupal 9 with the standard installation profile, we are greeted with this frontpage on the site:

This familiar face is the default theme, Bartik, for the site. 

The default front-end theme for Drupal 10 is now Olivero which is described as "A clean, accessible, and flexible Drupal front-end theme." It was originally introduced as an experimental theme to Drupal core in version 8.8. The Olivero theme has been available as a stable theme since Drupal version 9.3.

Another visual change to Drupal is a new administration theme, Claro, which is replacing the older Seven theme. 

Here is the old Seven administration theme:

Here is the refreshed Claro theme:

The new default themes in Drupal 10 will provide a better experience for content managers of Drupal sites. Content managers and site administrators will be able to more easily find and do the work they need to do in the back end of their Drupal sites.

Removing Some Core Modules

Drupal 10 core will say goodbye to a few modules that are redundant or not widely used. These modules will be moved to the Contributed Module space for continuity. This move will help make Drupal's core leaner and easier to maintain. According to Drupal core discussions, these modules are likely to be removed from Drupal core:

  • Aggregator - Gathers and displays syndicated content (RSS, RDF, and Atom feeds) from external sources.
  • QuickEdit - In-place content editing.
  • HAL - Serializes entities using Hypertext Application Language.  
  • Activity Tracker - Enables tracking of recent content for users. 
  • RDF - Adds metadata to pages to let other systems understand its attributes. 
  • Forum - Provides discussion forums.

Some of these core modules were enabled by default, but hardly ever used according to usage statistics and user surveys. Clearing these from Drupal core will help remove visual clutter and improve the content management experience for users.

In addition to some core modules being removed, some JavaScript dependencies will also be removed. The changes to the JavaScript that is shipped with core will help make core more secure and easier to maintain. The biggest change will be the removal of some uses of jQuery. jQuery has been a part of Drupal since Drupal 5 (released in 2007). The move to using vanilla JavaScript removes release risks that have come up in the past due to jQuery and jQuery UI's security and release processes.

Saying goodbye to QuickEdit will make Drupal 10 easier for content creators to manage. The QuickEdit module added a pencil icon next to any content field on the site. While this was a nice-to-have feature when it was first introduced in Drupal 7, its usefulness has diminished since the introduction of workflows with content revisions. Once content moderation workflows are added to a Drupal site, the inline editing experience of QuickEdit can't be used as it's not compatible with workflows.

Among the great improvements to the overall system, are some new features that content creators are going to enjoy. 

New Editing Experiences

CK Editor 5 will be the default rich text (WYSIWYG) editor in Drupal 10. With it comes a lot of features that will improve the content editing experience. These include Autoformatting where you can add bold with **asterisks**, headings with #, inline code with 'text', code block with ''', and bulleted lists with *.

There are also improvements to the paste-from-document functionality. The new version of CK Editor touts the ability to remove the extraneous markup that comes from pasting from Word or Google Docs. It also automatically uploads images when pasting images from the clipboard, rather than simply adding it as an tag that points to a third-party site. 

Drupal's popular page-building tool, Layout Builder is also slated to have improvements that will make managing content on the site better for content creators. The full details of these improvements are not yet available. I hope and suspect that a new layout editing experience will include a modal rather than sticking to the small sidebar that we have today. 

Editing large blocks of text in the sidebar can be cumbersome and confusing, especially when there are more than just a few fields to edit. Improvements to this experience will make managing layouts much easier.

Other enhancements to Layout Builder could include improvements to the interface itself. For some, the Layout Builder interface is clunky, and pending feature requests ask for better ways to move and manage blocks that are placed within Layout Builder.

Foundation for Future Improvements

The release of Drupal 10 clears the path for additional improvements to Drupal that will be built over the next few months and years. Keeping Drupal up-to-date with the latest, fastest, and most secure open source libraries and components give Drupal developers the ability to continually innovate and bring new features to Drupal. 

With the emergence of composable experiences and the further intertwining of web and social media in marketing, Drupal 10 continues to pave the way for some great user experiences into the future.

Feb 16 2024
Feb 16

Drupal code reviews are an important part of the software development process. If you've recently started working with Drupal or you are looking to improve your codebase and processes, you may be wondering what you should consider when reviewing changes to your Drupal codebase. We'll describe how to get the most out of your Drupal code reviews by providing a checklist of important steps and criteria for you to return to and reference as you open and review new pull requests.

Creating A Pull Request

A well-formatted and qualified pull request helps streamline the code review process. It's also a good point for an author to pause and consider the change they've made. Before submitting a pull request, the author should consider the change from the perspective of other team members, such as the designer, the reviewer, and the QA team. Reflecting on the change can offer additional insight into the problem as well as reduce cycle time as the change moves through different stages in the development process. Consider if the change meets the requirements in the most efficient manner.

Before Opening A Pull Request

The code review process begins before the pull request is even opened. The author should review the requirements and ensure the change appropriately addresses them. A developer doesn't need to be as thorough as the QA team members but a basic level of testing should be applied, including verification in multiple browsers to catch inconsistencies. 

Additionally, this is a good time to help out future developers on the project. Make sure the change meets any coding standards that have been established, is well commented on, and the commits show a clear story. The Coder project provides a set of rules for PHP_CodeSniffer to check and apply Drupal coding standards automatically.

▢ Sync the latest changes from the develop branch
▢ Make sure the change meets the documented requirements
▢ Perform appropriate testing and review in multiple browsers
▢ Run a test build to make sure the project builds correctly
▢ Run any linting or standards tools set up for the project
▢ Ensure that commits have useful messages

Opening A Pull Request

The pull request will set the stage for the reviewer. When opening a new pull request, set the reviewer up for success. Provide any relevant information to establish the context of the change. You don't need to copy and paste the ticket description but provide enough information for the reviewer to understand the change (and maybe a link to the full description). If your commit messages are clear and your repository automatically includes commits in the description, this will help provide a starting point.

Additionally, review the diff before opening the pull request. It's important to make sure no unexpected or unintended changes were included in the change. Formatting differences between IDEs are a common issue. These should be resolved before opening the pull request. When making changes to Drupal's configuration, make sure you didn't accidentally capture incorrect values. If you're using config splits, double-check that split config has been applied to the default and vice-versa.

▢ Review the diff to make sure only intended changes were included
▢ Write a useful pull request description including context, questions, or discussion points

Reviewing With Empathy

First and foremost, a code review is about feedback. It's a learning opportunity for both the author and the reviewer. When it goes well, we all become better developers and the codebase becomes stronger as a result. Keep this in mind when reviewing code and review with empathy. In general, assume good intentions.

The advice included in the section is applicable to all code reviews, not just Drupal reviews. For a deeper dive into positive code reviews, check out these resources:

For The Author

Authors should approach the review as a discussion. Pull requests are an opportunity to discuss your change with other developers on the team. Explain why your approach was used and reference edge cases or other considerations that were factors in the solution. In turn, listen to the reviewer's comments and consider how they might alter your approach.

Remember, you are not your code. Suggestions are meant to be constructive and helpful. Try not to take comments personally. Code reviews are a great way to grow your knowledge and learn new patterns and considerations when developing software.

For The Reviewer

Reviewers should approach the review as a discussion. Code reviews are an opportunity to discuss a solution among peers. Many developers assume the reviewer has absolute authority over the change—try to avoid this trap. Instead, ask open questions to facilitate discussion. Offer explanations for your suggestions and include examples. If you disagree with the approach, pause and consider if your solution is better or just different. Remember you can learn as much from the author as they can learn from you.

Remember, your words have power. Try to stay humble and keep your ego in check while reviewing code. Consider how your comments might be taken, particularly if they are only offered in impersonal text on a pull request. Don't request changes directly unless there is a convincing argument for a different approach. Give kudos as well as critiques.

Ultimately, stay humble and take your time. Make sure you understand the goal of the change and the approach the author chose to take. Consider the change from multiple directions. Acknowledge your shortcomings and note when an author has done something interesting or clever (plus, this can also help fight imposter syndrome on the team!).

Performing A Review

Code review is also a technical discussion of the change. It's important to understand the common pitfalls in order to keep the codebase in good shape. Performing a technical review of the code helps address architecture issues and may reduce bugs before they become a problem.

General Approach

In general, the goal of a code review is to facilitate discussion of changes and make sure the development team is creating the best solution possible. As such, there are a lot of components to consider when reviewing a change. During the code review, we want to understand what the change is accomplishing, verify that the change is doing what it's intended to do, and fits in with the overall architecture.

▢ Do you understand the solution (does the solution "make sense")?
▢ Does the solution accomplish the goal?
▢ Does the change include any unrelated functionality?
▢ Does the solution support the overall project strategy?
▢ Do commits contain appropriate information (ticket number, description of change, additional context)?

Drupal Way

Drupal provides a toolkit for content-based website development. Each tool has an intended usage and sometimes more than one tool may be used to solve a problem. Some of these solutions will be better than others and the best solution may not always be obvious. 

Consider the requirements and the intended use of a given system API, configuration, or application layer. The solution should make use of the correct APIs and occur in the correct part of the application. For example, is any front-end work implemented within the theme? Is shared business logic created as a service? Make sure the solution makes use of existing functionality where possible, usually in order by priority: Drupal core, contrib modules, custom code.

▢ Does the solution make use of existing functionality?
▢ Does the solution make the best use of Drupal's tools?
▢ Is the solution implemented in the appropriate application layer?
▢ Does the solution support a content management strategy?

Security

Drupal is a generally secure CMS and extensive efforts have been made by the community to support out-of-the-box security. However, any time custom code or community-contributed features may be involved, the security of the customizations should be considered. The change should make use of the appropriate features provided by Drupal to maintain the security of your application. Reference Writing Secure Code on Drupal.org for more information.

▢ Are Drupal's APIs being used correctly?
           ▢ Do SQL queries use the Database API?
           ▢ Are the text APIs such as t() applied to safely escape text and other scripting attacks?
           ▢ Is content rendered through Twig whenever possible? (Twig automatically escapes rendered content)
▢ Are permissions and access controls implemented properly?
           ▢ If a new entity or feature is implemented, does it have appropriate permissions applied?
           ▢ If a new permission is created, is it checked correctly?
▢ If JSON:API or other APIs are implemented, do API endpoints have appropriate access control and data filters in place?

API-first

Code should be written in a composable way using Drupal's API-first approach. Use services, plugins, etc. to create reusable functions that can be repurposed and edited easily. Drupal offers a powerful but complex dependency injection system. Make sure that functionality is accessed correctly to help keep the codebase DRY.

▢ Are the components of the solution appropriately (de-)coupled?
▢ Is dependency injection used correctly and are all dependencies necessary?
▢ Are new components abstracted to an interface, supporting dependency injection?
▢ Is the legacy hook system used when a more modern approach is available?

Documentation

Documentation is important for both future developers working on the project and existing developers who may need to reference a dependency while developing a separate feature. For architecture level changes, make sure patterns, strategies, and other important aspects are documented in an appropriate README. They may also be documented elsewhere but the codebase should at least contain a reference to external documentation.

Comments are also a key aspect of documentation. In particular, PHPDoc comments should be added to files, classes, functions, and properties to support IDEs that may automatically make this information available to developers. Make sure that complex code blocks have appropriate documentation to clarify the processes the code is following. 

For example, complex algorithms or code flow conditions should include enough information that a new developer can understand the logic that was implemented. If the change applies a workaround or specific logic changed, reference appropriate documentation, such as a task ticket or external documentation link.

Drupal offers some specific opportunities to document functionality. For changes that don't include custom code, help text and README files should be included to document the functionality. When creating new content types and other entity bundles, include a useful description documenting the purpose of the new bundle. Any custom code should have appropriate descriptions, grouping, and dependencies listed in the module's info file.

▢ Are PHPDoc comments added to each file, class, method, and property?
▢ Are PHPDoc comments correctly formatted and complete (include all necessary properties)?
▢ Are complex code blocks explained with appropriate comments?
▢ Do workarounds or specific logic changes reference appropriate documentation?
▢ Are new variables or configuration values documented in the Drupal UI via help text and descriptions or in a README file included with the module?
▢ Do new modules have appropriate values in the .info.yml file?
▢ Do new modules include a README, if necessary, describing aspects of the module?

Code Style and Standards

Code should follow PHP and Drupal coding standards as well as any team- or project-specific standards the team has agreed upon. Following code standards help with code readability and integration. Code style and standards should generally be enforceable via automated analysis tools such as PHP_CodeSniffer

Drupal.org provides a helpful guide for configuring this tool under Installing Code Sniffer.  Usually, these should be run via Git hooks as well as validated by the CI/CD pipeline at appropriate stages but it's important to make sure that these tools were run correctly. Additionally, confirm that no unexpected but valid formatting changes have accidentally been applied. Examples include a change in indentation or quote style through an entire file.

▢ Does the code generally follow code style conventions established by the team?
▢ Are variables, functions, classes, etc. named appropriately?
▢ Did the automated validation tools run correctly? Did they note any errors?
▢ Does the change include any unexpected formatting changes?

Improve Your Codebase & Processes

For those working with Drupal and looking to improve their codebase and processes, this technical guide is the perfect starting point for your team. Whether you were wondering what you should consider when reviewing changes to your Drupal codebase or how you can make the most out of your Drupal code reviews, this guide provides you with an understanding of how to create useful pull requests and perform code reviews in a way that improves your team, as well as your codebase. 

Please feel free to return to this guide as a reference for important review points as you review changes to your Drupal project. Try integrating these guidelines into your code review process to facilitate healthy conversations amongst your development team. By following these important checkpoints, your Drupal codebase will be more secure, more efficient, and easier to work with.

Feb 16 2024
Feb 16

Looking for a way to distinguish yourself among the many Drupal developers out there? Look no further than the Acquia Triple Certification. Representing excellence across Drupal and Acquia, the Drupal Certification exams are for developers, front-end specialists, and back-end specialists that want to demonstrate their advanced expertise.

From "Drupal Grand Master" to "Triple Certified"

Since 2015, Acquia has been using the term "Drupal Grand Master" to acknowledge those who completed Drupal Certification exams for developer, front-end specialist, and back-end specialist. 

With help from the Drupal community, Acquia decided to rename this high level of qualification to "Acquia Triple Certified Drupal Expert" or the shortened version, "Triple Certified." This change was made to reflect more inclusive language. Dries Buytaert, Co-Founder and CTO of Acquia said, "The words we use matter. They make a big difference toward eliminating subtle forms of racism, sexism, and more in the technology industry." The technology industry and Drupal are making huge strides towards improving diversity and inclusion within the open source community. 

In 2022, Acquia renamed its highest level of Drupal certification, formerly "Drupal Grand Master," to reflect more inclusive language. Learn more about this name change here.

What Is Drupal?

Drupal is one of the leading open source Content Management Systems (CMS) and one of the largest open source communities in the world. Founded back in 2000 by Dries Buytaert as a chat platform for college students, today it stands alone as the most flexible, adaptable system on the market, enabling anyone to create advanced websites and applications.

Based on Drupal’s latest stats, 1.5 million sites, 38 percent of Fortune 50 companies, and more than 23,000 developers use Drupal every day to power the sites we interact with regularly. Bounteous has been using Drupal to build websites for customers since 2009.

The Establishment of the Drupal Certification Program

Just as mentorship is ingrained into the DNA of the Drupal community, it was a driving factor in establishing the "Acquia Triple Certification," formerly "Drupal Grand Master Certification," program. Buytaert saw the need to provide a valuable distinction among the community and thus launched the Acquia certification program in 2014. While extremely resource-intensive to create a global certification program, Buytaert says, "We believe that effort is worth it, given the overall positive effect on our community."

Regularly relied upon for guidance and expertise, Acquia Triple Certified Drupal Experts relish the honor to further the Drupal community. As of 2022, Bounteous has 13 Acquia Triple Certified Drupal Credentials, 8 Acquia Triple Certified Drupal Experts, and over 100 developer certifications—the most of any organization in North America outside of Acquia.

Where does Acquia fit in?

Acquia delivers a cloud-based digital experience platform built on Drupal that enables organizations to build experiences that scale and is also led by Buytaert. A preferred partner of Bounteous, Acquia empowers brands to embrace innovation and create customer moments that truly matter. 

Recently named a leader by both Gartner and Forrester, Acquia is committed to facilitating certification programs allowing developers to validate and promote their Drupal skills year after year.

Acquia Certifications

Getting certified is a great way to validate and promote your Drupal skills while helping you stand out from the crowd. Acquia is working towards making it easier to access free training to gain Triple Certification, as well as other Drupal and Acquia certifications. Learn more about how to get Acquia Certifications here.

Acquia Certified Site Builder

The Acquia Certified Drupal Site Builder is a credential intended for professionals who build Drupal sites using core and contributed modules. This exam is designed to validate the skills and knowledge of a Drupal Site Builder. 

Acquia Certified Developer

The purpose of the Acquia Certified Developer exam is to validate the skills and knowledge of a Drupal developer in the areas of fundamental web concepts, site building, front-end development (theming), and back-end development (coding).

Acquia Certified Front End Specialist

The purpose of the Acquia Certified Front End Specialist exam is to validate the skills and knowledge of a Drupal developer in the area of front-end development (theming).

Acquia Certified Back End Specialist

The Acquia Certified Back End Specialist exam validates the skills and knowledge of a developer in the areas of building and implementing Drupal solutions using code (module development).

The Ultimate Triple Certified Achievement

To achieve the prestigious Acquia Triple Certification, a candidate must pass the developer, Front End, and Back End Acquia certification exams within a year. Each exam validates skills and knowledge in different areas from fundamental web development to Drupal Core API. This is no easy feat! It is the highest-ranking Drupal certification available, the triathlon of development, and requires expertise in multiple areas of focus.

Why Does This Matter to Me?

Whether you're a developer, a Drupal agency, or an Acquia customer, the Acquia Triple Certifications are a trusted benchmark in the industry. The real-world scenarios included in the exam ensure a breadth of prior experience that helps enhance development. Many companies even require Acquia Certification which speaks volumes to the respect this program has established. 

We recommend all Acquia Triple Certified Drupal Experts add this credential to their LinkedIn profile under certifications, or if you already have "Drupal Grand Master" listed, make sure it is updated to reflect the new and inclusive language. 

Ultimately, Triple Certified designation allows developers an edge in the development world and provides an enormous amount of credibility in the Drupal community. While no doubt a significant undertaking, the achievement is well worth the investment. With more knowledgeable and engaged developers bettering the community, Drupal’s power increases and in turn supports the companies that leverage Drupal for their digital experiences.

Feb 16 2024
Feb 16

Let’s be honest, PHP is an old language, relatively speaking. It might not be as ancient as COBOL or Smalltalk, but it’s a dinosaur relative to the new generation of programming languages like Rust, Julia, or Typescript. Due to wide adoption and decades of maintaining legacy functionality, updating PHP to include newer features and runtime improvements takes significant time and consideration. The reality is this language is not going anywhere, and there are many benefits of upgrading to PHP 8.

PHP 8 includes improvements that show a clear desire to modernize, as well as capabilities of other popular languages that developers will appreciate. Thanks to PHP 8, Drupal 10 can now use tools that will enable continued growth and enhanced performance. Upgrading to PHP 8 will be beneficial to any site running on PHP–however, as a Drupal developer, I’m particularly excited about how this will impact Drupal 10. I’ll highlight some of the benefits that apply to many sites, but especially how it may apply to Drupal.

To make the most of your PHP upgrade, learn about all of the new and exciting features of this programming language.

Why Upgrade to PHP 8?

Before discussing the features of PHP 8, it’s important to understand why you will want to make this upgrade from PHP 7 to PHP 8. The short answer is that Drupal 10 is requiring a PHP upgrade to enforce requirements imposed by Symfony 6.

It’s also relevant to note that Drupal 10 specifically requires version 8.0.2, not version 8.1. For updates like Fibers and better JIT performance, be sure to use version 8.1 (as opposed to the minimum PHP version needed by Drupal 10). Conversations on this topic are still ongoing, so keep an eye out for updates as new versions of Drupal are released!

New Language Syntax

PHP 8 and 8.1 both introduced changes that can be generally split into three groups: language syntax, new functionality, and execution strategy improvements. Syntax changes give developers opportunities to write code that’s more expressive of what they are trying to do, often with fewer lines of code. 

If we can create the functionality we want with syntax we like, that not only benefits the quality of the sites we build but also helps us with the speed at which we can write code. This article will cover some of the most exciting syntax changes, but you can check out the full list of changes for PHP 8 and PHP 8.1.

Help with NULL

Accessing data from within a deeply nested structure can be a hassle. Values at keys within a PHP array or object can be NULL, and they need to be checked for this case since this can cause runtime errors if not properly addressed. The isset function has helped with this for years, but with the advent of object-oriented programming in PHP 7, lots of data accessing is done via class methods, and those do not play well inside of an isset call.

PHP 8 has added a popular solution to this problem with the nullsafe operator: ?-> (See Figure 1). Many other languages already have this operator, and its addition to PHP will allow us to access data more efficiently.

$data = new stdclass;
$data->foo = NULL;

var_dump($data->foo);
// result: NULL

var_dump($data->foo?->stuff);
// result: NULL

var_dump($data->foo->stuff);
// result: ERROR

Figure 1: The Nullsafe Operator

PHP also added special type operators for making custom types that can allow for more specificity in type declarations. One such operator is the union type operator (See Figure 2). In the spirit of taking inspiration from others, this syntax is the same as in TypeScript and Haskell’s type systems. Thanks to this update, a function or class method can now explicitly state if an argument can be exclusively one of two or more types as a part of its declaration. 

NULL can be included alongside types in a union type declaration, and when NULL isn't included it cannot be passed as a value to that argument. All of this helps developers better control cases with NULL values and helps reduce runtime errors and bugs.

function func(int|string $foo) {
    var_dump($foo);
}

func(5);
// result: 5

func('bar');
// result: 'bar'

func(NULL);
// result: ERROR

Figure 2: Union Type Operators

Match Statements

Switch statements have been a staple to PHP and several other languages for decades. PHP 8 includes an improved version of this age-old control structure: the match expression (See Figure 3). 

Match expressions function similarly to switch statements, but they differ significantly from switch statements in that they are expressions used to resolve to a value, instead of a statement that operates as a control structure that runs lines of code. Because of this, setting the value of a variable with the return value of a match statement when it is declared is now possible.

$bar = 8.0;

$foo = match($bar) {
    8 => 'int 8',
    8.0 => 'float 8',
    '8.0' => 'string'
};

var_dump($foo);
// result: float 8

Figure 3: Match Statements

Pattern matching is an integral concept in many strongly typed languages, such as Rust, Haskell, and OCaml. The addition of match statements to PHP indicates the language is taking inspiration from other languages when making improvements. Though PHP match expressions aren't quite as powerful as similar syntax in other languages, this is still a huge leap forward in modernizing PHP. 

The fact that they can return a value and don't need break statements should eliminate many unnecessary lines of code and allow for better readability. For switch statements, the default case was optional and could potentially lead to undesired cases if not handled properly. However, with match expressions, an error will be thrown when no default case is provided, naturally encouraging the creation of more secure code.

Pure Intersection Types

Pure intersection types were added in PHP 8.1 and they provide an interesting way of strengthening the object-oriented type system in PHP (See Figure 4). When an object that is being passed to a function needs to implement two or more specific interfaces, a pure type intersection operator can be used to combine those interfaces into one type. 

Instead of having to create a new interface in a separate file, intersection types can be easily created when needed. Having more opportunities to create new types allows developers to be more expressive with their code and improves legibility, which can save time and effort over the long run.

class Bar implements Stringable, Countable {
    function __toString() {
        return 'this is an object';
    }
    
    function count(): int {
        return 0;
    }
}

class Foo {
    public function __construct(
        public Stringable&Countable $bar
    ) {}
}

$foo = new Foo(new Bar());

var_dump('toString: ' . $foo->bar);
// result: 'toString: this is an object'

var_dump('count: ' . count($foo->bar));
// result: 'count: 0'

Figure 4: Pure Intersection Types

New Functionality

Aside from syntax, new functionality has been introduced in PHP 8 and 8.1 that provides an opportunity for Drupal to improve drastically. Namely fibers and class attributes present new ways to enhance underlying code directly.

Fibers

Another way that PHP has differed from several other server-side languages is through the lack of native support for managing concurrency or suspend execution of code. Using callbacks can allow developers to write asynchronous code. However, there is no API enforced by the language for this functionality; it's managed entirely by other packages. The addition of the Fiber class in PHP 8.1 opens a new world of non-blocking code possibilities. 

In the Drupal community, issue threads are getting traction as developers advocate for using fibers to make time-consuming tasks like cache rebuilds, queue runners, and automated cron runs more performant and easier to manage.

Despite some exciting use cases of fibers, we aren't likely to see them used extensively in the everyday development of Drupal. Even the PHP documentation states "Libraries will generally build further abstractions around Fibers, so there's no need to interact with them directly." Fibers are introduced through 8.1, so you might not see it in Drupal 10 core until 8.1 becomes the minimum version needed. PHP is striving to make up for lost time with fibers and we can expect to see revolutionary architectures in future applications thanks to their introduction in PHP 8.

Class Attributes

A huge improvement in Drupal 8 was the Plugin API, which includes a discovery system for finding plugin classes. PHP 8 class attributes can make this process even better. Several types of plugin discovery exist, such as Annotated Class Discovery. This discovery type makes use of a class annotation in a comment before a class definition. 

Since class metadata is inside of a comment, a separate library provided by the Symfony framework called Doctrine is needed to parse and use class annotations. With class attributes, this functionality is now a native part of the language. Class attributes allow for much more flexibility in specifying metadata for a class, without the use of a third-party library. 

Additionally, they can be used for tasks other than plugin discovery, since attributes can be placed on class methods as well. When used in that context, attributes can specify route handlers, event subscribers, and a whole range of other Drupal functionality. Other object-oriented languages like Java, C#, and even JavaScript have versions of class attributes. The addition of class attributes to PHP 8 is further proof that the language is striving to modernize and provide developers with tools to build better systems.

JIT Compilation

The maintainers of PHP might have added all kinds of new and cool syntax and functionality, but underneath it, all was still the same execution process of language parsing, AST creation, OPcode transpilation, OPcache, and execution inside a VM. Little had previously been done to enhance the step between the traditional Zend VM and the CPU, but with PHP 8 a new door has been opened. 

As hardware has gotten exponentially more powerful over time, compilation has gotten quicker and quicker. Because of this Lua, Python, JavaScript, and other transpiled languages have made use of a Just-In-Time (JIT) compilation step that happens after a script has been queued for execution and before it is actually executed. 

JIT compilers offer huge speed boosts since all optimization strategies that have been part of compilers, in general, can be applied to scripting languages as well. PHP 8 added a JIT compiler to the language, which will allow it to make huge strides in code performance in the same way that many other popular languages already benefit from.

While PHP will become much more performant with version 8, the web frameworks that use PHP won't see the same kind of speed boost. The limiting factors to server-side processing speed in Drupal will still be the same as they were before: database queries, bootstrapping on request, and other architectural constraints.

Benchmarks against other similar frameworks have shown only a 3-5 percent increase in page render speed, so the same can be safely assumed for Drupal. For functionality requiring complex processing that is written purely in PHP though, the JIT compiler will make a huge difference. Image processing and data analysis can now be reasonably implemented in PHP thanks to the new JIT compiler.

Switching to PHP 8

As always, teams will need to rigorously test their sites with new versions of PHP locally, as well as in higher-level environments afterward. Switching to PHP 8 is possible to do today under Drupal 9 and is fairly easy to do locally, especially if you’re using Lando and Drupal VM. Configuring the PHP version used by an environment in Acquia Cloud is also a relatively straightforward task.

Whether it’s using new syntax, experiencing the speed boosts of the JIT compiler, or trying out new features of the language, PHP 8 has many improvements for developers to be excited about. PHP is continually improving, and keeping up with its growth will make for a better Drupal experience, which in turn will make the life of developers easier as well. I recommend upgrading to PHP 8 and giving all of these new and modern features a try as soon as you can!

Feb 16 2024
Feb 16

It’s been ten years since the release of Drupal 7. In that time, building experiences for the web and digital marketing needs have grown more complex. The Drupal platform has had to evolve to keep pace with market trends and other content management solutions. This concept of an evolving platform aligns perfectly with "Embrace Change," which is Principle 7 from Drupal’s Values and Principles. There’s a long shared saying in the community stating that, "The drop is always moving." Drupal (the drop) needs to grow to remain competitive and developers need to embrace these changes to take advantage of the latest features and functionality.

When it comes to embracing the latest Drupal offerings, as a community we still have a lot of work to do. Of the over 950K sites reported on the Drupal Usage Statics page for November 21, 2021, roughly 520K of those websites are running some version of Drupal 7. Drupal 8 support ended November 2, 2021, and after an extension due to COVID, Drupal 7 support will end in November of 2023. This means for organizations running any version less than Drupal 9, now is the time to be planning the next steps.

Why Migrate to Drupal 9?

Before jumping into the process of planning and executing a migration, it’s important to understand the value of this effort to your business. This is the perfect time for an organization to evaluate if it makes sense to continue investing in Drupal and understand what they’ll receive from their investment. There are a number of compelling reasons to invest in moving to Drupal 9, but here are some highlights!

Drupal Is API-First

The API-First initiative, introduced in Drupal 8, simplified using REST APIs to pull content out of Drupal and into other systems. This means fully decoupling or progressively decoupling is easier in modern Drupal. Additionally, as composable architectures grow in popularity, Drupal enables developers to quickly surface REST endpoints as JSON in core or GraphQL via contributed modules. 

It’s also worth noting the Decoupled Menus initiative aims to prove the model for integrating JavaScript libraries with the RESTful Web Services API. The goals of this initiative are to make the JavaScript developer experience and the process of building decoupled experiences in Drupal rival competing content management platforms.

Drupal’s Continuous Innovation Model

Once you’ve migrated to Drupal 9, future updates (like Drupal 10) will be minor releases. This is due to introducing a continuous innovation model that aims to shorten release cycles, add new features and APIs, and simplify the upgrade path. This development model reduces the total cost of ownership and allows organizations to spend less time maintaining the platform and more time investing in features that will grow the business. 

More in Core With Drupal

Panels in Drupal 7 have been replaced with Layout Builder. This enables site administrators to visually configure content in Drupal by node or content type. Acquia customers can take this a step further by using the Site Studio low-code page building tool. Other enhancements include a native media library that enables content authors to upload and reuse media assets, a modernized administrative theme, improved multilingual support, enhanced accessibility features which comply with WCAG 2.0 and ATAG 2.0, customizable workflow tools, and robust configuration management. 

Where to Start With Your Migration?

Before any code is written or migrations are run, the first step to any successful platform upgrade should be putting together a plan and defining what success looks like. Many organizations will use these projects as an opportunity to make other enhancements to the website. For example, there may be content on your existing site that is out of date or doesn’t receive much traffic based on your analytics. You may manage a taxonomy structure that has grown unwieldy or content types that can be consolidated or removed altogether. In short, we want to ensure any incorrect assumptions, bad habits, or abandoned features don’t make their way into the new experience. 

If it’s been a few years since any visual updates have been made, this could also be a great opportunity to update the look and feel of the website. Moving from PHPTemplate to TWIG and including Layout Builder in core opens up new theming possibilities for developers. This may also be the right time to modernize the look of your site and revisit the information architecture while simultaneously updating the theme layer. As mobile traffic has increased, optimizing for a mobile-first approach that prioritizes performance, responsive assets, and serving the best experience regardless of the device should be part of the implementation plan.

Before jumping in, it’s important to understand if there’s a migration path for any modules in use and identify alternative approaches where there are gaps. This process typically starts with taking inventory of the existing modules and content, verifying and documenting existing functionality, and identifying deprecated code. Though this can be done manually, the Migrate Accelerate tool can significantly streamline this effort for organizations using the Acquia platform. The Acquia solution will recommend Drupal 9 modules and patches based on Drupal 7 and tooling that helps automate the content migration process. There are also some helpful solutions like the static PHP analysis tool, drupal-check, and using the upgrade status module.

The outcomes of this evaluation may reveal that an automated migration may not be the best approach. If the content, information architecture, and designs are changing significantly, it may make more sense to rebuild your site in Drupal 9 instead of porting over lots of content that is no longer relevant. The best approach will vary, but it's important to identify the unique needs of your organization before jumping straight into migrating data.

Migrating to Drupal 9

Due to underlying architecture changes in Drupal 8 and 9, more work is required to migrate a Drupal 7 site. Moving will require migrating both content and configuration to a clean Drupal 9 website. Drupal 9 also uses Composer for PHP package management, which is a shift from managing projects in Drupal 7. You’ll want to be mindful to structure your composer files correctly, but there are some helpful existing composer project templates like the Drupal Recommended Project, opinionated build tools via Acquia BLT, and the Acquia CMS project for Acquia customers. 

There are two approaches to migrating from Drupal 7 to 9, using the Migration UI or Drush. Using the Migration UI assumes you want to migrate everything and first requires enabling the core migration modules and any other required modules needed in the new experience. This includes installing and enabling the Migrate Upgrade, Migrate Plus, and Migrate Tools contributed modules.

To proceed with the UI approach, import the D7 database, visit the upgrade path, enter your credentials, and follow the on-screen instructions to run the migration. The core Migrate modules support most nodes, taxonomy, fields, users, content, and user roles. However, themes, custom modules, and views without a contrib migration path will need to be rebuilt. This also assumes the contributed modules used in Drupal 7 have a migration path to Drupal 9. Any modules without a clear upgrade path will require manual or custom migration. 

For developers looking for greater configuration options, using Drush provides more flexibility to pick and choose your migrations. After importing the D7 database, you can run the following Drush command to get a list of the available migrations:

drush migrate:upgrade --legacy-db-url=mysql://root:root@localhost/drupal7db --legacy-root=drupal7site/docroot --configure-only

From there, you can run Drush migrate-import (or Drush mim) for the individual migrations you’d like to bring over to the Drupal 9 website. For example: 

drush mim d7_user

Lastly, there is a lot of helpful documentation on this process on Drupal.org. There is also a running list of known issues which may be a helpful resource for troubleshooting migration issues. Depending on the amount of content that needs to be migrated and the complexity of the Drupal 7 site, developers should expect some level of trial and error to ensure all intended content was migrated successfully. Stripping down the Drupal 7 site to the bare essentials before starting this process can help greatly streamline this effort. 

The Drupal Drop will Keep Moving

The Drupal project celebrated its 20th anniversary in January 2021. The web has changed significantly over that time as we’ve seen internet fads come and go. However, it’s a testament to the Drupal project leads and the developer community for continuing to push the platform forward so that it remains relevant today. 

There are some exciting initiatives planned, including making Drupal easier for new users with the Easy out-of-the-box initiative, making it easier to find and install relevant modules with Project Browser, and simplifying the Drupal contribution process with GitLab Acceleration. For any organization evaluating a migration from Drupal 7, this should be the last significant upgrade needed to take advantage of all the new and exciting features now available in modern Drupal.
 

Feb 16 2024
Feb 16

As the Drupal landscape continues to evolve, we have seen some great advancements in how we build and maintain Drupal websites. From the powerhouse of DrupalVM with Vagrant to the agile world of Lando and Docker, each solution has its own strengths—as well as some tradeoffs that can require some level of technical expertise to navigate. Here at Bounteous, we typically use a Sprint 0 to define and implement the toolset that will be used for the project. During this time, we evaluate the needs of the project, as well as any client requirements that may dictate one solution over another.

As we evaluate these options we consider things like maintainability and flexibility. In some cases, client restrictions prevent us from running any type of virtualization. With any solution, there will be some amount of overhead as we onboard developers and support ongoing development. When faced with virtualization restrictions, a natural solution is to create a custom LAMP or MAMP stack on each developer’s machine. This is often costly to maintain and requires a high investment to get started. Fortunately, there is a new option available, designed to give developers the flexibility of a virtualized environment without the technical cost or restrictions.

Enter Acquia Cloud IDE—a web-based development environment designed for Drupal.  Depending on your Acquia subscription, your development team will be allocated a specific number of environments that can be created and destroyed on demand. When you create a new IDE, Acquia provides a container-based environment on cloud infrastructure that matches a standard Acquia Cloud server. Each IDE comes allocated with 4GB of memory, two CPUs, and 60GB of disk space. It also comes preinstalled with all the development tools you need for high-grade Drupal—including Composer, Drush, npm, and even ChromeDriver for running automated tests.

Once the environment has been provisioned, a developer is given a link to open their IDE and begin working. The IDE itself is based on Theia, an open-source web-based IDE developed by the Eclipse Foundation. The project is extremely active, with over 5000 commits, 90 pull requests, and five releases this year alone. These are all great signals of a strong project with great backing. The IDE itself is modular, highly customizable, and feels a lot like Visual Studio. It even allows you to load some of the Visual Studio code extensions you are familiar with (in .vsx form). Though you likely won’t need to add anything, Acquia does a good job of preconfiguring the IDE with all the things you need for a Drupal build.

On the first launch of your IDE, you are greeted with a “getting started” page that gives you multiple one-click setup buttons to make your life easier. The first button creates an SSH key in the IDE environment and associates the key with your Acquia account. This key can also be manually added to any external repositories such as Bitbucket or GitHub. Once your key has been added, you can use a second button to clone your Drupal codebase and database directly from your Acquia subscription. From here you have a fully functional, personal development environment and you are ready to write some code! The IDE gives you direct access to the CLI, and even provides a command to enable Xdebug.

Thoughts and Impressions

It’s pretty easy (and warranted) to be skeptical of a solution like this for a development environment. New IDEs and environments mean new ways of working and ultimately friction when it comes to accomplishing work. It’s extremely important for developers to have complete control over their development experience in order to maximize efficiency. I personally rely heavily on keybindings and shortcut commands to deal with some of the limitations my disability creates.

All things considered, I’ve found transitioning to cloud IDE to be mostly painless. I have been able to customize various shortcuts to match the keybindings I typically use (Shoutout to my dotfiles). I do miss some of the more intelligent features PHPStorm offers me like comment generation and fast file switching, but there is nothing that prevents me from writing solid code.

Skepticism included, I am extremely excited about this product and wish I could use it on some of my personal projects. The ability to have an on-demand development environment that takes little to no setup time is a game-changer. Even as someone with deep Unix and DevOps knowledge, I constantly find myself in battles with getting local environments to "just work." As much as I enjoy investigating and resolving issues that come up with Lando or DrupalVm, I’d much rather spend my time building amazing websites. Acquia Cloud IDE makes that possible.

Opportunities for Improvement

No solution is perfect, and running an IDE in a browser runs into some pretty expected problems. Some of the more complicated tasks like file browsing and terminal interaction require communication with the server. This can cause problems like console input lag or slow/finicky code completion. These problems can be exacerbated by unstable internet connections, leading to warranted frustration. This has been a pretty serious and ongoing issue that Acquia is working on fixing.

The other part I wish I had more control over is the setup process. While the IDE makes it easy to clone code directly from your Acquia environment, it doesn't easily allow you to clone from a BitBucket or GitHub repository. It would be great if there were some way to customize the welcome screen and button actions. My goal is to onboard developers as quickly and painlessly as possible, and it would be nice to have greater control over this process.

Final Thoughts

Acquia Cloud IDE has amazing potential and has already proven to be a valuable tool. We are a couple of weeks into using it on one of my clients, and we were able to successfully onboard 12 developers—for many of whom it was their first Drupal project. The ease of onboarding and consistency of environments across both Windows and OSX was a breath of fresh air. I’m excited to continue to use this tool on future projects!

Pages

About Drupal Sun

Drupal Sun is an Evolving Web project. It allows you to:

  • Do full-text search on all the articles in Drupal Planet (thanks to Apache Solr)
  • Facet based on tags, author, or feed
  • Flip through articles quickly (with j/k or arrow keys) to find what you're interested in
  • View the entire article text inline, or in the context of the site where it was created

See the blog post at Evolving Web

Evolving Web