Planet Drupal

Subscribe to Planet Drupal feed - aggregated feeds in category Planet Drupal
Updated: 21 hours 33 min ago

1xINTERNET blog: Using Design Systems in Website Projects

3 September 2019 - 6:30am
Using Design Systems in Website Projects breidert Tue, 09/03/2019 - 15:30

We have been building design systems for many clients in the past two years. In this blog post I want to outline why using design systems has become so popular when building websites and other digital properties.

The challenges many large organizations face is to maintain a consistent branding, corporate design, and usage of approved interaction components across all digital properties. With digital properties I mean all websites, internal systems, social media profiles, email footers, etc.

Categories: Drupal

Jacob Rockowitz: Recommendations and strategies for building an exemplary appointment request webform

3 September 2019 - 5:24am

I have spent my two previous blog posts exploring how requesting an appointment online begins a patient's digital journey and how top US hospitals approach online appointment request forms. Now, I would like to make some recommendations and strategies for building an exemplary appointment request form and follow it with an explanation on to how these recommendations are being applied to the Webform module's "Request a Medical Appointment" form template.


Creating an exemplary appointment request form is an iterative process that requires experimentation and testing with analytics to determine which solutions work and which ones don't.


There are many different levels of statistics that can be captured from a form.

The most immediately available statistic is the form's completion rate, which indicates how many people successfully filled out and submitted the form. Subtracting the completing rate from how many users visit the form provides a general sense of the form drop-off rate. What is missing from these statistics is more nuanced information about the form's drop-off rate that can give a better understanding of the form's user experience.


Tracking a form's events shows which inputs were filled in and in what sequence they were entered. This detailed information helps to determine how a user is interacting with a form. Furthermore, knowing where users drop off from completing a form can help indicate which questions may need to be removed or reworked.

Analytics provides the digital team with insights that lead to experimentation and testing.


A...Read More

Categories: Drupal

Specbee: PHP Debugging - How to Debug your PHP Code (Drupal debugging techniques included!)

3 September 2019 - 3:15am
PHP Debugging - How to Debug your PHP Code (Drupal debugging techniques included!) Harika 03 Sep, 2019 Top 10 best practices for designing a perfect UX for your mobile app

Debugging is not something us developers look forward to. Developers detest bugs but to be able to build a fine quality software, debugging is an indispensable part of a developer’s life. Every PHP developer has a different style and go-to methods for debugging their code. This depends on their experience, their problem-solving approach and most importantly - the amount of time they have in hand! 

How important is debugging and why do you need to debug your code? 

Debugging is an integral part of a software development life cycle that assures quality results. 
Picture this - The codebase is big, You are new to the project, You do not have much details of the project/functionality. But you are supposed to fix a bug. Where do we start from? We start by analyzing the code step by step to understand what is done and where things are going wrong. That, my friends, is Debugging. Debugging is an art that can get better with practice and experience.

How to debug your PHP code

Okay so here is a case that I have come across in my development career. There is a commerce site built on Wordpress in which the checkout process was taking around 5-8 minutes and I was asked to solve it. In this case, I don’t have much knowledge on how things work with Wordpress. So I started with checking off the options from the list one by one such as, (a) Is it because of some plugin? (b) Is it Theme related? (c) Is it any custom code base? etc. 

The tool that helped me in php debugging and solving this case is Blackfire. This gives you a more user-readable option of the stack trace of all the functions, the time taken for each function in the whole process. By using this, I found the function that is eating up the checkout process. All you need is some setup to add the key to your code base and you are all set to analyse any functionality using the documentation.  
So, you can solve the bugs if you have knowledge on multiple methods of php debugging.

Code Debugging Techniques

Let me talk about a few techniques that I have used for debugging PHP.
A simple and most common way to check if the function or the method you have written is being called up, write an exit. There wouldn’t be any developer who hasn’t used this!
To check the value of some variable, print_r(), var_dump(), var_export(). Okay, let’s see the difference.


Assume an array $a = array( 1, array( "a", "b") ); print_r($a); Array ( [0] => 1 [1] => Array ( [0] => 'a' [1] => 'b' ) )

This gives a human-readable format and information about the variable. Also, we can store it to a variable with print_r($var, true).

var_dump( $a ); array(3) { [0]=> int(1) [1]=> array(2) { [0]=> string(1) "a" [1]=> string(1) "b" } }

This prints along with type, length of each value. And this is faster comparatively to print_r()
 var_export( $a );

array ( 0 => 1, 1 => array ( 0 => 'a', 1 => 'b', ), )

This prints along with type, length of each value. And this is faster comparatively to print_r()
var_export( $a );

This returns valid php, if variable exists, else returns false. Which means, the output of var_export can be used directly in a php file.

Have you ever made use of debug($var, NULL, TRUE) provided by Drupal core? This uses print_r() or var_export based on the arguments passed to the php debug function.

What about the warnings like below, which you don’t have a clue on which line of code is causing such a warning.

warning: Invalid argument supplied for foreach() in /modules/node/node.module on line 485.

We know that there are so many places that the node module will be called. So, how do you resolve this? One faster way without using any other external resources is using PHP function debug_backtrace(). Go to “drupal_set_message”, because you know, this is the method that is printing the warning. Put the below line, in that function



    [0] => Array
            [file] => /includes/
            [line] => 552
            [function] => drupal_set_message
            [args] => Array
                    [0] => warning: Invalid

