Trivia Night judges Hilmar Hallbjörnsson, John Cook, Anthony Lindsay, Tony Barker and Tom Bamford applaud the volunteers (including themselves). Photo by Philippe von Bergen

A special thank you to Marine Gandy, who co-MCd; Hilmar Hallbjörnsson, Anthony Lindsay, Tony Barker, Tom Bamford and John Cook who judged the answers; and to runners Alison Visser, Ricardo Galán, Karen Leech and Stella Power, who kept the answer sheets flowing. 

Thank you to everyone who volunteered and attended. It was a great way to bid farewell to DrupalCon Europe.

Conclusion 

DrupalCon Barcelona 2024 was a great one and besides DrupalCon Dublin, which we helped organise in 2016, was one of our busiest. 

Having said that, we’re looking ahead to DrupalCon Vienna 2025 and can’t wait to reconnect with the Drupal community again.

Series Overview & ToC | Previous Article | Next Article

In this article, we are completing field-related migrations by importing formatter settings. This step builds on our previous work with view modes and field groups, bringing us closer to a functional Drupal 10 site. As we go through the process we will also identify other configuration elements used by field formatters that don’t have an automatic migration.

Remember, if you have been following our series, you have already migrated view modes—a prerequisite for field formatters. The Migrate Skip Fields module will also be used to handle content model changes in the new site.

Before we begin

Familiarity with site building concepts related to fields is assumed. Refer to article 16 for a high level overview. Today's article also touches on view modes and date formats.

Field formatter migrations

A formatter determines how field data is rendered by Drupal. Each field type can be supported by one or more field formatters. For example, an entity reference field can print only the entity ID, its label as plain text or as a link, or the representation of the entity as specified by a view mode. Some field configuration might affect which formatters are available. For example, entity reference fields that point to taxonomy terms can use the RSS category formatter.

Technical note: The FormatterInterface interface includes a isApplicable method that determines if a formatter can be used for a field taking into account its configuration.

We use upgrade_d7_field_formatter_settings to migrate field formatter settings. Copy it from the reference folder into our custom module and rebuild caches for the migration to be detected.

cd drupal10
cp ref_migrations/migrate_plus.migration.upgrade_d7_field_formatter_settings.yml web/modules/custom/tag1_migration/tag1_migration_config/migrations/upgrade_d7_field_formatter_settings.yml
ddev drush cache:rebuild

Note that while copying the file, we also changed its name and placed it in a migrations folder inside our custom module. After copying the file, make the following changes:

• Remove the following keys: uuid, langcode, status, dependencies, cck_plugin_method, and migration_group. Notice that for field migrations, we preserve the field_plugin_method key.
• Add two migration tags: component_entity_display and tag1_configuration.
• Add key: migrate under the source section.
• Update the required migration_dependencies to include upgrade_d7_field, upgrade_d7_field_instance, upgrade_d7_view_modes, and the migrations that create configuration entities.

In addition to the updates above, remember that the Migrate Skip Fields module is installed on the site. Via hook_migration_plugins_alter, it modifies the field formatter migration to prevent some fields being imported. In particular, those excluded by the migrate_skip_fields_by_name setting as explained in article 17.

For field formatters, the module does not act on the migrate_skip_fields_by_type setting. The original migration already accounts for not importing formatter data for a field whose storage setting was not migrated. This happens in the field_type_exists pipeline of the process section.

We are going to make a small addition here. The last process plugin in this pipeline is skip_on_empty. We will add a message configuration to log when a field is skipped because its storage setting is missing. The logs are added to the migration tables and can be viewed from the command line or the migration messages admin interface.

After the modifications, the upgrade_d7_field_formatter_settings.yml file should look like this:

id: upgrade_d7_field_formatter_settings
class: Drupal\migrate_drupal\Plugin\migrate\FieldMigration
field_plugin_method: alterFieldFormatterMigration
migration_tags:
 - 'Drupal 7'
 - Configuration
 - component_entity_display
 - tag1_configuration
label: 'Field formatter configuration'
source:
 key: migrate
 plugin: d7_field_instance_per_view_mode
 constants:
   third_party_settings: {  }
process:
 # @modified
 field_type_exists:
   -
     plugin: migration_lookup
     migration: upgrade_d7_field
     source:
       - field_name
       - entity_type
   -
     plugin: extract
     index:
       - 0
   -
     plugin: skip_on_empty
     method: row
     message: "Field storage configuration does not exist."
 entity_type:
   -
     plugin: get
     source: entity_type
   -
     plugin: static_map
     map:
       field_collection_item: paragraph
       paragraphs_item: paragraph
     bypass: true
 bundle:
   -
     plugin: migration_lookup
     migration: upgrade_d7_field_instance
     source:
       - entity_type
       - bundle
       - field_name
   -
     plugin: extract
     index:
       - 1
 view_mode:
   -
     plugin: migration_lookup
     migration: upgrade_d7_view_modes
     source:
       - entity_type
       - view_mode
   -
     plugin: extract
     index:
       - 1
   -
     plugin: static_map
     bypass: true
     map:
       full: default
 field_name:
   -
     plugin: get
     source: field_name
 options/label:
   -
     plugin: get
     source: formatter/label
 options/weight:
   -
     plugin: get
     source: formatter/weight
 plugin_id:
   -
     plugin: process_field
     source: type
     method: getPluginId
 formatter_type:
   -
     plugin: process_field
     source: type
     method: getFieldFormatterType
 options/type:
   -
     plugin: static_map
     bypass: true
     source:
       - '@plugin_id'
       - '@formatter_type'
     map:
       taxonomy_term_reference:
         taxonomy_term_reference_link: entity_reference_label
         taxonomy_term_reference_plain: entity_reference_label
         taxonomy_term_reference_rss_category: entity_reference_label
         i18n_taxonomy_term_reference_link: entity_reference_label
         i18n_taxonomy_term_reference_plain: entity_reference_label
         entityreference_entity_view: entity_reference_entity_view
       email:
         email_formatter_default: email_mailto
         email_formatter_contact: basic_string
         email_formatter_plain: basic_string
         email_formatter_spamspan: basic_string
         email_default: email_mailto
         email_contact: basic_string
         email_plain: basic_string
         email_spamspan: basic_string
       field_url:
         url_default: link
         url_plain: link
       field_collection:
         field_collection_view: entity_reference_revisions_entity_view
       addressfield:
         addressfield_default: address_default
       telephone:
         text_plain: string
         telephone_link: telephone_link
       entityreference:
         entityreference_label: entity_reference_label
         entityreference_entity_id: entity_reference_entity_id
         entityreference_entity_view: entity_reference_entity_view
       file:
         default: file_default
         url_plain: file_url_plain
         path_plain: file_url_plain
         image_plain: image
         image_nodelink: image
         image_imagelink: image
       datetime:
         date_default: datetime_default
         format_interval: datetime_time_ago
         date_plain: datetime_plain
   -
     plugin: d7_field_type_defaults
   -
     plugin: skip_on_empty
     method: row
 hidden:
   -
     plugin: static_map
     source: '@options/type'
     map:
       hidden: true
     default_value: false
 options/settings:
   -
     plugin: default_value
     source: formatter/settings
     default_value: {  }
 options/third_party_settings:
   -
     plugin: get
     source: constants/third_party_settings
 options/settings/view_mode:
   field_collection:
     plugin: paragraphs_process_on_value
     source_value: type
     expected_value: field_collection
     process:
       plugin: get
       source: formatter/settings/view_mode
destination:
 plugin: component_entity_display
migration_dependencies:
 required:
   - upgrade_d7_field
   - upgrade_d7_field_collection_type
   - upgrade_d7_field_instance
   - upgrade_d7_node_type
   - upgrade_d7_taxonomy_vocabulary
   - upgrade_d7_view_modes
 optional: { }

Now, rebuild caches for our changes to be detected and execute the migration. Run migrate:status to make sure we can connect to Drupal 7. Then, run migrate:import to perform the import operations.

ddev drush cache:rebuild
ddev drush migrate:status upgrade_d7_field_formatter_settings
ddev drush migrate:import upgrade_d7_field_formatter_settings

No errors after running the migration. Great! Feel free to have a look at the logs using the drush migrate:messages command.

Similar to other field-related migrations, we should confirm that the result of migrating field formatter settings is correct. There are two places you should look at. Using the Event content type as an example, go to:

1. The manage display page where you can make adjustments to the migrated field formatter configuration.
2. The view page for a session node where you can see the current state of the field formatter configuration. At the moment, we have not migrated nodes nor other content entities. Feel free to create some content to see how it is rendered.

This is where having familiarity with site building concepts and past experience will help. Below is a screenshot of an Event node comparing how some of the fields attached to the content type are rendered.

Notice that the Date field in Drupal 10 shows the time even though the field type is supposed to store a date value only. This is because the Default long date format used to render the field is configured to render a time component. In Drupal 7, the Date field is configured to use Long date format, which can also render a time component; however, it is hidden when the date field is configured to store a date value only. This highlights how formatters can behave differently between Drupal versions and the importance of carefully reviewing the migrated configuration.

For the example above, we could hide the time component for the Date field in multiple ways. One option is to create a new date format which does not print the time. Another option is the Custom date formatter for the date field and use a PHP datetime pattern that does not print the time like l, F j, Y. The first option is recommended if you plan to reuse the same date format in multiple places. The second option can be used if you are certain that there is no need to reuse the pattern.

For the purpose of this example, we are going to go with a third option: use a different date format. Because we are using the Olivero theme, we can use the Olivero Medium date format which will hide the time and the day of the week. An acceptable compromise for the example.

Technical note: Drupal 10 does not provide an automated upgrade path for custom date types and formats from Drupal 7. They are stored in the date_format_type and date_formats tables respectively. You can write a custom migration to read from those Drupal 7 tables and create DateFormat configuration entities in Drupal 10. Or you can recreate them manually on the new site. In either case, you will have to identify where the custom date formats were used in Drupal 7 and manually update the corresponding configuration in Drupal 10. At the time of this writing, this issue contains a patch for migrating custom date formats, but no date types.

Below is a screenshot of an Session node comparing how some of the fields attached to the content type are rendered.

Notice that for the Topics field, the label is rendered in bold in Drupal 10, but not in Drupal 7. As for the terms themselves, in Drupal 10 they appear stacked on top of each other and, in Drupal 7, they are listed next to one another. For the Slides field, Drupal 10 shows the file size in parenthesis and not the file icon. In Drupal 7, you see an icon that varies per file type and there is no reference to the file size. These differences are a combination of changes to how formatters are implemented in different versions of Drupal and how themes decide to render some user interface elements.

For our example project, we are not going to take any action here. In real life projects, you are likely going to use a custom theme that will control how interface elements are rendered. Contributed modules like Fences can also manipulate the output of fields. As a rule of thumb, before adding any module to your project, evaluate if the functionality provided outweighs the extra configuration and maintenance required to use it.

Below is a screenshot of a Venue node rendered in Drupal 10.

The Venue content type has a Phone field that is rendered as plain text. This matches the configuration from Drupal 7, but that does not mean that we cannot make improvements as part of the migration. In this case, we can update the field to use the Telephone link formatter to render a link using the tel URL scheme. Users visiting the site with a mobile phone will be able to place the call by clicking on the link. Drupal is producing semantic HTML markup and it is up to the visitor's browser to determine what action to take when the link is clicked. Not obvious from the screenshot above, but the Address field shows the country in Drupal 10. The field formatter in Drupal 7 hides it when the field only allows a single country to be selected. No action to take as part of the example project.

While reviewing the field formatter migration, we identified that date formats are not migrated automatically. Migrations can be complex, and not every Drupal 7 setting has an automated upgrade path. Make sure to thoroughly review the migrated configuration and perform manual updates as needed. To wrap up the migration of fields, remember that storage, instance, widget, and formatter settings are closely interconnected.

Coming up in our step-by-step migration series, we will complete configuration migrations by walking through: media types and image styles, roles and permissions, and text and input formats. Once the remaining configuration is in place, we will be ready to work with content.

Image by Mohamed Hassan from Pixabay

DrupalCon is the biannual conference where leaders in Drupal gather to coordinate, collaborate and present the latest developments in digital and web technologies. This week 1xINTERNET attended DrupalCon Barcelona in full force. But this conference was like none before it, this was Starshots World Premier and it exceeded all expectations.

Migrating from Drupal 7 to the latest version, like Drupal 11, might seem like a big challenge, but it doesn’t have to be. One of the most common obstacles is figuring out how much it will cost. You want to know the price, but you don’t want to give full access to your site just to get an estimate. The good news? You can collect all the necessary information for an accurate project estimate in just 5 minutes. 

The problem: Estimating Drupal 7 to 11 migration costs 

When you're planning a migration from Drupal 7 to Drupal 11, understanding the cost is essential. Many companies ask for full access to your site to make this estimate, but understandably, you may be hesitant to provide that to multiple companies. Without knowing what’s involved, it can feel overwhelming to start the process. 

The solution: Collect info for an estimate in 5 minutes 

To make things easier, we at Droptica have developed a simple tool that allows you to gather all the necessary data without having to give full access to your site. In just 5 minutes, you can generate a file with all the important details needed for a migration estimate. This file can then be sent to any Drupal development company, allowing them to provide an accurate cost estimate based on your website’s setup.

How to use the migration tool: Step-by-step

Here’s how you can quickly gather the necessary data for a migration estimate using our tool:

1. Log in to your Drupal 7 site as an administrator.
2. Ensure the PHP Filter module is enabled. You can check this by visiting /admin/modules. You'll need to have the right permissions to see this page.
3. Navigate to /node/add/page. If you don’t have a page content type, you can create a new content type that allows PHP input.
4. Change the "Text format" of the body field to "PHP Code."
5. Paste the contents from the following link into the body field: snippet.php.
6. Save the node. Once saved, a text file will automatically download to your computer. This file contains all the necessary analysis of your Drupal 7 website.
7. Send the text file to the development company of your choice for an estimate. With this file, they can give you a preliminary estimate based on your website's structure and setup.

This method doesn't actually migrate your website, but it gathers all the data the development team needs to provide a reliable estimate for your migration.

[embedded content]

Alternative: Using DDEV for local sites

If you have your Drupal 7 site running locally with DDEV, you can also collect the necessary information without using your live site. Just run the following command:

Copy code

ddev drush php-eval 'eval("?>" . file_get_contents("https://raw.githubusercontent.com/droptica/drupal_7_migration_to_latest/refs/heads/main/droptica-drupal-7-audit.php"));'

This will execute the same script and allow you to collect the data for estimation.

Using the Devel module

If you have the Devel module enabled on your Drupal 7 site, you can also run the script by navigating to /devel/phpand pasting the contents of snippet.php. This is another easy way to gather the necessary information for your migration estimate. In this case remember to remove PHP opening tag “

Conclusion: Get an estimate without sharing full access

Gathering data for your Drupal 7 to 11 migration doesn't have to be complicated. With our tool, you can quickly collect all the essential information in just 5 minutes, allowing any Drupal development company to provide a preliminary estimate. While this initial estimation will give you a good idea of the cost range, most migrations will require a second iteration, including more in-depth analysis. At this stage, you may need to provide a full copy of your site for a more detailed evaluation.

However, after this first round of estimates, you can easily shortlist companies based on their cost range, saving time and avoiding the need to grant full access upfront.

If you’re looking for an estimate from Droptica, simply send us the file generated by the tool. We've successfully handled numerous Drupal 7 migrations and have additional tools that speed up the process, ensuring your migration to Drupal 11 is efficient and cost-effective.

Read more about our Drupal 7 migration services https://www.droptica.com/services/drupal-7-migration/

A new record week: 26 MRs merged! :D Too much to cover, so going forward, I will only write about the most notable changes.

The simplified zoom interface landed thanks to Jesse “jessebaker” Baker and Gaurav “gauravvvv” — with not only better controls, but also a much smoother UX:

Bálint “balintbrews” Kléri, Jesse and Ben “bnjmnm” Mullins integrated the existing “undo” functionality with the component props form, resulting in the UX you’d hope:

Your browser does not support playing videos. You can download it instead.

Now that many fundamental pieces exist, it’s time to build upon the foundations that we have. Five weeks ago, Ben added Redux integration to the component props form, resulting in live updates. That started out with a limited set of form elements supported. Harumi “hooroomoo” Jang added support for one more this week:

The Batch API is a powerful feature in Drupal that allows complex or time consuming tasks to be split into smaller parts.

For example, let's say you wanted to run a function that would go through every page on you Drupal site and perform an action. This might be removing specific authors from pages, or removing links in text, or deleting certain taxonomy terms. You might create a small loop that just loads all pages and performs the action on those pages.

This is normally fine on sites that have a small number of pages (i.e. less than 100). But what happens when the site has 10,000 pages, or a million? Your little loop will soon hit the limits of PHP execution times or memory limits and cause the script to be terminated. How do you know how far your loop progressed through the data? What happens if you tried to restart the loop?

The Batch API in Drupal solves these problems by splitting this task into parts so that rather than run a single process to change all the pages at the same time. When the batch runs a series of smaller tasks (eg. just 50 pages at a time) are progressed until the task is complete. This means that you don't hit the memory or timeout limits of PHP and the task finishes successfully and in a predictable way. Rather than run the operation in a single page request the Batch API allows the operation to be run through lots of little page request, each of which nibbles away at the task until it is complete.

This technique can be used any a variety of different situations. Many contributed modules in Drupal make use of this feature to prevent processes taking too long.

A good analogy I like to use is to compare the batch process to food challenges. In my home town of Congleton there is a cafe called Bear Grills that hosts a food challenge called Bear Grills’ Grizzly Breakfast Sandwich Challenge. This is a 2.7kg sandwich that contains 6 sausages, 6 slices of bacon, 4 eggs, 4 potato waffles, beans, and topped off with cheese.

Eating the breakfast sandwich challenge in one go is certainly difficult, but it certainly sounds easier when you consume the sandwich in 100 smaller meals over the course of a couple of days. This is just what batch processing does; it takes a large amount of items and breaks them up into smaller chunks so they're easier to handle (or digest).

This article is the first in a series of articles that will look at various aspects of the Batch API and how to use it. In this article we will look at the core Batch API and how to get set up with your first batch run.

The Batch Process

The following three steps are involved in the batch process in Drupal.