argument supplied for foreach() in

/modules/node/node.module on line 504.
                    [1] => error


    [1] => Array
            [file] => /modules/node/node.module
            [line] => 504
            [function] => error_handler
            [args] => Array
                    [0] => 2
                    [1] => Invalid argument
supplied for foreach()
                    [2] => /modules/node/
                    [3] => 504
                    [4] => Array
                            [param] =>
                            [revision] =>
                            [reset] =>



    [2] => Array
            [file] => /sites/all/modules/custom/custom_module
            [line] => 10
            [function] => node_load
            [args] => Array
                    [0] =>


    [3] => Array
            [file] => /includes/
            [line] => 365
            [function] => custom_module_form_alter
            [args] => Array


This function shows the stack of all the functions that are called in the process of causing the warning. Make sure you restrict the limit, otherwise PHP shows a “memory exhausted” message if the stack takes too long to be displayed.

Debugging through CLI:

Heard of phpdbg! Yes, there is a php extension that is available from PHP 5.6+ which is used to debug a php file from command line.
Open you terminal, enter “phpdbg”. This starts  an interactive php debugger shell. You can also use breakpoints! Just try it out - the hidden way of debugging PHP. 
The only problem is: you will have to get used to the commands of phpdbg to make better use of it.

Debugging through Drupal:

Devel Kint: Drupal developers use this pretty often. Kint is a submodule of the Devel module that can be used to debug Drupal 8 twig templates together with dump(); 

DB Log: Who is not aware of this Drupal module?! In D7 it is watchdog() and D8 it is logger service.


But the only reason why we don’t encourage the use of this module even though we are in love with this is that the log message is written into the database every time!

And imagine if it is a huge database, this would be even worse and will affect the performance. That’s the reason, it is not recommended to use DBLOG module on Production sites.
Do you still want to use DBLog, module and reduce the performance impacts? There is a solution for that as well - DBlog Filter. This is a contributed module which helps in restricting the type of logs to be written into the database. For example, if you want to store only logs of severity “error”, you can configure them with this module. So you don’t have to completely get rid of Dblog module. Oh yes, and this module is contributed by me ;) 

Web profiler

Web profiler is a contributed module provided by Devel again. Once you have the module enabled, you will see a report at the bottom of the window. Whenever a page is loaded, this report gives us the page load time, number of queries running in the page, number of forms, number of js/css files, etc. in that page.

Yes, This even offers details of each section by clicking on them. For example, the following image shows the queries in the home page.

XDebug - Debugging through IDE:

The best and more user-friendly way of debugging most of the people prefer if they are using an IDE for coding is using XDebug. XDebug is a PHP extension that helps in the development and debugging and provides a single step debugger that you can use with an IDE like PHPStorm. Of course to get the best results, you have to put more effort to install and configure the extension with the IDE you are using.

Debugging your PHP code does not always have to be a frustrating experience. With the right tools and methods available today, debugging code can be simplified and gratifying. If you have found my methods of php debugging useful, bookmark us :). And don’t forget to check back on our blogs that get updated with fresh and insightful content every week!

Drupal Planet Shefali ShettyApr 05, 2017 Subscribe For Our Newsletter And Stay Updated Subscribe Shefali ShettyApr 05, 2017 Recent Posts Image PHP Debugging - How to Debug your PHP Code (Drupal debugging techniques included!) Image Drupal Translation - How to create Multilingual websites in Drupal 8 Image How to make Interactive Websites and why you need one? Explore Our Drupal Services TAKE ME THERE Featured Success Stories

Know more about our technology driven approach to recreate the content management workflow for [24]


Find out how we transformed the digital image of world’s largest healthcare provider, an attribute that defined their global presence in the medical world.


Develop an internal portal aimed at encouraging sellers at Flipkart to obtain latest insights with respect to a particular domain.

Categories: Drupal

ADCI Solutions: Drupal Cafe #20

3 September 2019 - 3:04am

The ADCI team keeps the tradition of organizing Drupal Cafe. It’s a great opportunity for networking, learning new information and improving competence. We organized the 20th event, where we kept sticking to our high standards of sessions' quality. Learn more in our blog.

Categories: Drupal

ADCI Solutions: Drupal and Wordpress: define your goals and possibilities, then choose the platform

3 September 2019 - 2:27am

Because of many variations of CMSs, choosing the best can be quite difficult in 2019. The market offers hundreds of different platforms for creating websites.

In this article, we give a comparison of Drupal and Wordpress. You’ll find out about their advantages and differences, so it’ll be easier to choose the best CMS for you.


Categories: Drupal

Agaric Collective: Executing Drupal migrations from the user interface with Migrate Tools

2 September 2019 - 4:16pm

In previous posts we introduced the concept of defining migrations as configuration entities. These types of migrations can be executed from a user interface provided by the Migrate Tools module. In today’s article, we will present the workflow to import configuration entities and execute migrations from the user interface. Let’s get started.

Important: User interfaces tend to change. In fact, Migrate Tools recently launched a redesign of the user interface. Screenshots and referenced on-screen text might change over time. Some exposed settings might work, but give no feedback indicating a successful outcome. Some forms might only work with specific versions of modules. The goal is to demonstrate what is possible and what are the limitations of doing so. In general, executing migrations from the command line offers a better experience.

Getting the example code

You can get the full code example for today’s example at The module to use is `UD configuration group migration (JSON source)` whose machine name is `ud_migrations_config_group_json_source`.  It comes with three migrations: `udm_config_group_json_source_paragraph`, `udm_config_group_json_source_image`, and  `udm_config_group_json_source_node`. Additionally, the demo module provides the `udm_config_group_json_source` group.

You could install the module as we have done with every other example in the series. Instructions can be found in this article. When the module is installed, you could execute the migrations using Drush commands as explained in this article. But, we are going to use the user interface provided by Migrate Plus instead.

Importing configuration entities from the user interface

The first step is getting the configuration entities into Drupal’s active configuration. One way to do this is by using the "Single item" import from the "Configuration synchronization" interface. It can be found at `/admin/config/development/configuration/single/import`. Four configuration items will be imported in the following order:

  1. The `udm_config_group_json_source` using "Migration Group" as the configuration type.
  2. The `udm_config_group_json_source_image` using "Migration" as the configuration type.
  3. The `udm_config_group_json_source_paragraph` using "Migration" as the configuration type.
  4. The `udm_config_group_json_source_node` using "Migration" as the configuration type.

When importing configuration this way, you need to select the proper "Configuration type" from the dropdown. Otherwise, the system will make its best effort to produce a valid configuration entity from the YAML code you paste in the box. This can happen without a visual indication that you imported the wrong configuration type which can lead to hard to debug errors.

Note: If you do not see the "Migration" and "Migration group" configuration types, you need to enable the Migrate Plus module.

Another thing to pay close attention is changes in formatting when pasting code from a different source. Be it GitHub, your IDE, or an online tutorial, verify that your YAML syntax is valid and whitespaces are preserved. A single extraneous whitespace can break the whole migration. For invalid syntax, the best case scenario is the system rejecting the YAML definition. Otherwise, you might encounter hard to debug errors.

In today’s example, we are going to copy the YAML definitions from GitHub. You can find the source files to copy here. When viewing a file, it is recommended to click the "Raw" button to get the content of the file in plain text. Then, copy and paste the whole file in the designated box of the "Single item" import interface. Make sure to import the four configuration entities in the order listed above using the proper type.

To verify that this worked, you can use the "Single item" export interface located at `/admin/config/development/configuration/single/export`. Select the "Configuration type" and the "Configuration name" for each element that was imported. You might see some extra keys in the export. As long as the ones you manually imported are properly set, you should be good to continue.

Note that we included `uuid` keys in all the example migrations. As explained in this article, that is not required. Drupal would automatically create a `uuid` when the configuration is imported. But defining one simplifies the update process. If you needed to update any of those configurations, you can directly visit the "Single item" import interface and paste the new configuration. Otherwise, you would have to export it first, copy the `uuid` value, and add it to the code to import.

Executing configuration entities from the user interface

With the migration related configuration entities in Drupal’s active configuration, you should be able to execute them from the user interface provided by Migrate Tools. It is available in  "Manage > Structure > Migration" at `/admin/structure/migrate`. You should see the `UD Config Group (JSON source)` that was imported in the previous step.

Note: If you do not see the "Migration" link in "Manage > Structure" interface, you need to enable the Migrate Tools module.

This user interface will list all the migration groups in the system. From there, you can get to the individual migrations. You can even inspect the migration definition from this interface. It is important to note that only migrations defined as configuration entities will appear in this interface. Migrations defined as code will not be listed.

For the `udm_config_group_json_source` group, click the "List migrations" button to display all the migrations in the group. Next, click the "Execute" button on the `udm_config_group_json_source_image` migration. Then, make sure "Import" is selected as the operation and click the "Execute" button. Drupal will perform the import operation for the image migration. A success status message will appear if things work as expected. You can also verify that images where imported by visiting the files listing page at `/admin/content/files`.

Repeat the same process for the `udm_config_group_json_source_paragraph` and `udm_config_group_json_source_node`migrations. The final result will be similar to the one from the JSON source example. For import operations, the system will check for migration dependencies and execute them advance if defined. That means that in this example, you could run the import operation directly on the node migration. Drupal will automatically execute the images and paragraphs migrations. Note that migration dependencies are only executed automatically for import operations. Dependent migrations will not be rolled back automatically if the main migration is rolled back individually.

This example includes a paragraph migrations. As explained in this article, if you rollback the node migration, any paragraph associated with the nodes will be deleted. The Migrate API will not be aware of this. To fix the issue and recover the paragraphs, you need to rollback the paragraph migration as well. Then you re-import the paragraph and node migrations again. Doing this from the user interface involves more manual steps compared to running a single Drush command in the terminal.

Limitations of the user interface