• Initiate Step - This is where the batch is started. It's best to start the batch from some sort of action like a controller, form, or Drush command as it means that the batch can proceed unimpeded. When the batch starts the site will redirect to the path /batch, so you need to be sure that it's the last thing run in the action or submit handler.
• Processing Step(s) - After the batch is initialised the batch process itself is then run. The number of processing steps can be set in the initiate step, but you can also set a single step and have that step run repeatedly until the task is finished. During the processing steps you can keep track of your progress, including how many items you have processed or how many errors occurred. It's also possible to run multiple different steps that do different actions.
• Finishing Step - The final step is a finish step. In this step you can log what happened in the batch and optionally perform a redirect to another page on the site.

The complexity around working with the Batch API is mostly about how you set up the processing steps. There are a couple of different flavors of initialising a batch run and the processes you create will depend on the tasks you are trying to accomplish.

Core to the Batch API is the BatchBuilder class, so lets start off looking at that.

The BatchBuilder Class

The core of the Batch API in Drupal 8+ is the BatchBuilder class. Using this class we can create the needed parameters that have to be sent to the batch_set() method, which is where the batch operations are started.

Create a BatchBuilder object like this.

use Drupal\Core\Batch\BatchBuilder;
$batch = new BatchBuilder();

The BatchBuilder object has a number of different methods that you use to create the batch setup and operations that you need. Here is a list of the available methods.

• setTitle() - Sets the title of the batch page.
• setFinishedCallback() - Sets the callable code that is run once the batch operation has finished. This is used to log success (or errors) and redirect the user.
• setInitMessage() - Sets the displayed message while processing is initialized.
• setProgressMessage() - Sets the progress message that is displayed during the batch run (if no other message has been set).
• setErrorMessage() - Sets the error message to display if an error occurs whilst processing the batch.
• setFile() - This allows you to set the location of the file that contains your callback functions (ie, the batch operations and for finishing). This path should be relative to the base_path() of the site and so should be built using the \Drupal\Core\Extension\ExtensionList::getPath() method. This will default to "[module_name].module", but if you explicitly state where your batch callbacks are then this setting will not be used as PHP will already know where your callback is located.
• setLibraries() - This sets the libraries that are to be used when processing the batch. Libraries will be included on the batch processing page and by default will include the core/drupal.batch library.
• setUrlOptions() - Sets options that will be added to the redirect URLs.
• setProgressive() - This setting changes the batch to run progressively. Normal batches should be run in a progressive manner, meaning that more than one request is used to process the batch operation. You can turn this off to force the batch to run in a single operation. Whilst this might seem like it defeats the point of running batches, it can sometimes be useful. For example, if you know that you have a tiny batch run you might activate this setting to prevent Drupal bootstrapping too many times.
• setQueue() - An advanced setting that can be used to alter the underlying queue storage system that the batch system uses when running the batch. This is normally set to \Drupal\Core\Queue\Batch for normal batches, but can be set to \Drupal\Core\Queue\BatchMemory if progressive is set to true. It is important to remember that the batch system works using the Drupal queue API with each operation we set being an item in the queue.
• addOperation() - Use this method to set the callbacks for the batch operations that will be run during the batch process.
• toArray() - A utility method that converts all of the settings of the object into an array. This is used to hand over the batch information to the Drupal batch runner.

For example, to set up a minimal batch process you would set up the batch operation object like this.

$batch = new BatchBuilder();
$batch->setTitle('Running batch process.')
  ->setFinishCallback([self::class, 'batchFinished'])
  ->setInitMessage('Commencing')
  ->setProgressMessage('Processing...')
  ->setErrorMessage('An error occurred during processing.');

All you need to do then is set the operations that you would run. As an example, here is a batch operation that counts through the numbers from 1 to 1000 in batches of 100 items each.

// Create 10 chunks of 100 items.
$chunks = array_chunk(range(1, 1000), 100);

// Process each chunk in the array to operations in the batch process.
foreach ($chunks as $id => $chunk) {
  $args = [
    $id,
    $chunk,
  ];
  $batch->addOperation([self::class, 'batchProcess'], $args);
}

Once the batch has been set up we kick off the batch run using the batch_set() method and passing in the output of the toArray() method.

batch_set($batch->toArray());

This will start the batch and run through the operations we set in the addOperation() method calls, before finishing on the method we set in the setFinishCallback() method.

The Batch Process Method

The batch process method is where your processing will be done and is the main body of the batch run. The name and arguments that the method have depend on the arguments array you used when calling addOperation() when setting up the batch.

In the betch setup code we added a number of calls to the method batchProcess(), and passed in an argument array that was 2 elements in length. Here is the call again in isolation.

$args = [
  $id,
  $chunk,
];
$batch->addOperation([self::class, 'batchProcess'], $args);

This mean that the process method lives in the same class as we currently are, and has the following footprint. We'll build up the method to have all the parts we need.

public static function batchProcess(int $batchId, array $chunk, array &$context): void {
}

Argument one is the value of $id, argument two is the $chunk variable, and we always get a final argument called $context, which is passed by reference. The $context variable is where all of the internal tracking for the batch run takes place and we can use it to initialise variables, report on progress, and even stop the batch once it is complete.

When we first start the batch process the $context array will look like this.

Array(
    [sandbox] => Array()
    [results] => Array()
    [finished] => 1
    [message] => 
)

The components of this array have the following functions.

• sandbox - This is used within the batch process methods only. This is normally used to keep track of the progress of the batch run, or to figure out the max number of elements in the batch. Once the batch processing is finished this array will be thrown away.
• results - This is used by the batch processing methods to keep track of the progress of the batch run. The difference here is that this array is passed to the finish callback method, which gives us the ability to report on how the batch process went. As a result, this array is normally used to store the number of successful or failed operations that happened. What you add to this part of the array depends on what you want to print in the finished output.
• finished - This is a special value that is used by the batch system to see if the batch processing is finished. If you set this to a value of less than 1 then Drupal will call the batch method again to finish off the batch. This value is really powerful, but only comes into play when have an open ended batch process. If you set up your batch process with a specific number of items and a set number of operations then this flag will not be used. I will go into this setting in more detail in later posts.
• message - To communicate progress to the user you can set a message to this array variable and this will be shown on the batch processing page (along with the progress bar).

When we first start the batch process there isn't any information in the sandbox and results array items, so we first set up these values in the processing method. We can also add to the message parameter of the $context array since we also know some things about the batch process we are currently running.

public static function batchProcess(int $batchId, array $chunk, array &$context): void {
  if (!isset($context['sandbox']['progress'])) {
    $context['sandbox']['progress'] = 0;
    $context['sandbox']['max'] = 1000;
  }
  if (!isset($context['results']['updated'])) {
    $context['results']['updated'] = 0;
    $context['results']['skipped'] = 0;
    $context['results']['failed'] = 0;
    $context['results']['progress'] = 0;
  	$context['results']['process'] = 'Chunk batch completed';
  }

  // Message above progress bar.
  $context['message'] = t('Processing batch #@batch_id batch size @batch_size for total @count items.', [
    '@batch_id' => number_format($batchId),
    '@batch_size' => number_format(count($chunk)),
    '@count' => number_format($context['sandbox']['max']),
  ]);
  
  // Process the chunk. 
}

The next thing to add is processing the chunk of array items.

Rather than get the batch operation to do anything destructive to the site I decide to just loop through the items in each chunk and get the process to sleep for a few milliseconds to simulate things happening to the site. This means that you can run this batch call as many times as you like without causing lots of content to be added (or removed) from your site. I will go into more concrete mechanisms later in this series of articles so show nodes being created.

public static function batchProcess(int $batchId, array $chunk, array &$context): void {
  if (!isset($context['sandbox']['progress'])) {
    $context['sandbox']['progress'] = 0;
    $context['sandbox']['max'] = 1000;
  }
  if (!isset($context['results']['updated'])) {
    $context['results']['updated'] = 0;
    $context['results']['skipped'] = 0;
    $context['results']['failed'] = 0;
    $context['results']['progress'] = 0;
    $context['results']['process'] = 'Form batch completed';
  }
  
  // Keep track of progress.
  $context['results']['progress'] += count($chunk);

  // Message above progress bar.
  $context['message'] = t('Processing batch #@batch_id batch size @batch_size for total @count items.', [
    '@batch_id' => number_format($batchId),
    '@batch_size' => number_format(count($chunk)),
    '@count' => number_format($context['sandbox']['max']),
  ]);

  foreach ($chunk as $number) {
    // Sleep for a bit (making use of the number variable) to simulate work
    // being done. We do this so that the batch takes a noticeable amount of
    // time to complete.
    usleep(4000 + $number);
    // Decide on the result of the batch. We use the random parameter here to
    // simulate different conditions happening during the batch process.
    $result = rand(1, 4);
    switch ($result) {
      case '1':
      case '2':
        $context['results']['updated']++;
        break;

      case '3':
        $context['results']['skipped']++;
        break;

      case '4':
        $context['results']['failed']++;
        break;
    }
  }
}

As part of the simulation of processing the batch operation I also added a random function that will pick a number between 1 and 4 and increment items in the results part of the context array. As these items will be fed to the finish method we can simulate things not working quite right on the batch run and see the results of that.