Although you can import and execute migrations from the user interface, this workflow comes with many limitations.The following is a list of some of the things that you should consider:

  • Updating configuration in production environments is not recommended. This can be enforced using the Configuration Read-only mode module.
  • If the imported configuration entity did not contain a `uuid`, you need to export that configuration to get the auto generated value. This should be used in subsequent configuration import operations if updates to the YAML definition files are needed. Otherwise, you will get an error like "An entity with this machine name already exists but the import did not specify a UUID."
  • The following operations to not provide any user interface feedback if they succeeded: "Rollback", "Stop", and "Reset". See this issue for more context.
  • As of this writing, most operations for CSV sources fail if using the 8.x-3.x branch of the Migrate Source CSV module. See this issue for more context.
  • As of this writing, the user interface for renaming columns in CSV sources produces a fatal error if using the 8.x-3.x branch of the Migrate Source CSV module. See this issue for more context.
  • As of this writing, it is not possible to execute all migrations in a group from the user interface in one operation. See this issue for more context.
  • The Migrate source UI module can be used to upload a file to be used as source in CSV migrations. As of this writing, a similar feature for JSON and XML files is not working. See this issue for more context.

To reiterate, it is not recommended to use the user interface to add configuration related to migrations and execute them. The extra layer of abstractions can make it harder to debug problems with migrations if they arise. If possible, execute your migrations using the commands provided by Migrate Tools. Finally, it is recommended to read this article to learn more about the difference between managing migrations as code or configuration.

What did you learn in today’s blog post? Did you know you can import migration related configuration entities from the user interface? Did you know that Migrate Tools provides a user interface for running migrations? Share your answers in the comments. Also, I would be grateful if you shared this blog post with others.

This blog post series, cross-posted at as well as here on, is made possible thanks to these generous sponsors. Contact Understand Drupal if your organization would like to support this documentation project, whether it is the migration series or other topics.

Read more and discuss at

Categories: Drupal

Code Karate: Drupal 8 Allowed Formats Module

2 September 2019 - 11:19am
Episode Number: 229

The Drupal 8 Allowed Formats module allows you to configure what text formats are available for each field. By default, all the text formats a user has permission to use are available for every field that uses text formats. Sometimes you want a field to have html, but have a more limited set of html tags. This can easily be accomplished by creating a new text format and using the Allowed Formats module to limit the field to using that text format.

Tags: DrupalDrupal 8Drupal Planet
Categories: Drupal

Gábor Hojtsy: Drupal 8.7.7+ will support extensions compatible with both Drupal 8 and 9!

2 September 2019 - 9:17am

Drupal 8.7.7 expected later this week is the first Drupal release to support extensions compatible with multiple major versions of Drupal. This is huge!

Drupal 9 is planned for June 3, 2020 and we are aiming to make the transition as smooth as possible. In fact we build Drupal 9 in Drupal 8 with API deprecations and optional support for new dependencies (Symfony 4.4 is getting very close, while Drupal 8.7.0 was already Twig 2 compatible). Extensions following these deprecations and making sure they are compatible with the updated dependencies could have codebases that are both compatible with Drupal 8 and 9 at the same time, meaning less support burden and earlier Drupal 9 compatibility. In March 48% of contributed projects on were already "Drupal 9 compatible" (as we could detect at the time), and that increased 54% by July (highfive!). These projects will now have one more thing to do, a one line info.yml file addition, to allow their existing codebase to also run on Drupal 9.

✋Drupal contrib maintainers, thank you! You are already contributing a lot to a successful Drupal 9. Projects that are "compatible with Drupal 9" (as much as we know now) are up to 54% from 48% since March. Deprecated API use is decreasing overall.

You are awesome, keep it up!

— Gábor Hojtsy (@gaborhojtsy) August 2, 2019

The core: 8.x key did not cut it anymore

Drupal 8 looks at extension .info.yml files and checks for the core: 8.x key to check if the extension can be used with Drupal 8. Unfortunately this was not adequate already due to API additions in Drupal 8 minor releases. You could not specify an extension was only compatible with Drupal 8.4+. People devised clever tricks with dependency on certain versions of the system module, but that was still limiting due to inability to depend on specific patch releases. In case your extension depended on a bugfix being present, you cannot set a dependency on Drupal 8.4.1+ in any way.

Introducing the core_version_requirement key

While solving this issue it became apparent that solving it with the existing core: 8.x key is going to cause backwards compatibility problems with existing Drupal 8 sites. The format of the value could not be changed without causing issues, so a new core_version_requirement key was introduced. This now allows to depend on major and minor versions of core as well as specify multiple version requirements even between multiple minor Drupal versions. For example if you would need a bugfix that is to be included in both Drupal 8.7.23 and 8.8.3 (imaginary future versions) but you wouldn't care for the minor version, then you would use the following, making your module incompatible with versions before the particular bugfix you need on both minor branches, as well as incompatible with all older Drupal 8 branches:

name: My Module
type: module
core_version_requirement: ~8.7.23 || ~8.8.3

Such precision was never possible before!

The new feature is made available in 8.7.7 to help prepare for Drupal 9, as this makes it possible to also declare Drupal 9 compatibility with the existing codebase you already have. Drupal 8.7.x will get security support up until the planned release of Drupal 9 on June 3, 2020. For extensions that only support Drupal 8.7.7 and later you can now exclusively use the core_version_requirement key. If the extension is also Drupal 9 compatible:

name: My Module
type: module
core_version_requirement: ^8.7.7 || ^9

For extensions that also support older versions, you should keep the core: key as well. The core_version_requirement key will be ignored by older Drupal versions, and new versions will validate that you specified non-conflicting requirements in the two keys (with regards to Drupal 8 support) so for extensions supporting older core versions, core_version_requirement also needs to be permissive, but could also allow compatibility with Drupal 9 too:

name: My Module
type: module
core: 8.x
core_version_requirement: ^8 || ^9

Read more about this change in the change notice. There is also work ongoing to support dependency metadata from composer.json to drive Drupal's dependency resolution as well. That will coexist with this simpler approach and will provide a more composer-native solution for those who already adopted composer for their extensions. In the meantime at least core_version_requirement will limit what Drupal would install while composer.json requirements will limit what composer will download. Because both Composer and Drupal use the term install, but those don't mean the same thing, here is a comparison chart:

  core: 8.x system module dependency core_version_requirement composer.json dependencies Can be used from Drupal 8.0.0+ Drupal 8.0.0+ Drupal 8.7.7+ Drupal 8.0.0+ Allows minor version precision No Yes Yes Yes Allows patch version precision No No Yes Yes Allows multiple constraints No No Yes Yes Limits composer install (download) No No No Yes Limits Drupal 8 install Yes Yes Yes No, unless explicit support is added. Allows Drupal 8 and 9 install with same codebase No No Yes No, unless explicit support is added. What happens to project version numbers then?

So a 8.x-1.3 version of an extension on may only be compatible with a subset of core, but that was already the case earlier. Now an 8.x-1.3 version of an extension on may also be compatible with Drupal 9. How will this work? Drupal's composer integration already ignores the 8.x prefix from version numbers and only cares about the project specific version. Drupal core already only installs extensions where the core compatibility requirements are met regardless of which version number was the package you used to download (8.x modules may be only compatible with 8.4+ already). So the ultimate plan is to do away with the 8.x prefix in extension numbers entirely on and support semantic versions for contributed extensions instead. In the short term, the project browser also needs to be updated to take the dependency metadata and use that to power compatibility filters, instead of merely using the version number prefix.

Categories: Drupal

Centarro: Commerce 2.14 adds Address Book to core

2 September 2019 - 6:30am

Ask most Drupal Commerce 2.x users what their #1 missing feature is, and they'll say it’s the ability to store and reuse customer information for future purchases, i.e. the “address book”. On Drupal 7, we provided this functionality through the Commerce Addressbook module. For Drupal 8 we felt this functionality was important enough to make it a core feature, and we started working on initial address book patches soon after releasing Commerce 2.0. We didn’t anticipate how wide-reaching implementing our ideal solution would be.

Categories: Drupal

Srijan Technologies: Rolling out API Monetization for a Philippines Telecom Giant with Drupal-APIGEE

2 September 2019 - 1:12am

With a successful API monetization strategy, enterprises can expand their business capabilities to new customers through the rapid consumption of business assets.

Categories: Drupal

Vardot: Vardot Named Top Developer in Jordan by Clutch

2 September 2019 - 12:07am
Firas Ghunaim September 2, 2019

Software solutions come in all shapes and sizes. Perhaps you’re looking for software that will help you build valuable links back to your company. Or maybe, you need a custom CRM to manage all of your valuable patrons. Either way, it’s vital to find a reliable technical partner to make your software solution dreams a reality.

At Vardot, we understand that all web development is not one-size-fits-all. We know exactly how can help your organization transform its website to meet the demands on the digital landscape. Our solutions help increase and refine distinguished companies’ digital presence through Drupal, a powerful open-source CMS.

In acknowledgment of our efforts, we’ve been recognized by Clutch, as one of the top developers in Jordan! We’d like to thank our valued customers for participating in brief client interviews on our behalf. We’ve been awarded a 4.9-star rating (Out of a possible 5 stars). We’re excited to keep this momentum going and maintain ourselves as a top provider in our field! Check out a recent review below!




“We are honored and pleased to see our team's innovation and hard work recognized.”Mohammed Razem - CEO, Vardot.


Clutch is an objective resource for business-to-business services. The platform lauds a unique rating methodology that objectively reviews similar companies. The Manifest’s directory also features us a top Drupal development company. For those unfamiliar, The Manifest is a sister site of Clutch that specializes in business news. Another great resource and Clutch sister site is Visual Objects. Each Visual Objects profile features a catalog of businesses’ visual work.


If you’re interested in learning more about how we can help maximize your Drupal success, drop us a line today!

Categories: Drupal

Code Karate: Drupal 8 Scheduler Module

1 September 2019 - 7:11pm
Episode Number: 228

The Drupal 8 Scheduler module allows content editors on your Drupal site to schedule the publishing or unpublishing of content at a specific date and time. It’s a very simple module to setup and use, and provides a great feature for your content editors that want content to go live at a specific time.

Tags: DrupalDrupal 8Site BuildingDrupal Planet
Categories: Drupal

Code Karate: Drupal 8 Quicklink Module

31 August 2019 - 7:24am
Episode Number: 227

The Drupal 8 Quicklink module enabled faster subsequent page loads on your Drupal site. It does this by prefetching links during idle time. This means as you browse your Drupal site, this module will be pulling down the html for any links that are in the current view port. This makes the next page load much faster.

The module adds additional features and configuration options so you can fine tune the experience to fit your Drupal 8 site.

Tags: DrupalDrupal 8Drupal Planet
Categories: Drupal

Promet Source: A Marie Kondo Inspired Guide to Content Migration