This is pretty much it for the batch process method. The Batch API will call each of the operation methods we setup at the start, passing in the array items we set for each operation. When finished, the results will be passed to the batch finish method.

The Batch Finish Method

The batch finish method is the final function that is called when the batch operations finish. This method accepts the following parameters.

• $success - TRUE if all Batch API tasks were completed successfully.
• $results - An results array from the batch processing operations.
• $operations - A list of the operations that had not been completed.
• $elapsed - Batch.inc kindly provides the elapsed processing time in seconds.

Using this information we can setup a pretty simple finished method. All we need to do look to see if the $success variable is true or not. If it is then we can report to the user (via the Messenger service) that the batch finished, log the fact that the batch finished. If the batch failed (for whatever reason) then we print this out as an error, passing in the operation that caused the issue.

Here is a typical finished method, based on the batch operations we ran in the above step.

public static function batchFinished(bool $success, array $results, array $operations, string $elapsed): void {
  // Grab the messenger service, this will be needed if the batch was a
  // success or a failure.
  $messenger = \Drupal::messenger();
  if ($success) {
    // The success variable was true, which indicates that the batch process
    // was successful (i.e. no errors occurred).
    // Show success message to the user.
    $messenger->addMessage(t('@process processed @count, skipped @skipped, updated @updated, failed @failed in @elapsed.', [
      '@process' => $results['process'],
      '@count' => $results['progress'],
      '@skipped' => $results['skipped'],
      '@updated' => $results['updated'],
      '@failed' => $results['failed'],
      '@elapsed' => $elapsed,
    ]));
    // Log the batch success.
    \Drupal::logger('batch_form_example')->info(
      '@process processed @count, skipped @skipped, updated @updated, failed @failed in @elapsed.', [
        '@process' => $results['process'],
        '@count' => $results['progress'],
        '@skipped' => $results['skipped'],
        '@updated' => $results['updated'],
        '@failed' => $results['failed'],
        '@elapsed' => $elapsed,
      ]);
  }
  else {
    // An error occurred. $operations contains the operations that remained
    // unprocessed. Pick the last operation and report on what happened.
    $error_operation = reset($operations);
    if ($error_operation) {
      $message = t('An error occurred while processing %error_operation with arguments: @arguments', [
        '%error_operation' => print_r($error_operation[0]),
        '@arguments' => print_r($error_operation[1], TRUE),
      ]);
      $messenger->addError($message);
    }
  }
}

Remember that the results array here contains information that you put into it in the batch operation step(s). This means that if you want to want to perform different operations or report on different activities then you need to change this code to report on the contents of the different results array.

One final thing in the finished method is the return value, which depends on where you start the batch from. If you start the batch operation from a form then the form redirects will be taken into account and used to send the user to the whatever was set in the form. If the batch operation is initiated from a controller then the return value must be a redirect response as controllers must return either a render array or a response object.

Essentially, if you return a redirect response from the finished method then this will be used and the user will be redirected, but returning a redirect response is optional.

Running A Batch From A Form

It is quite common to initiate a batch operation from a form. Doing so means that we can accept parameters from the user about what to do in the batch, but it also gives a more definite warning to the user that performing this action will result in a (potentially) lengthy process.

Setting a patch operation in a form is pretty simple though, in the submitForm() handler of the form class we just create a new BatchBuilder object and set the batch up.

public function submitForm(array &$form, FormStateInterface $form_state): void {
  // Create and set up the batch builder object.
  $batch = new BatchBuilder();
  $batch->setTitle('Running batch process.')
    ->setFinishCallback([self::class, 'batchFinished'])
    ->setInitMessage('Commencing')
    ->setProgressMessage('Processing...')
    ->setErrorMessage('An error occurred during processing.');

  // Create 10 chunks of 100 items.
  $chunks = array_chunk(range(1, 1000), 100);

  // Process each chunk in the array to operations in the batch process.
  foreach ($chunks as $id => $chunk) {
    $args = [
      $id,
      $chunk,
    ];
    $batch->addOperation([self::class, 'batchProcess'], $args);
  }
  batch_set($batch->toArray());

  // Set the redirect for the form submission back to the form itself.
  $form_state->setRedirectUrl(new Url($this->getFormId()));
}