30 August 2019 - 3:44pm
I’ll admit to having watched a few episodes of Marie Kondo’s show on Netflix. She has definitely inspired some of the downsizing my wife and I done over the last few years. I even applied her thought process to my personal website. When I moved it to a new host I thought about how much of the content on it was not sparking joy.  If I didn't really care about stuff did my readers? This thought process is probably even more valuable for a large business-focused Drupal site than it was for my goofy personal website.
Categories: Drupal

Mediacurrent: [Flexible Typography] UX Design Principles for Component-Based Systems

30 August 2019 - 11:37am

In this 5-part series, take a deep dive into universal design concepts in the context of creating component-based systems for dynamic web content. Get a birds-eye view of the inner workings of user experience (UX) architecture. Brand strategy, user psychology, objective methodology, and data-driven decisions come together, guided by timeless fundamental ideas, to construct today’s digital journeys.

Flexible Typography

The Art of Setting Type for Dynamic Systems

It is the typographer’s task to divide up, organize, and interpret this matter in such a way that the reader will have a good chance of finding what is of interest to him.

- Emil Ruder

In the 1950s, Swiss typographer and graphic designer Emil Ruder was involved in developing the International Typographic Style. Cleanliness, objectivity, and the use of “the grid” are key features of this approach which still plays a major role in design today.

In 2006, Oliver Reichenstein said,

Web Design is 95% Typography.

And while faster connection speeds have allowed us to provide more media-rich experiences, text-based information is still vital - and the only thing that devices like Google, Alexa, and assistive technologies for the differently-enabled “see.”

Today, the timeless challenge of how to visually present text-based information is as formidable as it’s ever been. Contemporary design decisions take into account the experiences of billions of potential users, located anywhere in the world, in front of screens of all sizes, with a wide range of backgrounds, situations, and abilities. 

Fortunately, standards such as those for Heuristic Evaluation, the W3C’s Web Content Accessibility Guidelines and user testing tools such as the System Usability Scale and the Single Ease Question have provided an objective structure to inform the creative works of designers today.

Fast, Scalable, Legible Type Styling Guiding principles for font selection and implementation  Limit the number of fonts 

In the name of consistency, efficiency, and optimized load times, consider combining two harmonious fonts that create a visual hierarchy. Two is considered an ideal number for fonts. Choose a font with enough members in its family to allow design options, however. A font with light and black versions, as seen on some of Google’s best fonts, will provide a versatile UI toolkit.

Most brand standards contain definitions for print and well as web fonts. In the absence of such standards, a review of mission and vision statements can guide you to a font that reflects the brand identity.

Use a responsive type scale

Responsive modular typography scales, when designed and implemented, are an easy way to preserve visual hierarchy across the various screen widths of devices. A modular type scale is a series of type sizes that relate to each other because they increase by the same ratio. 

Example of how responsive typography looks across various breakpoints on Mediacurrent’s Rain demo site.


Avoid All Caps for headings and paragraph text

Not only have studies shown text formatted in All Caps decreases reading speed by 10-20%, but this styling presents substantial barriers for users with dyslexia. According to the latest estimates, that is 15-20% of the population.

When headings are less than around 25 characters, all caps is still considered readable for everyone. All caps can also be a valid choice for short navigation titles and concise button copy.

Avoid Italics for headings and paragraph text

A first-time user may spend seconds on your website, not minutes, and as reading speed is dependant on legibility, styling is of paramount importance for all users. In terms of accessibility, italicized letters are nearly illegible to some with reading issues.

Addressing accessibility concerns is a great investment that provides an opportunity to bring in objective best practices to increase usability, readability, and visual impact for all users, opening up your website to a larger audience.

Modern, Readable, Accessible Type Styling  Guiding principles for line and paragraph spacing Look to the gold standard for accessibility

Because Section 508 compliance is currently attuned to the A and AA Level WCAG 2.0 guidelines, the AAA Guidelines are sometimes left out of the conversation. The guidelines around line and paragraph spacing, however, are especially easy to incorporate. Because they improve the experience for all users, they are well worth considering. 

Avoid justified text

People with certain cognitive disabilities have problems reading text that is both left and right justified. The uneven spacing between words in fully justified text can cause "rivers of white" space to run down the page making reading difficult and in some cases impossible. Text justification can also cause words to be spaced closely together so that it is difficult for them to locate word boundaries.

Implement a maximum width for containers of heading and paragraph text

For people with some reading or vision disabilities, long lines of text can become a significant barrier. They have trouble keeping their place and following the flow of text. Having a narrow block of text makes it easier for them to continue on to the next line in a block. Text blocks must be no wider than 80 characters. 

When determining how to limit the width of a responsive text block, it can be helpful to use a character counting tool. Or try advanced math! The Golden Ratio Typography Calculator generates suggestions for your entire type hierarchy based on the Golden Ratio: a pattern found in nature that is inherently pleasing to the human eye.

Provide ample line spacing for paragraph text

People with some cognitive disabilities find it difficult to track text where the lines are close together. Providing extra space between lines and paragraphs allows them to better track the next line and to recognize when they have reached the end of a paragraph. Provide line spacing that is at least 1.5 (a space and a half) in text blocks and spaces between paragraphs are at least 1.5x line spacing.