As this is a form operation we can use the $form_state object to alter the redirection of the batch process once complete. This is understood by the Batch API and will be used as the final destination after the finished method is called (assuming that the finished method doesn't return a redirect response itself).

When we submit this form we see the following batch process running.

Once complete we will be redirected back to the form that we submitted, where a message will show us show many items were processed.

When To Use The Batch API

There are a number of situations that you might want to use the Batch API, I've hinted at a couple in the introduction, but here's a list of some examples.

• Performing an operation on lots of different items of content. For example, updating every page on a site or deleting lots of taxonomy terms.
• If you are interacting with an API that requires lots of operations to complete a task then the Batch API can be useful. This allows you to show the user a progress bar whilst you perform the actions, and can often mask a slow API system or prevent the API from timing out the user's page.
• If you want to accept a file from a user and process the results then using the Batch API can often help break down that file into smaller parts. I have successfully managed to parse a CSV file with 100,000 entries using the Batch API.

When Not To Use The Batch API

Of course, the Batch API isn't always the best thing to use in all circumstances. If you want to process a bunch of items quickly (and give user feedback whilst doing it) then the Batch API is normally the best approach.

If you don't need to give that feedback to the user, or timescales are less important, then just using a queue processor can be a better solution. The Batch API in Drupal is build upon the Queue API so if you build the batch operation it isn't too difficult to swap to a queue processor after the fact.

Conclusion

The Batch API in Drupal is a really powerful component of processing data whilst also giving the user a decent experience. It does away with long page loads and introduces a nice progress bar that will show you how long your user has to wait for it to complete. Drupal makes use of the Batch API in a few places, and even allows certain parts of Drupal (e.g. update hooks) to integrate with the Batch API with very little extra code.

There's quite a lot of information here on how to setup and use the Batch API, but what I have shown here is the simplest version of using batch. Using the above code you can create a form that will run a batch operation that takes a few seconds but should allow you to experiment with the API and see what it does.

In the next article we will look at setting up a batch run so that it can be run using either a form or via a Drush command.

If you want to see the source code for the examples above (or all examples in this series) then I have released them all as a GitHub project that has a number of different sub-modules that show how to use the Batch API in different situations and combinations. Feel free to take a look at the project and use the source code in your own projects. Also, please let me know if there are any improvements to the module that you can think of.

Finally, I'd like to say thanks to Selwyn Polit and his Drupal at your Fingertips book for some of the code examples I have used here. The page on Drupal batch and queue operations is really worth a read.

The statement "Love thy CMS" appeared in an internal Zoom chat about the modernization of my organization's CMS. My co-worker and I were explaining the overarching technical goals for rethinking and modernizing the organization's Drupal implementation. On the call were stakeholders, an SEO specialist, site builders, and content authors. While presenting goals and features, I finally summed it up as "We want you to love your CMS." In the chat, someone simplified that statement into "Love thy CMS!" and the "thy" adds the tongue-in-cheek aspect, being it is hard to imagine loving a piece of software. Yet, Drupal has the potential to be loved, and this concept could become part of Drupal's marketing efforts.

Early on, I implemented the concept of mapping sets, which set up multiple Schema.org types in sequence to test and review the module’s out-of-the-box configuration. As I have worked to implement Schema.org for my client, I’ve realized that the generated Schema.org types and properties need additional configuration to create the ideal content authoring experience and website. While learning more about Schema.org’s history and evolution, it has become apparent that schemas for different sectors are led by working groups that research and recommend additional types and properties. For example, information architects and content experts have collaborated to define comprehensive schemas for the automotive, hospitality, medical, and financial industries. These very thorough industry schemas can feel overwhelming and make it difficult for developers to leverage and understand the available schemas and possibilities. To help developers get started and maintain their organization’s schemas, I’ve implemented a Schema.org Blueprints specific starter kit API, which can either provide the beginning or an example of an approach for implementing Schema.org via Drupal.

Acquia Content Management System (Acquia CMS) is an open source, composable CMS for managing digital content and experiences. It is powered by Drupal and optimized for the Acquia platform.

Acquia CMS consists of key Drupal modules, curated by Acquia to be best-in-class. Acquia keeps these modules updated and tested. Acquia also provides security patches and updates to Drupal as they become available, so your team does not have to.

Acquia CMS 2.0 introduces the new starter kit wizard. With the new starter kit wizard, you can assemble the right combination of modules that you need for your use case, be that traditional Drupal, low-code or headless. You can also add our content model and demo content.

Unlike Acquia CMS 1.0, Acquia CMS 2.0 is not a Drupal installation profile. Acquia CMS 2.0 is a set of post-installation modules setup, and is configured by the Acquia CMS starter kit system. Drupal is installed from the Drupal core Minimal installation profile.

-- https://docs.acquia.com/acquia-cms/ 

Drupal 10 released in December 2022 and ever since, the community has been pushing its users to migrate to the latest version. 

As many as 54% of all Drupal sites are running on Drupal 7. 

Using an outdated version has downsides. Businesses miss out on technological advancements and new features that can speed up and safeguard their digital properties.

With the release of Drupal 10 and the fact that Drupal 7 will reach end of life in November 2023, it is crucial to migrate to Drupal 10 soon. Here’s why enterprises should plan their Drupal 10 migration now, and not wait until the last moment. 

Why should you migrate from Drupal 7 to Drupal 10? 

Drupal 10 brings automated updates, improved user experience, along with several other feature additions. These components will be more secure, user-friendly, and powerful. Let’s dive deep into why enterprises must plan their Drupal 7 to 10 migration. 

1. Community support: As an open source CMS, community support is what keeps Drupal's continuous innovation ongoing. With Drupal community prioritizing and actively focusing on security of newer versions, as and when Drupal 7 reaches end of life, the community support will seize. This primarily jeopardizes the security of your Drupal 7 website. This also means that contributed modules and themes that are currently used in your Drupal 7 website, will also lose support for maintenance. This would bring challenges in website maintenance.
    
2. New features and upgrades: Another consequence of not upgrading to latest version is that certain functionalities may cease to perform as intended. Or there may be better alternatives available. Not only can this cause extra annoyance among website maintainers, but resolving these issues may incur additional expenditures for your company owing to the time and resources required to do so. In Drupal 7, while developers had to manually upgrade/updates or search for modules from drupal.org , Drupal 10 has simplified this with Automated updates and Project browser, respectively. A lot of Drupal 7 features are either incorporated out-of-the-box in Drupal 10 or simply removed to maintain ease-of-use. 
   • Automatic updates: Drupal sites require manual upgrading, which may be challenging, time-consuming, and expensive. Delays in applying security upgrades can lead to hacked sites. The Automated Updates Initiative seeks to give Drupal sites safe, secure automatic updates. In order to minimize the total cost of ownership of maintaining a Drupal site, increase the security of Drupal sites in the wild, and lower the entry barrier for utilizing Drupal, a safe mechanism for automatically deploying updates in Drupal is to be implemented.
      
   • Project browser: Module installation and locating involve too many steps. Some steps call for you to navigate away from your Drupal site and visit Drupal.org. Other procedures, like utilizing Composer from the command line, need technical knowledge. For users who are new to Drupal and site builders, project browser aims to make it simpler to identify and install modules. This eliminates the need to visit Drupal.org or other sites. It is one of the primary Drupal strategic projects that determines the platform's development goals.
      
   • New themes: Olivero & Claro - The Drupal 7 "Seven" theme from 2009 gave off an out-of-date system impression. Seven was replaced by the new "Claro" theme, which was created in accordance with the most recent requirements. The front-end theme, "Olivero," was created to fit with features that are well-liked by users, such as the Layout Builder. The Olivero theme will be WCAG AA compliant.
     The simple finding and installation of modules should empower Drupal newcomers as well as "ambitious site builders" – Dries Buytaert
      
3. Technical Dependencies: Drupal work on current supported PHP versions. Recommended PHP versions are the best choice for building a Drupal site because they will remain supported longer. Drupal 10 is built on PHP version 8.0 while 7 isbuilt on PHP 7 which is also reaching end of life. This creates technical dependencies in supporting the platform better.
    
   • jQuery, jQuery UI, jQuery Forms- Drupal 7 includes old and unsupported versions of these libraries. jQuery's current version is 3.6.x. Drupal 7 includes 1.4.2. Other libraries have comparable challenges. You may minimize this little with the jQuery Update module, although the most recent version is 2.1.x. Drupal 8 and later (as well as many other content management systems) make it simple to provide API access to your content. In the age of "publish everywhere," this is a critical feature. Drupal 7 has some basic API support, but if you want a full-fledged API with write support, you'll have to create it yourself, which adds technical debt and possible vulnerabilities.
      
   • CKEditor 5 update from CKEditor 4 - With a thorough rebuild and an exciting new feature set, CKEditor 5 gives Drupal 10 a modern, collaborative editor experience. Users of programs like Microsoft Word or Google Docs will be used to the new CKEditor's interface. It also offers common tools for collaboration like comments, change suggestions, version histories, and other accepted editing practices. Additionally, it has outputs to.docx and.pdf files for straightforward conversion to print formats. Although the integration is still being worked on, Drupal core 9.3 already has an experimental version if you want to try it out.
      
   • Composer 2 and PHP 8 support - Although backporting of composer 2 to Drupal 8 was successful, PHP 8 compatibility was not. PHP 8 will be required for Drupal 10 because PHP 7 will be discontinued in November 2022.
      
4. Modules that have gone out of support: The Drupal 10 core will be updated to eliminate a few modules that are redundant or are not frequently used. For uniformity, these modules will be transferred to the Contributed Module area. Gathers and presents syndicated material from outside sources (RSS, RDF, and Atom feeds).
   • QuickEdit: In-place content editing
   • HAL - Serializes entities using the Hypertext Application Language.
   • Users may keep track of recent content with the activity tracker feature.
   • RDF – Enhances websites with metadata so that other systems may comprehend their characteristics.

You will have to leave Drupal 7 behind. Eventually, the opportunity cost of continuing to use software that is more than 10 years old is substantial, and once it is considered End of Life (EOL), the risk and expense of an uncovered vulnerability increases rapidly.

There are several possibilities available to you, and you have an additional year to choose and make plans for one of them. The ideal option will rely on the expertise level of your team, the amount of business logic you have included into Drupal 7, and your projected budget.

Conclusion 

Drupal 7 will reach end of life in November 2023, Drupal experts recommend that organizations begin migrating to Drupal 10 soon and not wait till November 2023.

If you want to migrate your website to Drupal 9 and prepare for Drupal 10, you may rely on our Drupal migration skills and expertise.

OpenSense Labs, as a Drupal partner, is committed to providing active support. Contact us at [email protected] for a long-term and fruitful collaboration.

The significance of SEO in digital business is no secret. Organizations invest thousands of dollars just to be on the top of the search engine result pages. Despite several tectonic shifts in consumer behavior, organic search delivers the most traffic. More on that later

SEO is more than just adding keywords.

An important part of doing SEO right is ensuring your technical SEO is set right. 

Apparently, organizations that have websites built on mature CMS like Drupal have to care less about technical SEO. All aspects of Google-identified site and page-level best practices are ensured out-of-the-box.

In this article, we’ll dive deep to understand different Google ranking factors and how Drupal ensures you stay on top of those trends.
 

SEO Objectives

Organic search remains the dominant source since budget restraints many marketers to opt for Google Ads for more visibility on SERP.

Best SEO practices not only ensure higher ranking but are also budget-friendly. 

According to research, 61% of Google traffic comes from organic searches. Before we move to understand SEO objectives, here's a look at organic SEO trends. 

Some of your SEO goals can be: 

• Brand Visibility: It simply means the rate at which your brand is visible to the target audience. SEO immensely helps enterprises to improve their brand visibility.

  The more people are aware of your brand online the better your chances of a higher conversion rate. In this digital age where people consume most of their information online, not having a solid online presence is simply not an option.

  Content marketing notably has a great role to play in brand awareness and when it gets infused with SEO it has the potential to make a significant transformation. 
   

• Better ROI: Good brand visibility paves the way to high ROI. If you use SEO strategically then your conversions will increase. On-page SEO is an effective strategy to rank higher on search engines and drive more organic traffic to your website.

  The more people visiting your website the more likely you will get better conversions. 
   

• Organic Traffic: Despite so many shifts in consumer behavior people still mostly use organic ways to search for any product/service.

  According to content marketing statistics 2022, quality content with optimized images can increase organic traffic by over 111.3%. On-page SEO addresses all of the tactics necessary for improved organic traffic.

  The improved technical aspects of your website contributed to a better user experience, ease to crawl, and thus increased organic traffic.

Let's understand some Drupal SEO modules that you can use to make your website SEO friendly and rank higher on search engines.
 

Site Level Factors & Modules

1. Advanced CSS/JS Aggregation: Slow website load directly affects the search engine rankings. Advanced CSS/JS Aggregation is a must-have module for websites with a lot of CSS/JS files which means this module compresses your frontend files and speeds up your website. 
2. CDN: A content delivery network is a distributed system of servers deployed in multiple data centers around the world. Website performance directly affects your search engine ranking and user experience. A website that takes an eternity to load will eventually lose most of its visitors. A CDN will distribute a load of your website across servers globally to reduce load time. This module will help the website in loading faster and thus improves user experience and website performance.   
3. AMP: AMP also known as the accelerated mobile page is an open-source framework launched by a joint initiative of google and several other tech companies. Accelerated mobile pages are lightweight and designed to give mobile users lighting fast and more engaging experience. This module converts web pages as per AMP standards and helps web pages to load faster on mobile and tablets. 
    
4. Search 404: 404 error occurs when a content of a URL is moved or deleted. It is considered bad for SEO as it hampers user experience and google bots also penalize such websites. When a web page is deleted or moved ‘search 404 module’ will do a search for URLs that are being moved or removed and show the result of the search instead of a 404 error. This improves the site’s SEO by making sure inactive URLs don’t hamper user experience by delivering the content as per the user’s query. 
5. Blazy: Lazy loading is a technique for waiting to load particular parts of the website, especially images- when needed. The Blazy module provides lazy image loading to save load bandwidth and help reduce bounce rate. It also helps in saving bandwidth for important information before the website load completely. 
6. Cloud Flare- This module helps your website load 30% faster, use 60% less bandwidth, and process 65% fewer requests. Cloud flare is a global network designed to make everything you connect secure, fast, private, and reliable. Fast content delivery and Improve SEO are some more features of cloud flare. 
7. XML Sitemap: In the simplest terms site map is an XML file that contains all your website URLs along with additional metadata about each URL. XML site map creates an efficient site map of your website that is easy to crawl and automatically gets added to search engines like google, bing, yahoo, etc. Site map links pertaining to the content, menu items, taxonomy terms, and user profile can also be added. 
    
8. Simple XML Sitemap:  This module helps your website in creating individual site maps for each webpage according to google guidelines and policies. Apparently, a simple XML sitemap helps your website get indexed faster on any search engine. This module creates multilingual site maps for entities, views, and custom links and it supports all Drupal’s content entities i.e. nodes, taxonomy terms, users, and menu links. 
    
9. Robots txt: A robots.txt file tells search engine crawlers which URLs the crawler can access on your site. Use this module if you are operating numerous Drupal sites from a single code base and each one requires a distinct robots.txt file. This module produces the robots.txt file automatically and allows you to change it from the web UI on a per-site basis.
    
10. Schema.org Usage: Pages with micro formatting tend to rank higher on SERP. Schema markup help website create formatted pages that help search engines understand your content easily. This module specifies the mapping between content types and fields with schema.org types and properties. 

11. Menu breadcrumbs:  A website with a large amount of data would immensely benefit from the menu breadcrumbs module. As this module builds a navigational path for visitors that helps the website track users' exact behavior on the website and enhance user experience.

    
     

12. Easy breadcrumb: Navigational design of a website describes how different pages of a website are organized and connected to each other. When a site is easy to navigate it increases visit duration. The easy breadcrumbs module helps in creating an accessible navigational website structure that is easy to navigate. 

13. Link checker: This module is useful to detect broken links from the content. Both internal and external links can be checked via the link checker module. It occasionally removes broken links from your stored content by checking the remote sites and assessing the HTTP response codes. Broken links can easily be checked in the log/report section. In the “my account” section, author-specific broken links are stored. 

14. Menu attributes:  As the name suggests, this module helps you add extra attributes to your menu section like class, ID, name, style, relationship, and target. A well-organized menu helps users’ website accessibility and experience. 

15. Pathauto: User-friendly URLs are extremely vital for boosting your SEO efforts. Pathauto module allows you to generate a URL  based on your content. It is a must-have module for any website to make it SEO-friendly. 

16. Metatag: Search engines usually prefer websites with optimized content and meta description. The meta tag module creates structured meta tags for your website so that your website ranks higher on SERP.  In addition to that this module also provides support to meta tags from other social media sites. You can furthermore control how your content is going to appear on different platforms. 

17. Hreflang: Now if are not sure what hreflang is then it is an HTML attribute used to specify the language and geographical targeting of a webpage. When you have different geographies to target then your website should be multilingual. This module is best for websites with multilingual content. The Hreflang module automatically adds tags to your website’s enabled languages. 

    The multilingual website attracts a larger audience, improves the brand image, and has an edge over competitors. With only 25% native English speakers, it's a great opportunity to reach out to the rest 75%. 

18. External Hreflang: This module allows you to add hreflang for external sites to easily detect spammy and faulty websites. External links connecting spammy websites degrade the user experience and can damage your brand presence and online ranking. 

19. Redirect: Directing visitors and bots from one URL to another is called redirection. The key benefits of redirection are to improve user experience and help search engines better understand website content. The redirect module helps in merging websites, moving domains, deleting existing pages, and switching from HTTP to HTTPS. 

    301, 302, and javascript redirects inform the web browser that a page has moved from one URL to another and let visitors and users land on the right page.

20. Domain 301 Redirect: A 301 redirect sends all the requests from the old URL to the new one. Domain 301 redirect help in redirecting users to relevant pages and page relevance congruent with the user’s query help in good ranking. This module allows sites to 301 redirects to a domain that has been selected as the main domain. 

21. W3C Validator: HTML errors or poorly coded websites can hamper the site quality and bad site quality consequently damages your website’s SEO. W3C validator reduces the code size on your web page and adds value to your content. Small codes help your website loading speed on diverse platforms. It validates your HTML and CSS codes according to international coding standards.

Page level factors 

1. CKeditor: It is a rich text editor that helps users write or edit the content inside the webpage. It has a nice writing interface where you can easily format and style content like adding a head, sub-heads, and numbering and bullet feature for better readability. 
2. Disqus: Pages with lots of comments may be a signal of user interaction and quality. In fact, one Googler said comments can help “a lot” with rankings. Enabling comments on a blog has multiple benefits including the possibility. To engage with your readers and grow a strong community. Disqus module helps you integrate a comment feature on your website that helps your readers to better engage with your content.

   
    

3. Scheduler: This module can help content writers to plan and publish content as per their requirements. The scheduler module makes your overall publishing experience hassle-free and supports both Drupal 7/9. 

   Time Scheduling enables achieving your intended interest group in the circumstances they're on the web, regardless of the possibility of what that time is, hence it has a huge benefit in content marketing. 
    

4. Automatic Alternative Text: Alt text is basically an alternative text for images. The whole purpose of alt text is to improve accessibility by describing what an image looks like to the user who doesn’t have the ability to see it. 

   This module automatically generates an alt text for your images if you missed putting one. Interestingly google prioritize images with meaningful alt text and it can be helpful in ranking higher on google.  
    

5. ImageAPI Optimize: A blog with optimized images has always been the prime factor for higher ranking. Search engines prioritize images that have a proper title, description, alt text, file name, and caption. This module allows you to compress images without compromising image quality with flawless image optimization.
    
6. ImageMagick: This is an open-source software suite that helps edit, display, and convert picture elements and vector files. It’s also helpful in creating image thumbnails, color correction, and liquid rescaling which basically means rescaling the image without distortion. 
    
7. CKEditor Nofollow: A no follow link doesn’t authorize the website it is linking to. You can make no follow the link by Adding the “re=nofollow” code to your website. This module requires no modules outside of Drupal core and is used to add rel="nofollow" to links using CKEditor widget.
    
8. Linkit: Internal links are the inclusion of web pages connected to each other. It can increase the ranking of the other pages within your website. It helps both readers and crawlers to easily find your site. Linkit gives you a nice interface for searching and links to internal content on your website instead of you trying to look for URLs manually. Within the editor section, you can select which URL you want to interlink and you will get the asked result.  
    
9. Editor advance Link: This module helps you convert normal hyperlinks into a styled button. This module allows content creators and editors more control over link appearance or functionality. 
    
10. CKEditor Entity Link: Drupal entities (content, tag, files) can be easily linked with the help of CKEditor Entity Link. This module is compatible with Drupal 9 and with all content entity types. It allows you to choose which entity types and bundles to search for and also provides an autocomplete box to make entity selection easier.

Drupal SEO Checklist Modules 

1. SEO Checklist: This module is compatible with Drupal 8/9. As the name suggests Drupal SEO checklist module creates an automated SEO optimization checklist so that you can optimize your website hassle-free. If you are someone who likes to follow organized checklists for website optimization then this module is a must-have. 
    
2. Real-time SEO for Drupal: If you like writing your content according to SEO guidelines then this module is quite helpful. SEO is a great source for organic reach and a higher SERP ranking is the prominent source of it. While writing, real-time SEO for Drupal provides inbuilt SEO-friendly suggestions as per best SEO standards.
    
3. Requires on Publish:This module is required when your content is published or getting published. Requires on publish can be used when you have fields on your pieces of content, such as tags or SEO information, that editors don't need to fill up until the material is published. 

Conclusion

Drupal comes with countless SEO benefits and it delivers the best SEO results. All the modules that we discussed encompass all the features that can help you achieve the best quality results in 2023 and beyond. 

With changing Google updates and SEO trends, you need a technology partner that makes sure your digital game is top-notch. 

Our Drupal expertise ensures that your site measures up to Drupal’s capabilities in SEO and you leverage them for the top-most SERP rankings.

Looking to enhance your website’s visibility on Search Engines? Get the SEO results you want.

Contact us at [email protected] and let our experts help you out with SEO.

The way companies are developing their products is changing. That’s because more people are accessing websites in more ways than ever before. To create and innovate at a faster pace, developers are leveraging reusable components. Pattern Lab is one such front-end framework that uses atomic design architecture to execute the component-based design. Reusability and portability of components are the prime reasons for its fast-gaining popularity. 

In this blog, we’ll cover what Pattern Lab is, and how developers can use it with Drupal to create their own frontend library and accelerate their product development. 

What is Pattern Lab?

Pattern Lab is based on Brad Frost’s Atomic Design concept. Pattern Lab proves to be one of the best dynamic prototyping and organization tools for professionals. It is easily available for download on GitHub and can be used as part of existing or new projects. 

It helps in transforming pattern templates, authored by developers, into a full-featured, static site. Easy to learn, it can be used in different types of projects. In fact, it can also be used as a front-end style guide, a rapid prototyping tool, and the actual templates powering one or more live sites. It uses atomic design for accelerating the process of creating modular designs.

Now, let’s break down the above visual building blocks:

• Atoms: They are the basic building blocks of design. For example, UI elements such as buttons, search fields, form elements, and labels.
   
• Molecules: These are groups of atoms that work together for performing a particular action. For example, search navigation involves a combination of atoms such as a search button, a search field, and a label.
   
• Organisms: These are molecules and atoms grouped together to define sections of the application. They’re more complex and also have more interactions. For example, a footer a header, or a related blog post section.
   
• Templates: Groups of organisms form Templates. They are placeholders for organisms. For example, a login page template, a blog page template, or a shopping cart page template.
   
• Pages: When we combine a template with real content, we get a page.

Pattern Lab with Drupal

Pattern Lab has become popular in the Drupal community, since the release of Drupal 8 with Twig. The combination of Pattern Lab and Drupal leads to better performance of Drupal websites that are complex in nature. Pattern Lab ensures that its Twig templates and CSS can be consumed like a service by Drupal.

Contributed theme such as Emulsify Drupal that comes with inbuilt the Pattern Lab architecture. Emulsify is basically a component-driven prototyping tool that uses atomic design principles and modern frontend practices in order to build a living style guide. It can be executed easily into any CMS for rendering twig files since it adopts the methodology where the smallest components are atoms, which are assembled into organisms, molecules, templates, and pages.

Emulsify authorizes us to manage and assemble components in a way that improves the workflow by integrating Pattern Lab. So, the Emulsify-based project works with custom template names that are very particular to the project, clients, and developers. This helps in segregating the category-wise patterns (modules) and also increases the expertise of the process.

When the templates are ready for production, Emulsify then connects them to Drupal in a non-complex way as a Twig function (include, extend, or embed) and connects the Drupal templates to the component files.

Emulsify prioritizes a "living style guide" approach where the style guide components are basically the same ones in use on the live websites. And we do not need to worry about the components becoming outdated or more unusual than the normal style guide.

Why should we use Pattern Lab?

Let’s now look at why should we use Pattern Lab.

1. Dynamic Data: Patterns are supposed to be authored to work with dynamic data. Example data files are easily customizable, included, and available to templates. Also, we will find a global set of data and the capability to customize per component, and variant. This will further encourage writing templates in such a manner that they can also be used outside of the pattern lab, with real data.
    
2. Organization and Presentation: A high-level structure, or groups, based on "Atomic Design" principles is offered in Pattern Lab. We can choose to work within that structure or change the terminology to whatever fits our wants by directly renaming file system directories. These groups happen to turn into dropdown menus, that expands in order to show all the pattern templates in that group and also allow navigating to them. This indeed makes it very simple for the team members to browse and discover what patterns actually exist.
    
3. Proper documentation: Documentation can be easily added at group and component levels, as wished, by simply adding a markdown file, with the same name. This documentation happens to be exposed in the static site, along with the source code of the template.
    
4. Variants: It’s very common to have several variants of a pattern. For instance, in a typical "Hero" pattern we might just have a "light" and "dark" version. So, basically, Pattern Lab supports variants, which it calls "Pseudo Patterns" and displays them very clearly in the static build. 

Conclusion

By implementing Pattern Lab, teams can quickly prototype and iterate without multiple rounds of expensive redesigns with the help of traditional design flats. It enables us to be more efficient when it comes to multi-device testing and cross-browser and also makes the job of a front-end developer a lot easier and more fun. 

Pattern Lab supports keeping designers, developers, and stakeholders on track in regard to visual decisions. So, if we prioritize brand consistency, and value design, and wish to have a website that works in a very effective way both on the front-end and the back-end then Pattern Lab is the right choice.
 

Last week we released a new version of OpenLucius: a lean and fast Drupal social collaboration distribution with features like: groups, social posts, messages, group chats, stories, file -and folder management, notebooks, categories, activity streams, notifications, @-mentions, comments and likes.

OpenLucius 2.0 has been in production for the last ~5 months, it's stable enough to go into beta! We also keep on improving: what we globally did since last release:

• Added new features;
• Enhanced existing features;
• Tweaked UI / Design.

All work we did was based on feedback we got internally, from our customers -and trial users. And we plan to keep it this way, so if you have ideas for new/better features: let me know!

The fastest way to explore OpenLucius is by trying it via the product site. And since a lot has changed, I though I'd make it easy on myself by just showing off with current main features -with the newest on top, here you go:

Task / Kanban Board (*Sneak peak*)

You can already try this task board, but it needs work to get it to an open source release. We plan on releasing this as an add-on contrib module:

@-mentions (*new*)

What we really missed in previous version where @-mention, so that's now included in texts and chats, with autocomplete:

@group mention: As you can see, you can also mention everyone in current group.

Technical background: via Drupal core's CKEditor this was hard to accomplish, so we tested out other editors and came up with open source editor Summernote, a light-weight editor based on Bootstrap. It's extendable, able to facilitate inline-editing and it's also very nice that it automatically inherits theme styling (since it's not loaded via an iframe). 