In the first post of this series, we discussed the advantages of generously-sized type comfortably line-spaced within a width-restricted column. Not only does this approach align with that of today’s best-in-class websites and provide a comfortable, welcoming reading experience, it is universal design that is accessible and all-inclusive.

Preparing to Reach a Global Audience Scratching the surface of localization Designing type for Right To Left (RTL) languages

Arabic is the 4th most popular language globally and 60% of Arabic speakers prefer browsing internet content in Arabic. Aligning text to the right side is key, and so is upsizing the font to preserve text readability. Factoring in the shorter length of words as most Arabic words. Read more about web design for RTL languages.

Example of RTL language typography on

Accommodating translated text

Character counts expand or contract according to language. Expect a 15 - 30% expansion when translating English to Spanish or Portuguese, for example. When planning to translate English to Chinese or Japanese, however, expect variation. Read more about typography for translated text here.

Planning for character-based languages

Written Japanese, for example, consists of thousands of characters across four character sets: hiragana, katakana, kanji and the Latin alphabet. Japanese users perceive carelessly designed websites as reflective of brand quality. They describe products as “unnatural”, “foreign”, and “suspicious.” The work to get from unnatural to perfect is not hard. Read more about standards for presenting Japanese text on the screen.

Applying and Iterating Type Systems Continuous improvement based on user feedback

After carefully selecting type styles representative of the brand experience, applying them with accessibility in mind, defining parameters within responsive components, and perhaps including specifications for translated type, what comes next?

We take these specs and build a living style guide to catalog the site’s elements and components. Having the building blocks all in one place not only ensures consistency but allows developers to rapidly adjust or efficiently leverage the existing pieces to create more complex components.

A living style guide makes it easier to add new patterns to meet your needs and the needs of your users that arise as “the rubber hits the road” when content editors begin using the site and feedback is collected from users, ideally through methodical tests.

Technology has evolved rapidly since pioneers like Emil Ruder developed the Swiss style, and is always offering new challenges for designers. But happily, this evolution has allowed us to collect data to objectively guide our practice and to create, share, and continuously improve standards for accessibility and usability, allowing us to meet the challenge of designing with confidence for the global audience. What a great time to be a designer!

In the next installment, we’ll cover pattern libraries/ living style guides in greater detail. We’ll discuss how style libraries ensure a consistent experience and make ongoing enhancements much easier. Learn about the steps it takes to build an emotion-rich, brand-true user journey within the restricted structure of a website built to last for years displaying dynamic, user-entered content.

Categories: Drupal

Palantir: Drupal Sustainability: Contribution, Credit and Impact

30 August 2019 - 9:24am

Having more companies working with Drupal is a good and necessary thing, but it means we need to improve the way that we onboard, recognize, and differentiate those who help sustain and innovate Drupal.

A few weeks ago, I earned my first ever Drupal contribution credit for my DrupalCamp Colorado keynote. While I am oddly excited about that, I also find it somewhat ironic, as that keynote should not be mistaken for my first contribution to Drupal.

According to my profile, I’ve been a community member for over twelve years. In that time, I’ve presented keynotes for three other DrupalCamps, presented sessions and participated in panels going back to DrupalCon Boston 2008, led the RFP process for the redesign of, chaired DrupalCon Chicago 2011, served on the board of the Drupal Association for nine years and, most recently, served on the Executive Director Search committee. That is but a partial tally of my individual contributions; of course my company,, has also made considerable contributions of time, talent, and treasure over all these years.

Recognition is not my motivation for these efforts; like so many open source contributors, I give back to Drupal because I am committed to stepping up when I see a need or an opportunity. When I was new to the community, the karma earned from such efforts, code and non-code, was informally held in the living memory of those who were there. I always felt that I had earned the credibility and support of those with whom I collaborated closely to move on to the next opportunity, to tackle and solve the next problem. In many ways, as a woman on/of the internet, I appreciated the relative anonymity of it.

In that way, Drupal has become the largest independent community-driven open source project. And many of us believed that our collective success and the impact we made was enough to sustain the virtuous cycle of open source. But was it?

Open source has won: we now have legions of people and companies who rely on Drupal and other open source tools and products; however, these companies picked the best tool, which just happened to be an open source tool, and they don’t necessarily yet know the open source way. Twelve years ago, the Drupal community was small enough that those established norms and expectations were passed on person-to-person, along with the lore and the legends. The old ways of influencing behavior and enforcing norms through social bonds (aka peer pressure) aren’t strong or explicit enough for the swells of newcomers.

There is a lack of shared understanding, visibility and support for what it takes to not just keep Drupal sustainable, but to have it thrive and win in a competitive landscape. This lack of clarity has led to the emergence of multiple subcultures within the commercial ecosystem and a worrying disparity between those who benefit the most from Drupal versus those who give the most.

In his Amsterdam 2014 keynote, Dries noted that while open source has a long history of credit (for code) to the individual contributors, this does not adequately recognize (or incentive) the organizations. He proposed a simple way to give organizations credit in addition to individual credits for the core issues their teams either performed directly or sponsored, which the Drupal Association released in late 2015. Over time, this system has been expanded to capture more than just code contributions.

And yet, the contribution credit system has not wholly replaced karma. As my own experience shows, so much of the vital work that Drupal relies on is not yet captured in credits. Due to my privilege (not looking for a job, having well-established connections in the community, etc.), the lack of visibility was a feature, not a bug, for me as an individual contributor.