Also, we are building a Kanban/Scrum board with highly interactive modals and for example: inline editing of card descriptions and comments. For that we also needed a lean editor.

And last but not least: we could tweak the editor UI, making it blend with the theme smoothly.

Summernote also facilitates drag-and-drop images & texts:

Drag/drop images (*new*)

So drag-and-drop images is now available in all text editors:

It also has some great, user friendly, inline image options:

General settings (*new*)

Set global colors, homepage tabs and homepage image:

Order book pages (*new*)

You can now order book pages easily, with unlimited depth:

Groups

1. Group name, with drop down for group settings.
2. Group sections, with activity badges that you can turn on/off per group.
3. Group activity stream, bundled per day.

Activity streams (global and per group)

Homepage with activity stream example:

1. Home banner, configurable;
2. Stories;
3. Activity stream, personalised, bundled per day, per group;
4. Your Groups, with link to group archive;
5. Social posts, global, can also be turned off.

Social posts

Messages

Group chats

Stories

File -and folders management

Notebooks

Overview:

1. Hierarchical book pages;
2. Order pages modal;
3. Like and comment;
4. Add file attachments to comments and notebooks.

Order pages easily, with unlimited depth:

Use notebooks for example for:

• Project documentation
• Manuals
• Notes
• Web links
• Agreements
• Minutes
• Ideas
• Brainstorm sessions
• Onboarding information
• House rules
• Customer information
• ...whatever needs text.

Notifications (non-disturbing)

Comments

Likes

Get it, got it, get that!

That's it for now, if you want to test OpenLucius this instant, that of course is possible via the product website. Or download and install OpenLucius yourself via the project page on Drupal.org

Do you want to serve personalized experiences to your users? Are you managing a large amount of data, served from disparate systems? Is your IT team unable to support you with fast changes to your marketing platform? Are you worried about data ethics and how your technology is geared to ensure standardization? Are you looking to quickly prototype your marketing platform and test it out for your specific use case?  Drupal 9 is here to solve many of your content problems of the 20s.

Drupal 9 is scheduled to be released on June 3rd 2020.  Drupal’s next major release coming with features aligned towards a future-proof offering. Here are 9 things to watch out for in Drupal 9.

1. User Experiences for First time Users

You never get a second chance to make a first impression. First-time users, beginners, evaluator experience with Drupal is this context would facilitate overall increased adoption of Drupal.
In Drupal 9 there is going to be an improved User experience for First-time users. Some of the specific features in the road map include installation profiles for common use cases, separation of journeys by roles and an upgraded ‘Try Drupal’ experience which helps users familiarize themselves with the platform.  Installation profiles means a ready to use bundle of Drupal that solves for specific use cases like profile for conferences, profile for a government project, profile for setting up a multilingual project, etc. This will make it easier for the first time user to not only try Drupal, but try Drupal in a context that is relevant to them. Separation of journeys by roles is a concept where what the user can experience based on his/her role is different. Today this is limited to an anonymous user and an admin role. ‘Try Drupal’ is a quick, free build out of Drupal in the cloud by popular Drupal cloud hosting providers.

2. Decouple CMS Capabilities

Tomorrow’s content can flow to the Digital screens in conferences, the kiosks and other marketing channels from a central content repository. Decoupled/Headless CMS capabilities are a prerequisite for this “cross-platform publishing”.

Drupal 9 brings enhanced Decoupled CMS capabilities. Some of the key enhancements in this area include auto-generated API documentation, JSON API explorer to quickly generate APIs and optimized performance. The JSON API explorer is an interactive web application that makes building JSON queries simple. The performance optimizations are much-needed in the context of the large scale applications that are powered by a Decoupled CMS design.

2. Native DAM

Enterprises have a large volume of content. Digital Asset Management (DAM) brings this content to a central location, making this content accessible and contextually available to serve the end-user the content they need. This is important for the marketers whose objective is to engage with their users/customers. AI and analytics of content are tightly coupled with DAMs.

Drupal 9 roadmap includes building out a DAM solution.

3. Integration Framework

Today’s Marketing solutions are a mash up of different tools, cloud services and content publishing channels that provide specialized capabilities.  Some of these interactions include social integrations, integrations with bots, integrations with CRM solutions, Marketing automation solutions and such.

Drupal 9 continues  to act as an Integration framework. Based on the popular needs this layer is normally plugged in by the Contributed  modules. To ensure you have access to these modules, it is important you stay up to date.

4. Improvement to Editor Tools