However, wearing my Palantir CEO hat I’ve come to realize that the failure to capture fully what and how companies do (and are expected) to contribute is far more problematic for the sustainability of the project. Some of the most essential work in the community (Drupal Association Board of Directors, the Community Working Group (CWG), the Security Team and non-code Core team work including release management, communication, sprint organizing and overall project and initiative coordination) is severely undervalued or all-in-all ignored by the contribution system. George DeMet's ongoing commitments as the chair of the CWG often average anywhere from ¼ - ½ of his time (more at intense times) and over the last year he received four credits (the other members of the CWG received even less!). The community and the project suffer because this invisibility obscures, and indeed over time deteriorates, the community expectations and norms by measuring what is easy, rather than what matters.

When Drupal 7 was released, the firms that built Drupal enjoyed a competitive advantage: those who wanted to use Drupal knew which firms meaningfully contributed and why it mattered. However, over the last five years, the Drupal ecosystem has expanded to include many new, larger firms that leveraged partnership and sponsorship programs to establish their Drupal credentials.

These programs and the new implementers and agencies they ushered into the Drupal community are essential to Drupal’s growth and adoption. They are a welcome addition to the ecosystem. However, there are serious problems with the ways that these programs have been structured to date and their unintended impact on our culture of contribution:

  • Status within these programs is primarily pay-to-play and non-financial contributions to the project are not required.
  • The programs do not directly directly support or indirectly incentivize the time or talent contributions on which the Drupal project depends.
  • The financial proceeds of such programs benefit infrastructure initiatives ( and more broadly the Association) and market visibility, which are not necessarily the areas of greatest need for the project or community.
  • These programs have undermined the reputational system that prioritized successful outcomes (successful client implementations AND contributions back to the project) and replaced it with one that favored outputs (financial success and client list).

Allowing companies to position themselves as leading experts in Drupal without validation that these firms are contributing commensurate with the benefits derived from Drupal has been corrosive to the sustainability of the project. This has tacitly supported the commoditization of Drupal services, devalued the competitive advantage received from direct contribution, and simultaneously incentivized and conditioned all in the ecosystem to increase indirect contribution (sponsorship and advertising on and events including DrupalCon).

As I noted on a panel at OSCON, I see all of this as a success problem. Having more companies, including large scale implementers and agencies, working with Drupal is a good and necessary thing. What we need to improve is the way that we onboard, recognize, and differentiate those who help sustain and innovate Drupal to (re)establish a culture of contribution for Drupal. Doing this well will involve creating new and easy-to-access avenues for contribution that match the project’s weighted needs and companies’ available resources (be they time, talent or treasure). A concerted focus on what matters will shore up Drupal’s path to long-term sustainability.

Community Drupal Open Source People
Categories: Drupal

Event Organizers: Making it Official

30 August 2019 - 9:10am

For over a decade* the Drupal community has gathered in volunteer-led “camps”, based on the BarCamp model, to follow in that camp’s initial goals:

  • Introduce web developers to the Drupal platform.
  • Skill sharing among established Drupal developers
  • Give back to the Drupal project (e.g. fix bugs, documentation, lesson materials)

The scope of Drupal Camps has expanded as our community has grown and matured, and camps now serve everyone in the community, not just developers. They serve as an on-ramp for new developers, a networking opportunity for clients and agencies, a marketing opportunity for service providers, and much more.

The Drupal Event Organizers have documentation of over 50 volunteer-led events with over 10,000 attendees worldwide in the past year, and we know there are almost double this number that we don’t have good data for. These events have evolved organically, with little central organization, and are estimated to comprise more than one million dollars in sponsorship and ticket sales worldwide, yearly.

The Event Organizers have organized in various forms over that time… from various documentation efforts to our current monthly meeting format. With Kaleem’s instigation, the group started toward a more formal organization in late 2018, and that process is almost a reality. 

We’ve established a formation board composed of organizers from across the globe and have been collaborating on a charter for the Event Organizers Working Group over the past few months. We’re looking forward to presenting it soon and beginning the next chapter of the Drupal Event Organizers.

Thanks to the following folks who have contributed to the effort thus far.

Our Formation Board members:

And our trusted advisers:

* Possibly starting at Drupal Camp Toronto, 2006? If you know of an earlier camp, please let us know in the comments.

Categories: Drupal

Code Karate: Custom Entities with Drupal Console

30 August 2019 - 7:37am
Episode Number: 226

In the last episode we covered creating a Drupal 8 module with Drupal Console. In the episode before that, we covered using the Drupal 8 ECK module to create custom entities. In this episode, we cover how you can use Drupal Console to scaffold out custom entities on your Drupal 8 website.

Tags: DrupalDrupal 8Drupal Planet
Categories: Drupal

OSTraining: How to Create a Masonry-Like View in Drupal 8

29 August 2019 - 10:53am

Masonry is a very popular JavaScript library, that stacks items in columns and rows, like a masonry brick wall.

The items reorder themselves according to their size as the viewport size changes with a nice animation effect. For some examples, take a look at the official Masonry site.

It is possible to create a view in Drupal with this style of layout. Keep reading to learn how!

Categories: Drupal