Editors are one of the main stakeholders who use Drupal. They are constantly using Drupal to churn out fresh content to the world wide web. Drupal has consistently prioritized improvements to the Content Editor tools.

These tools enable marketers and content teams to work independent of technology teams and enable publishing content with faster time-to-market.

Admin UI Claro theme brings a modern look improving the visual appeal, focused on accessibility and mobile compatibility in Drupal 9.

Rich media content like images, videos, tweets are an integral  part of today’s digital content. Managing these Rich media content in a centralized repository delivering them to the various devices, channels or various experiences further enhances the speed with which the editors can publish.

Drupal 9 brings with it the Media module as part of core. Media will assist in organizing the multi-media assets in a manner that renders easy reusability. These are augmented by the existing capabilities to manage responsible images, integrations with streaming services or external video hosting services.

5. Structured Data

Structured data is simply data that is organized based on specific data models. The  information around a particular content is captured, stored and displayed based on the meaning the particular piece of data provides to the content as a whole. Also Structured data helps to build relationships.

As we move into an era of personalization and individualized experiences with a forecast of increased data in the coming years, structured data becomes extremely important.  Structured data is also important in the context of Search Engine Optimization.
Some new features in consideration in Drupal 9 include support for GraphQL that allows to manage large amounts of structured data.

6. Open Web Standards

“Open Web Standards” define a set of best practices to follow while publishing on the World Wide Web. With increase in data privacy challenges, capabilities of certain organizations/browsers to take control of user data there has been an increased focus on “Open Web Standards” that help to preserve the “Open Web”.

Aspects of “Open Web standard” that will remain a priority in Drupal 9 include GDPR, Accessibility, Privacy, Fast by default, Webmentions and Semantic.

GDPR stands for General Data Protection Regulation. It's the core of Europe's digital privacy legislation. Accessibility is something Drupal has been. Web accessibility means ensuring Drupal is designed and developed so that people with disabilities can use them. Drupal has been adhering to WCAG Accessibility guidelines since Drupal 8. Webmention is a (now) standardized protocol that enables one website address (URL) to notify another website address that the former contains a reference to the latter.

7. Simple Upgrade Process

Ease of software maintenance, lowers the cost maintenance for the end user.

Maintenance of Drupal is easier with a simple upgrade process in Drupal 9. Tightly integrated Composer initiative facilitates updates of 3rd party tools will continue to remain a key focus area in Drupal 9. Further in the roadmap is Automatic upgrades which further enhance this process.

8.Community-Centric Approach

Drupal, with its strong community-centric approach, is poised to deliver cutting edge, innovative tools for Marketers, Content editors, Site builders and all its different stakeholders.

9. Managing Application Changes

Agile development is the norm of the day. Customers want to be in a mode where product is developed iteratively, quickly testing their ideas. Key to this is a technical process that ensures tools that facilitate deploying changes to applications easily.

Continued emphasis to support automated deployment using Devops tools like Jenkins or Kubernetes and improved configuration management systems make this possible.

What’s unique to the Drupal 9 release is that the upgrade process is really simple. Just need 4 steps to upgrade your Drupal 8 site. Even if you are still in Drupal 7, there is no need to fret as there is an upgrade path directly to 9 as well. Many of the most complex sites go beyond just the Drupal core and today well ahead of the Drupal 9 launch we also have close to  1500 contrib modules fully compatible and  3400+ other modules that are near completion. 

Are you evaluating migrating to Drupal 9?  Write to us to get a Free Audit & Approach note for your site.

Related resources:

Drupalcon is always special! Back from DrupalCon, left feeling happy, proud to be part of a caring Board, a passionate DA team and last but not least the wonderful Drupal community.

Drupal Board Retreat

Was in Dublin Friday evening 23rd September. Saturday and Sunday was the Board retreat at The Gibson hotel.

The Board meetings at the conferences are day-long sessions where the 12 Board members along with Megan the Executive Director of the Drupal association work together on a strategy for the Drupal Association. The 12-Member Board includes 1 Founder Member (Dries Buytaert), 9 Class Directors bringing various expertise and 2 At Large Directors elected by the community. We have a very interesting mix for our 9 Class Directors - Tiffany, Vessa and Jeff all run successfully large Drupal shops, Rob who earlier worked with NBC & now part of Acquia, Mike who works with Pfizer, Danese brings with her the best of Open Source Strategies from her various open source associations, Sameer from the education background - brings a good external perspective, Donna brings in her expertise from having organized large open source events, a great community person, Steve comes from a technical background, the COO of Docker project, involved or been a part of multiple open sources technologies - again brings a good external perspective and experience from similar communities. Addi & I are the community elected At Large Directors on the board.

To know more about us checkout https://assoc.drupal.org/node/1589

Drupal association is a non profit to support initiatives that in turn benefit the Drupal project and community. The Drupal association operates with the Mission that - Drupal powers the best of the Web. The Drupal Association unites a global open source community to build and promote Drupal. The key initiatives that Drupal association has been sustainably maintaining drupal.org and running Drupalcons. The Board worked with Megan in defining the strategic direction and the boundaries in which the association should operate to ensure Sustainability. The Board also actively involved in the implementation through Task Force that jointly represent the community, Board and the association.

Megan presented us the work of the Drupal association and this was followed by a strategic planning session that was facilitated by Adam. Adam plays the most important role to make sure we work towards structured outcomes that then provide direction to Megan and the Drupal Association staff. Key objective of the retreat being:

• Reach a shared understanding of issues and opportunities for the Drupal Association in 12 - 24 month duration.
• Pick the top three opportunities and strategic focus areas
• Discuss to provide guidance and help identify resources, Task Force to support the same

Day 1 had the Executive update and Financial update from Megan, followed by a session to Discuss and select Strategy Questions to address. Day 2 was spent on more elaborate discussions on the selected Strategic focus areas. Watch out for the Public board meetings at DrupalCons where the DA presents the work that they have done and the Board and DA jointly take questions from the Community. Below is the video of the Public boarding.

[embedded content]

My Next Steps

I am proud to represent the vibrant Drupal Community as a Board member. Besides being involved in the strategic planning want to spend my next few months speaking to more members of the community - Drupal developers, Core Developers, Drupal Community Champions, Shop owner and more. Do reach out to me for any clarifications or support. Best way to connect with me is by dropping a mail to [email protected]

Watch out for my next blog on the Board Staff Mixer!

Have you been to an event recently involving free software or a related topic? How did you find it? Are you organizing an event and don't want to fall into the trap of using Facebook or Meetup or other services that compete for a share of your community's attention?

Are you keen to find events in foreign destinations related to your interest areas to coincide with other travel intentions?

Have you been concerned when your GSoC or Outreachy interns lost a week of their project going through the bureaucracy to get a visa for your community's event? Would you like to make it easier for them to find the best events in the countries that welcome and respect visitors?

In many recent discussions about free software activism, people have struggled to break out of the illusion that social media is the way to cultivate new contacts. Wouldn't it be great to make more meaningful contacts by attending more a more diverse range of events rather than losing time on social media?

Making it happen

There are already a number of tools (for example, Drupal plugins and Wordpress plugins) for promoting your events on the web and in iCalendar format. There are also a number of sites like Agenda du Libre and GriCal who aggregate events from multiple communities where people can browse them.

How can we take these concepts further and make a convenient, compelling and global solution?

Can we harvest event data from a wide range of sources and compile it into a large database using something like PostgreSQL or a NoSQL solution or even a distributed solution like OpenDHT?

Can we use big data techniques to mine these datasources and help match people to events without compromising on privacy?

Why not build an automated iCalendar "to-do" list of deadlines for events you want to be reminded about, so you never miss the deadlines for travel sponsorship or submitting a talk proposal?

I've started documenting an architecture for this on the Debian wiki and proposed it as an Outreachy project. It will also be offered as part of GSoC in 2018.

Ways to get involved

If you would like to help this project, please consider introducing yourself on the debian-outreach mailing list and helping to mentor or refer interns for the project. You can also help contribute ideas for the specification through the mailing list or wiki.

Mini DebConf Prishtina 2017

This weekend I've been at the MiniDebConf in Prishtina, Kosovo. It has been hosted by the amazing Prishtina hackerspace community.

Watch out for future events in Prishtina, the pizzas are huge, but that didn't stop them disappearing before we finished the photos:

In this post I will share a quick tip on how to upgrade the jquery.once plugin in Drupal 7 without breaking current code.

Drupal 7 ships with jquery.once plugin version 1.2 that dates from 2013. For a project we needed to make code targeting the old 1.x and the 2.x work at the same time. In our case this was core javascript written for 1.x working with some code of ours designed for jquery.once 2.x.

The solution is easy: upgrade the core jquery.once to 2.x and add a polyfill to make it backwards compatible.

More articles...

• Using Heatmaps to boost conversions: Heatmap.me Drupal integration
• Drupal 8 Performance: Moving the service container cache away from the database
• Drupal Session Handler: everything you need to know
• Deploying Drupal Like a Pro
• Powerpoint presentation to images in PHP: a Drupal example
• Drupal on IIS or Apache
• Database Transactions in Drupal
• Git shell on Windows reports “sh.exe has stopped working (APPCRASH)”
• Benchmarking Drupal 7 on PHP 7-dev
• PHP 7 nightlies for Windows