Sep 18 2018
Sep 18

Drupal Modules: The One Percent — Entity Class Formatter (video tutorial)

[embedded content]

Episode 44

Here is where we bring awareness to Drupal modules running on less than 1% of reporting sites. Today we'll consider Entity Class Formatter, a module which allows you to add fields which can be passed to your entity as classes.

Sep 18 2018
Sep 18

We're excited to mark the first minor update for our Drupal 8 products since the initial D8 release! There are no new features in this update but we're incrementing the middle digit in our version numbers for Glazed Theme and Glazed Builder because of a change we made in how Bootstrap Panels are handled. This change may require manually re-saving of pages that use the panels Glazed Builder element. More info about that in the Changelog

Thanks to changes in how panels are handled we now support an option to select all the Bootstrap-native panel styles in our Glazed Builder panel element. Besides the panels update both the Glazed Theme and Glazed Builder releases contain various small fixes.

Managing Sooperthemes' Growth 

Besides crushing bugs we've been working on other areas of our products and services during the hot summer that we've had in the Netherlands. Since the release of our Drupal 8 products we've seen a growth in subscription sign-ups and also in sales questions and support tickets. To handle the extra workload we're now onboarding a full-time customer success manager as well as a full time content/marketing manager. Check out our brand new Sooperthemes instagram account for the behind-the-scenes. 

Sneak Peek: Glazed Builder User Profiles

This feature has been requested for so long I'm really excited that it's finally happening. We're working on adding an interface similar to the WYSIWYG Drupal module. This interface let's you create profiles that limit the elements, buttons, and settings a user sees in the Glazed Builder interface. Check out the sneak preview here:

Sep 18 2018
Sep 18

This is the fourth installment in a series presenting work on shared configuration that comes out of the Drutopia initiative. To catch up, see Part 1, Configuration Providers, Part 2, Configuration Snapshots, and Part 3, Respecting Customizations.

In the next installment we'll start to pull it all together, showing how all the pieces covered so far fit into a solution for merging in configuration updates. But first there's one more piece to add. In this installment we'll be looking at creating and updating configuration alters.

First off, what is a configuration alter?

An alter is an addition, deletion, or change to a piece of configuration.

When we're producing a several packages of shared configuration - what are often called feature modules - sooner or later we need a particular feature to modify configuration that was provided by another feature.

Say I'm producing a Drupal distribution that includes two different features: an event feature and a location feature. Any given site might install the event feature, or the location feature, or both, or neither. (A big part of the point of having distinct features is to make them optional and independent.)

In this example, say the event feature provides an 'event' content type with fields including a required 'date' field. The description of the event content type is: "An event takes place at a specified time." The location feature provides a 'location' content type.

But if I have both events and locations, there's a relationship between them. Events take place at a location. So on a site with both the event and the location features installed, the event content type should get an additional required field, "Venue", that's a reference to a location. When that happens, the description of the original event content type should change accordingly. Now it should read: "An event takes place at a specified time and place."

To make this happen, the location feature (or, possibly, a third feature) is going to have to alter the event feature's configuration.

Drupal's configuration data is exported in YML format. Here's a snippet of what the event content type would look like as provided by the event feature:

name: Event
type: event
description: 'An event takes place at a specified time.'

We only want to change one property, description. Here's the result we want after an alter:

name: Event
type: event
description: 'An event takes place at a specified time and place.'

While it looks innocuously simple, even this rudimentary alter turns out to present thorny challenges when it comes to producing and updating packages of shared configuration.

Overrides and alters in Drupal core

There are several ways that configuration changes, overrides, and alters are supported in Drupal core. We'll review them before digging into specifics.

Optional configuration

Extensions can provide optional configuration: configuration items that are installed only when certain conditions are met. In our example, the event venue field could work well as optional configuration provided by the location feature. This optional venue field will be installed only when the event feature is installed and its event content created. We'll see below that the task isn't quite so easily accomplished, but getting the field in place is at least a start.

Optional configuration helps with the use case of extending one module's configuration in another module, but doesn't do alters.

Installation profile configuration overrides

If you've ever tried to install a Drupal module that provides configuration that already exists on your site, you'll be familiar with the often perplexing error that Drupal core throws to the effect that configuration items provided by the module "already exist in the active configuration". This error occurs because regular modules and themes can't re-provide configuration that's already provided by another extension. But installation profiles can. For example, if you put a customized version of the site.info.yml file in an installation profile's config/install directory, that file will be installed on the site rather than the version provided by core's system module. For more on configuration overrides in installation profiles, see this blog post.

Configuration overrides in installation profiles are useful, but have key limitations:

  • They're only an option in the installation profile.
  • They only work for a full override of a configuration item, not for a selective alter.

Programmatic changes to configuration

It's possible to make programmatic changes to configuration in custom code--for example, in an update function. That's what core does in the Standard installation profile's install function. For example, code in that function sets the site's home page, a property of the site.info configuration item.

That works for one-off changes. But:

  • As alters multiply, so does the amount of custom code.
  • Such changes can't be worked into an automated configuration update workflow. For example, the Configuration Provider module introduced in part 1 of this series has no way of guessing what arbitrary changes may have been made in custom code.

Configuration override system

Drupal 8 introduced a system to override configuration from modules--see the relevant documentation on drupal.org.

In this system, an override is a change to configuration that's dynamically applied on top of the site's active configuration. Overrides are a good fit for cases where a change needs to be made only under certain conditions. The classic use case in core is language-specific configuration overrides--see the drupal.org documentation on translating site interfaces. If you've ever switched languages on a Drupal 8 site and seen a field label change to the new language, you've seen configuration overrides in action. User interface translation fits the model of a conditional change because the text presented to users needs to be changed only if the site is multilingual and the interface language is other than the site's default language.

Configuration overrides are also used in the contributed Domain Access module. There, the need is to customize configuration per domain.

There's a contributed Configuration Override module that allows modules to provide configuration overrides alongside the other configuration they provide.

But for our purposes it won't work for alters to be layered on top of the active configuration. Instead, we need them to behave just like regular extension-provided configuration. For example, we want the resulting configuration to be editable. Configuration overrides aren't a good fit.

Overriding configuration in settings.php

A final way core supports altering configuration is in the settings.php file used to provide and customize a site's settings--see the relevant documentation on drupal.org. For more on overriding configuration in settings.php, see this blog post.

Again, while useful for other purposes, this approach doesn't help with feature-provided configuration since (a) it has the same disadvantages as module-provided configuration overrides and (b) we can't rely on site admins to manually edit their settings.php files.

Challenges of Drupal 8

In the intro we looked at an example of configuration altering: changing a content type's description. But in Drupal 8 the need for alters runs much deeper.

Shared configuration was the original use case in Drupal for exportable configuration. Drawing on innovation by Earl Miles and others in the Views module, major work took place in and around the Features module. The original announcement of the Features module in 2009 laid out the program:

A feature is a collection of Drupal entities that, taken together, satisfy a certain use-case.

And:

individual feature modules don’t script site building or use update scripts to maintain themselves. Instead, we take advantage of the powerful exportables concept pioneered by Views to allow all of your feature’s site building to live in code (exported views, contexts, imagecache presets, node types, etc.) but also be overridden and in the database.

Because work focused squarely on the Features use case, exportables were structured from the start to facilitate stand-alone configuration packages. To take two key examples:

  • A user role can have multiple permissions assigned to it. Typically, a site will have a small number of user roles and each separate feature will need to provide permissions to one or all of those roles. In Drupal 7, exportables were structured to make this easy, by exporting user permissions separately from roles.
  • A content type has multiple fields. A fairly common need is for one feature to add a field to another--like in our example of a location feature adding a field to events. As well as the field structure itself, a field typically needs to be displayed. In Drupal 7, the export of a field (then termed a field instance) included its presentation information for multiple displays (view modes).

But the focus on configuration staging in Drupal 8 meant that exportables were rewritten seemingly without reference to the use case of shared configuration packages.

Contrary to Drupal 7, in Drupal 8:

  • Permissions are exported as part of the role entity. This means that this quintessentially basic requirement of stand-alone configuration packages - adding a permission to a site-wide user role - requires complex customization via alters. Various workarounds have emerged in contrib. Two examples are Config Role Split and Role mixins / Subroles. The Features module in Drupal 8 includes a related workaround: permissions are optionally stripped on user role export, since lumping them into a single feature would break the ability to produce stand-alone features.
  • With field configuration, we're no better off. The relevant configuration entities include display information for all fields in a single entity, meaning a feature adding a field to another feature's content type can't just export its own configuration. Instead it must perform complex alters on multiple entities provided by the other feature. How? See this Drutopoia documentation page for the messy details of one approach.

Because of regressions in Drupal 8 compared to previous versions, alters are needed even for some of the most basic and common tasks of building features.

Modules for configuration alters

Fortunately, there are at least two contributed modules that provide support for module-provided configuration alters: Config Actions and Configuration Rewrite. The Update Helper module provides similar functionality, though in that case linked specifically to updates. In Drutopia we've chosen to work with Config Actions since it provides a full set of tools for adding, deleting, and changing configuration properties along with extensive documentation.

Using Config Actions, a config action is a manually edited file that you place in a module's config/actions directory. The file contains just the additions, deletions, or changes you want to make.

Here's a simple example. To accomplish the alter from the intro - changing the description value of the event content type - we would start by creating a file with the same name as the item we're altering, node.type.event.yml, and putting it in the location feature module's config/actions directory. The file's content would be:

plugin: change
path: ['description']
value: 'An event takes place at a specified time and place.'

This says:

  • Use the change plugin (a plugin determines what type of action to apply).
  • Make the change the description property.
  • Set the new value to read 'An event takes place at a specified time and place.'

Add the file, install the event feature, then install the location feature, and voila, we have the altered event content type description just like we wanted.

But what if a given site installs the location feature first, and only later adds the event feature? Sadly, in that case, we'd be out of luck. By default config actions (and the config rewrites supported by the Configuration Rewrite module) are applied only when a module is first installed. To address that issue, we might have to pull our alter into a bridging feature: a feature that provides the integration between two other features. If we make the bridging feature require both the event and the location feature, we can ensure the event content type exists when the alter is applied.

For our use case of importing configuration updates from features, alters present a series of additional challenges that don't have such easy workarounds.

Altering provided configuration

In Part 1 of this series we looked at the Configuration Provider module, which answers the question: what configuration is available to be updated? That module includes support for the configuration models supported by Drupal core: required configuration in config/install and optional configuration in config/optional.

Support for config actions is accomplished in Config Actions Provider. As noted on its Drupal.org project page:

Config Actions Provider integrates the Config Actions module with Configuration Provider, making it possible to apply config actions during configuration updates.

Concretely, Config Actions Provider provides a config_provider plugin that accepts configuration provided by other providers (such as required and optional) and applies any available alters to it.

The Nitty Gritty

For those interested in the messy details....

Alters raise the issue of ownership. Which module "owns" the snapshot of a configuration item? Typically, we'd say a piece of configuration is owned by the module that provides it. But with alters the resulting configuration structure is the sum result of input provided by multiple sources.

Also, the order in which alters are applied matters. If two different modules have changed the same configuration property, only the second change will be in effect.

In Config Actions Provider and related modules, we assign ownership to the module that originally provided the configuration. For example, when we're listing available configuration updates by providing module, any alter-provided changes are assigned to the module that provided the original item.

To emulate the altering that happens at install time, alters are applied in module dependency order--the same order that modules are installed in. Even if we're loading only a single module's available configuration, we iterate through all installed modules, since any of them could provide an alter for this module's configuration.

If determining what alters would be applied to configuration as provided sounds tricky enough, it's really nothing compared to the challenges of applying alters to configuration snapshots.

In Part 2 of this series we looked at the Configuration Snapshot module which provides the ability to take snapshots of configuration as provided by installed extensions. A snapshot should answer the question: what was the state of this configuration as provided when it was last installed or updated?

Introducing configuration alters makes that question a lot harder to answer.

Recall that alters are applied when the module providing them is installed. This means that a snapshot of the configuration as installed or updated has to include all alters that were actually applied, but not any that may have been added since installation or update. Say as a module author I add a new alter to an existing module. New sites that install that module will get the alter, but sites on which the module is already installed won't. For our purposes, what should happen in this case is:

  • The alter should show up in the data returned by Configuration Provider on what's available to be installed or updated.
  • The alter should not be included in the snapshot.

That way, when the currently-available configuration as provided is compared with the previous snapshot, the alter will show up as an available update.

In our Drutopia work, much of the handling of snapshotting for configuration alters has gone into the Configuration Synchronizer module, which we'll introduce in the next installment in this series.

Integration for snapshotting config actions is in the Config Actions Provider module. There we do pretty much the inverse of what we do for provision. Rather than iterating through all modules and applying their alters to the provided configuration, as we do for provision, for snapshotting we iterate through all existing extension snapshots and apply to the snapshots any alters provided by the extensions we've just installed. That way, when a module is installed, any alters it provides are added to existing snapshots.

Potential enhancements

The core issue Add configuration transformer API proposes an approach that dispatches and subscribes to events (not the kind in the hypothetical event feature discussed above!) to assemble available configuration. If that API is added to core, it could open the way to use a parallel approach for config alters.

Related core issues

Next up

Stay tuned for the next post in this series: Updating From Extensions. In that installment, we'll start to pull together everything we've covered so far: configuration providers, snapshots, merges, and alters.

Sep 18 2018
Sep 18

Even though it is has been 20+ years since I graduated from college, every September I struggle to get back to work while also feeling inspired to learn something new.

This summer I took a rest from blogging about sustainability, but I kept on coding. I felt a little guilty thinking my blog might lose its momentum, yet somehow on the “work” side, I just kept on plugging away at the Webform module’s issues queue and managed to fix a bunch of issues and make some important accessibility and UX improvements.

Coding is what I love to do; it is what drives me.

Coding is what I love to do

As I charge forward toward a stable release of Webform 8.x-5.x by Christmas, it’s time to start thinking about what’s next for the Webform module. There are a lot of people in our community thinking and talking about the future of Drupal. Drupal and most Content Management Systems (CMS) are moving towards a decoupled and headless approach.

Headless software is software capable of working on a device without a graphical user interface. Such software receives inputs and provides output through other interfaces like network or serial port and is common on servers and embedded devices.

-- https://en.wikipedia.org/wiki/Headless_software

Beginning to think about headless Webforms and Form API (FAPI)

Webform and Drupal's Form API (FAPI) has to start supporting headless Drupal and decoupled websites and applications. The Admin UI & JavaScript Modernisation is beginning to think about and experiment with, how to make Form API work with React. React will provide us with a frontend framework to build the rich user experiences and applications that our clients and users need. Choosing a frontend framework is a big decision that necessitated a considerable discussion. React's a solid choice for a frontend framework but I’m not sure it should be the foundation for an Open Source reusable form builder.

If we could decouple form elements, validation rules, and data definitions in an abstract and reusable way, any application would be able to reuse these elements or web components.

Web components

Web components are a set of web platform APIs that allow you to create new custom, reusable, encapsulated HTML tags to use in web pages and web apps. Custom components and widgets build on the Web Component standards, will work across modern browsers, and can be used with any JavaScript library or framework that works with HTML.

-- https://www.webcomponents.org/introduction

Conceptually, I was sold on the value of web components while attending John Riviello and Chris Lorenzo’s session titled "Web Components: The Future of Web Development is Here", at Drupaldelphia. They showed how Comcast is leveraging web components across all their websites.

I also watched the "Webcomponents, Polymer and HAX: decoupling authoring for Drupal and beyond" presentation by Bryan Ollendyke and Nikki Massaro Kauffman from DrupalCon Nashville. The HAX project shows the potential of web components.

There is a lot to learn about frontend frameworks and technologies

Headless Drupal has opened up our world to a variety of frontend frameworks and technologies.

A funny thing that I have to openly admit is that I have yet to code a React application or build a single web component. It took me 20 years of no longer being a student but I can now candidly say, accept, and feel no shame admitting when I don’t really know something; while knowing I can learn it. There is no way that we can know every technology. The best we can do as good software engineers is to be comfortable with continually learning new things.
 

React, Web components and all frontend works are completely new to me. The heart of all frontend frameworks is JavaScript. The real challenge we are facing with moving into the headless Content Management System world is learning JavaScript.

Learn JavaScript, Deeply

Drupal has better code and API's than WordPress but I have to give Matt Mullenweg credit for directly pushing the WordPress community to become better developers. In 2015, Matt told the WordPress community "To Learn JavaScript, Deeply." The only other time I have seen a tech leader take such a direct and game-changing stand on a technology was Steve Jobs rejecting Flash in favor of HTML5. Matt Mullenweg told the developers of the most popular CMS to learn JavaScript, deeply
 

Dries Buytaert has shared a similar call-to-action with the Drupal community:

Sharing my journey while relearning JavaScript

JavaScript and I go back a long way. My first steps into the world of programming was using JavaScript to generate an email via an HTML form that built using MS FrontPage and worked in Internet Explorer 3. My first HTML form and JavaScript is still online and it even works after 20+ years.

My first CMS, called the Inettool, was built using JScript and ASP. The code was entirely procedural and honestly, I still have not determined the best approach to creating object-oriented JavaScript.

I will keep posting about my experience with learning JavaScript, deeply. For now, I need to wrap up development of Webform 5.x.

Wrapping up Webform 5.x and looking to 6.x and beyond

For the past 2 years, I have done an introductory presentation and screencast about the Webform module and it’s time to explore some advanced topics including testing, APIs, plugins, hooks, and more…

I will be speaking about Advanced Webforms at BadCamp in 2018. Please attend my session or like me, you might want to start learning JavaScript and attend other great sessions at these conferences and many more.

Almost done…

We just sent you an email. Please click the link in the email to confirm your subscription!

OKSubscriptions powered by Strikingly

Sep 18 2018
Sep 18

At the beginning of September 2017 the Drupal Association announced that they aren’t going to organise the annual DrupalCon Europe in 2018. Instead of that they focused on discovering a sustainable model for the future.

Community stepping up

After the announcement, European Drupal community was terrified and most of corridor talks at DrupalCon Vienna were about patching this state, which led to announcing Drupal Europe in October. During the rest of the year a group of volunteers from all over Europe worked hard and the European community could met again in September 2018 in Darmstadt, Germany on a new event called Drupal Europe. 
The whole conference was organised by volunteers. Given the volume of needed work during the conference, organisers had called for help and I decided to join the volunteering team. That means that I decided to spend significant amount of time during conference as a room monitor or with some other tasks, basically whatever organisers asked me to do I was more than willing to help them. 

So how was it?

On Monday, the first morning of the conference I started with volunteering as a room monitor in contribution rooms. I was working on getting my contrib modules to better shape. 
Contribution room is a new term introduced by the Drupal Europe team in order to decrease focus on the coding part of contribution, which Drupal really needs and benefits from.
After lunch - vegetarian and vegan food during the week - I rushed myself to invites only roundtable of community leaders. This was one of the things I was most looking forward to. The roundtable was opened by Dries Buytaert, the Drupal project owner, and Megan Sanicki, the Drupal Association executive director.

Awesome to meet over 30 Drupal community leaders from different European countries and to represent #drupalat. As somebody said, together we can create magic! #drupaleurope pic.twitter.com/Jm1MApJl7N

— Christian Ziegler (@crizzirc) September 10, 2018

It was great to hear that almost all communities in Europe are facing the same issues. The main problem was identified as lack of marketing - towards developers, agencies, clients. Later we split into smaller groups - each of the group had to come with at least three quick wins for communities. The most liked wins were hiring part-time marketing person in every community and preparing marketing starter kit for different situations. These issues are now being worked on by community leaders.

Session days

Tuesday started with a new event, the European Splash Awards, designed for agencies and their clients to celebrate their successes.
Next session for me was about the Drupal.org Update, which provided quite extensive description of all services the Drupal Association is running under the Drupal.org hood.

Congratulations to all the #splashawards winners at @DrupalEurope! Such an impressive list of brands and innovative Drupal use cases. pic.twitter.com/40V0y7jeHe

— Dries Buytaert (@Dries) September 11, 2018

Then I took a place on the session about decoupled Drupal and Gatsby by Joe Shindelar.  GatsbyJS is a static site generator build in Node.js. It combines traditional approach with internal GraphQL and ReactJS. This allows you to add dynamic parts to your statically generated site. You should definitely use it if you want your sites to be blazing fast :)
The first session day ended with party in typical German beer garden. 

Wednesday started with traditional Prenote session. This year’s mix of fun and songs Jam and Campbell pointed out the diversity in our community and that’s what makes Drupal great.

So delighted that #DrupalEurope continued the fine tradition, no institution!, of #Prenote this year. Always causes belly laughs. @HornCologne @rachel_norfolk pic.twitter.com/L79fFcuhpq

— Paul Johnson (@pdjohnson) September 13, 2018

After the funny part a more serious Driesnote took a place. Dries showed all the cool new features in Drupal 8.6, which was released just in the beginning of September. After that we learned some important dates - Drupal 9 development will start soon and the expected release is in 2020, also Drupal 7 and Drupal 8 will end their lifecycle in 2021. If you are using Drupal 8 with well-maintained modules, you should have no problems with updating to Drupal 9.

Drupal 7, 8, and 9: deprecate the old to intake the new https://t.co/1d6PVDJj1d @nmdmatt responds to the #DrupalEurope 2018 #DriesNote

— Drupal (@drupal) September 18, 2018

Important news for the European community was the announcement that DrupalCon Europe will be back in 2019 at the end of October in Amsterdam.

We are delighted to announce the next #DrupalCon Europe will be in Amsterdam 28 Oct - 1 Nov 2019. For news and updates be sure to subscribe to our email list https://t.co/Osq2vENWBw #DrupalEurope #DriesNote pic.twitter.com/XgmAHFa8B0

— DrupalCon Europe (@DrupalConEur) September 12, 2018

In the afternoon I held my session about Drupal 8 Commerce. In the session I talked about multi currency and different approaches to it. More than 20 people attended my session including Bojan and Matt from Commerce Guys, authors of Drupal Commerce.
The day ended by a Q&A session with Dries and Rachel Lawson. People were able to ask much more questions than during previous DrupalCon’s Q&As after Driesnote. It’s not surprising that a lot of questions were about the upgrade path for Drupal 9 or stability of Drupal and its ecosystem.
The last day of sessions started with a panel discussion about open web. It’s little frightening that none of the panelists thinks that open web is winning.

Impressive panel at #drupaleurope with @Dries, Barb Palser, Heather Burns, DB Hurley @TimLehnen about The future of the #openweb and #opensource pic.twitter.com/FH3MfhO84V

— ricardoamaro (@ricardoamaro) September 13, 2018

Then I attended a session about business implications of decoupled Drupal. Michael from Amazee talked about their journey of becoming a Drupal and React agency. For me a quite surprising fact was that they don’t have separated roles for frontend and backend, but people are more universal. Their cost for this makeover was over 300k EUR.
My afternoon was again focused on the community. I attended a BOF about Community landing page where we discussed how to make something meaningful with it. I think it would be great if we could get some level of geolocated data there e.g. displaying local DUG, meetups, zoom into the country on Drupical. Output from the BOF was that a working group will look into data from analytical tools and will try to come up with stories why people are coming to that page.
The very last session I attended was retrospective for Drupal Europe. It was amazing to hear about the route the team had taken. I want to say huge Thank you to everyone who helped to make this conference happen. 

@dries leads a standing ovation expressing immense gratitude to the entire volunteer team who made Drupal Europe possible https://t.co/9oVVeRhwJr #DrupalEurope pic.twitter.com/u9OLJ94pNE

— Drupal (@drupal) September 12, 2018

The end

The last day of conference was once again contribution day. Mentors trained a couple of new contributors and taught them about Drupal ecosystem. I focused again on my contrib modules, mostly writing automated tests for them.
I must say that I enjoyed being at this conference, it was great to meet a lot of my Drupal friends and I’m looking forward to meeting you again in Amsterdam.

Here's the Drupal Europe Group Photo. Thanks for participating everyone! #drupaleurope @DrupalEurope @amazeelabs https://t.co/SHbkKBQEBe pic.twitter.com/r1LLdFi7eS

— Josef Dabernig (@dasjo) September 12, 2018
Sep 18 2018
Sep 18

A slick new feature was recently added to Drupal 8 starting with the 8.5 release  — out of the box off-canvas dialog support.

Off-canvas dialogs are those which slide out from off page. They push over existing content in order to make space for themselves while keeping the existing content unobstructed, unlike a traditional dialog popup. These dialogs are often used for menus on smaller screens. Most Drupal 8 users are familiar with Admin Toolbar's use of an off-canvas style menu tray, which is automatically enabled on smaller screens.

Admin toolbar off-canvas

Drupal founder Dries posted a tutorial and I finally got a chance to try it myself.

In my case, I was creating a form for reviewers to submit reviews of long and complicated application submissions. Reviewers needed to be able to easily access the entire application while entering their review. A form at the bottom of the screen would have meant too much scrolling, and a traditional popup would have blocked much of the content they needed to see. Therefore, an off-canvas style dialog was the perfect solution. 

Build your own

With the latest updates to Drupal core, you can now easily add your own off-canvas dialogs.

Create a page for Your off-canvas content 

The built in off-canvas integration is designed to load Drupal pages into the dialog window (and only pages as far as I can tell). So you will need either an existing page, such as a node edit form, or you'll need to create your custom own page through Drupal's routing system, which will contain your custom form or other content. In my case, I created a custom page with a custom form.

Create a Link

Once you have a page that you would like to render inside the dialog, you'll need to create a link to that page. This will function as the triggering element to load the dialog.

In my case, I wanted to render the review form dialog from the application full node display itself. I created an "extra field" using hook_entity_extra_field_info(), built the link in hook_ENTITY_TYPE_view(), and then configured the new link field using the Manage Display tab for my application entity. 

/*
 * Implements hook_entity_extra_field_info().
 */
function custom_entity_extra_field_info() {
  $extra['node']['application']['display']['review_form_link'] = array(
    'label' => t('Review Application'),
    'description' => t('Displays a link to the review form.'),
    'weight' => 0,
  );
  return $extra;
}

/**
 * Implements hook_ENTITY_TYPE_view().
 */
function custom_node_view(array &$build, Drupal\Core\Entity\EntityInterface $entity, Drupal\Core\Entity\Display\EntityViewDisplayInterface $display, $view_mode) {
  if ($display->getComponent('review_form_link')) {
    $build['review_link'] = array(
      '#title' => t('Review Application'),
      '#type' => 'link',
      '#url' => Url::fromRoute('custom.review_form', ['application' => $entity->id()]),
    );
  }
}

Add off-canvas to the link

Next you just need to set the link to open using off-canvas instead of as a new page.

There are four attributes to add to your link array in order to do this:

      '#attributes' => array(
        'class' => 'use-ajax',
        'data-dialog-renderer' => 'off_canvas',
        'data-dialog-type' => 'dialog',
        'data-dialog-options' => '{"width":"30%"}'
      ),
      '#attached' => [
        'library' => [
          'core/drupal.dialog.ajax',
        ],
      ],

The first three attributes are required to get your dialog working and the last is recommended, as it will let you control the size of the dialog.

Additionally, you'll need to attach the Drupal ajax dialog library. Before I added the library to my implementation, I was running into an issue where some user roles could access the dialog and others could not. It turned out this was because the library was being loaded for roles with access to the Admin Toolbar.

The rendered link will end up looking like:

<a href="https://www.zivtech.com/review-form/12345" class="use-ajax" data-dialog-options="{"width":"30%"}" data-dialog-renderer="off_canvas" data-dialog-type="dialog">Review Application</a>

And that's it! Off-canvas dialog is done and ready for action.

off-canvas-demo-gif
Sep 18 2018
Sep 18

I'm Ana, and I'm a talent manager at Agiledrop. It is a little less than a year since I joined Agiledrop team, and Drupal Europe was my first larger Drupal event. I have attended some of the Drupal events in Slovenia, like Drupal meetups, which are not nearly as big as other Drupal events, especially global ones. They are (for now) small and cosy, but I am proud of them - because Agiledrop is taking the initiative to grow the Drupal community in Slovenia bigger and stronger. We are presenting how great Drupal is by organizing Drupal courses and speaking at meetups.

So how was Drupal Europe for a first-time to a non-developer person like me?

I was extremely excited to get to meet people from the Drupal community in person and to add a face to all great bloggers, whose blog posts I'm reading. Do you want to know what I've learned in those few days as a non-developer at Drupal Europe? 

Before arriving at the conference, I felt like an intruder, as I was expecting technical participants and very conservative environment. Instead, I found it very welcoming and easygoing, and I immediately felt accepted, even though I’m not a developer. I feel this was important for me, as a talent manager, to understand the underlying community that makes Drupal happen because the values of the community are also the values in which we believe at Agiledrop.

I was honoured to meet Baddy Sonja Breidert from 1xInterent and one of the main organizers of Drupal Europe. It felt like the event has inherited her values and believes, and was so good because of that. Diversity is an important topic in the Drupal community and it was mentioned many times in the conference programme. Moreover was kept in mind in every aspect connected with conference organizers. As a woman in the tech world, with a background in social work, I am naturally more open to seeing the problems with diversity. I will definitely take many findings back to our company.

I also had a chance to meet in person people, whom I interviewed this year. Just a minute after arriving Josef Dabernig came over to say hi, Michel van Velde, CEO of One shoe told me the story about his agency's name, and I was able to say quick thanks to Rachel Lawson who was actively involved with the conference as the Community Liaison. 

I also had one secret wish I didn't get to accomplish, but maybe it's going to get realised next time. I wanted to take a photo with the person who made all this happened, who created the software and is continuing leading the community. Unfortunately, I didn't have the chance to catch Dries in the hallway… but I will most certainly try again next time. 

Big thanks to all the volunteers that made Drupal Europe happened, and thanks to the whole Drupal community to accept me in your mids. 

Sep 18 2018
Sep 18
The Drop Guard Team at Drupal Europe
It has been a week full of impressions, old and new friends and exciting challenges at Drupal Europe! The Drop Guard team members Joe, Max, Alexey, and Johanna attended the Drupal event from 10th to 14th of September. 

This is a brief overview of our Drupal Europe highlights and impressions, enjoy it!

The Drop Guard team members Max, Joe, Johanna, and Alexey

 
Alexey Beloglazov, our lead developer, came from Belarus to say hi! and to enjoy a great week in person with his team and at Drupal Europe. Meeting international colleagues in person will bind the whole team together is worth it every time!

Team week impressions

 
We won't wait long to bring the whole team together again! We also spent this week with Balazs from the European Commission, Andrew from Bright Solutions and Hendrik, who supports us with server maintenance all day and all night! 

Team shenanigans

 

We are also very proud of three active participation in Drupal Europe from our side:

THANKS TO EVERYONE who made this wonderful week possible and as great as it was!

THANK YOU!

 
Sep 18 2018
Sep 18
Max Madl's first workshop at Drupal Europe
Our CTO Max Madl held his first workshop at Drupal Europe last week. The main goal of this hands-on session was to show the audience what it means to update a Drupal project
a.) manually
b.) with helping tools & services
c.) fully automated.
22 developers approached these tasks.

The questionnaire about the services, tools, and systems they’re using led to interesting results: 

used CI/CD tools

So, nearly three-quarters of our group deal with manual update processes. 

We also asked them which hosting providers they use in their pipeline:

Used hosting providers

 
This group of 22 people does not represent the whole Drupal world, of course, nevertheless, we felt confirmed that a big part of agencies and freelancers don’t use the benefits of tools and services to optimize (or even build) their update pipelines. 
The first task was to create a manual update process - phew, you might know what that means: time consuming and boring. But the attendees did well and stuck to it. After that, Max presented relieving CI/CD tools and hosting services that ease that manual update pain. 

Max presents common CI/CD solutions

 
Finally, the audience could experience what it means to automate the whole update process with Drop Guard. After understanding the characteristics of the tool, the main feedback was a real aha experience - update processes can be managed as a whole by a tool, automatically! 
After this first workshop experience, Max is keen to think about further ways to submit update related workshops to encourage Drupalers to optimize their update process - be it by including CI/CD tools, using hosting provider pipelines or by managing updates automatically. The main goal is to make people realize how update processes can block the productivity and security of a team or project - and how to avoid this and even make a profit out of it.

If you have any questions or want to as for the details behind this workshop, you can always contact us.

 

Sep 18 2018
Sep 18
Why we need to talk about Auto Updates
Joe Noll, CEO at App Guard GmbH, and Hernâni Borges de Freitas, Technical Architect, raised awareness about Drupal update security and why we need to talk about the Drupal Auto Update Initiative. 
The talk included facts and figures about the amount of insecure website or “types of updaters", the main risks and - especially the opportunities and role of the Auto Update Initiative.
This post provides you the gateways to the session slides "Drupal Europe 2018: Hackers automate but the Drupal community still downloads modules from drupal.org", and the topics update automation and Auto Update Initiative in Drupal. 
Joe Noll and Hernani about why we should talk about Update Automation: 
                                           ​
Drupal Europe 2018: Hackers automate but the drupal community still downloads modules from drupal.org from hernanibf

 

Join the Auto Update Initiative 

You can take part in the discussion on drupal.org and support it by also encouraging others to give thoughts on this important topic:
Auto Update initiative on drupal.org.

Test Drop Guard's solution

You can also test Drop Guard to experience an existing solution for Drupal update automation management. Just sign in and test it for free. Or contact us to get a personal onboarding, we're looking forward to meet you!
 

Auto updates discussion via slack

And we always recommend to join slack channels such as the main https://drupal.slack.com channel and if you want to learn more about Drop Guard, you can also join our support channel https://dropguard.slack.com.

Questions? Contact us, we're here for you!

Sep 18 2018
Sep 18
It’s happening. Drupal 8 will be end-of-life by November 2021. So what does that mean? Well, whether you’re talking about a vehicle or a website, ensuring that routine maintenance is regularly performed can contribute to a smooth path. And when it…
Sep 18 2018
Sep 18
Contribute Today! at Drupal Europe
I’ve joined the Drupal mentoring team for the first time last week at Drupal Europe.
In this post, I’ll share how and why this contribution changed the way I think about Drupal events and the Drupal Community. 

The bigger picture

Joining a Drupal group and contribute in any kind of way - be it by mentoring, developing, marketing, or simply assisting - gave me a real-life insight into what it really means to give something back to the community and find solutions. It changes your point of view, as you face the challenges of a bigger picture and not only those of your own company or team. 
“Contribute Today” - I’ve never felt addressed to this call because I had no idea what contribution could mean. I just filed that information under “okay, I don’t fit into the idea of contribution”.
And left it in this drawer until Balazs encouraged me to join Drupal Europe as a mentor. 

Question marks

So, I came to the congress center Darmstadtium on Monday, Sept. 10th, and had hardly an idea of what I will do as a mentor - what are “typical” tasks of a mentor, what skills are required? And so on. I tried to figure it out and checked the Drupal mentoring slack channel, asked lovely mentor old hands, but - let’s be honest - everyone just had to figure out their stuff as well so I was still left with questions marks in my head, but I knew they will be cleared somehow. 
That’s the lesson no. 1, by the way: ASK. Just ask. Ask often, ask everyone, ask the channels, ask your team, ask. Everyone will be happy to help you. 

What it means to mentor and contribute 

During the next days until Friday, I was helping by keeping an eye on the mentoring booth, but I focused on my team and marketing as well so the question marks for Contribution-Friday just got pushed back somewhere in my brain. A quick mentor meetup informed me about the time I need to arrive on Contribution-Friday and encouraged me that everyone is qualified to be a mentor. 
Lesson 2: Open your mind - I’ve learned that mentoring was not just about helping others to code or contribute to the Drupal core.
And then Contribution-Friday dawned and I met with the group of mentors, which were welcomed warmly by Rachel
My first task was simple but important so everyone felt welcomed: Balazs, Merel and I guided all arrivals and ensured that they’ll find their way to the right contribution room. 
Simply put, there were two rooms: One room that offers mentored groups, recommendable for contribution newbies, and one room for those who already know what issues they want to solve or how they want to contribute, so let’s say the old hands.  

Mentor Squad

Mentoring means to ensure that people work together in those guided contribution spaces. You don’t have to know every answer to a question, you don’t have to know how to code. You can always ask those people who know the right answer to those questions. The most important thing about greenhorn mentoring & contributing is to ensure that people start with an easy issue to understand the process of contribution. It’s about understanding what it means to find a solution together, in a team, for the bigger picture. You don’t need to be a developer, there are so many issues that address non-developers or work that can to be done by non-devs so the developers can achieve the next step within an issue (e.g. testing, giving feedback etc). 
So, my question marks about what it will require to be a mentor were resolved. 

My personal contribution experience 

After a few time of welcoming people, I was asked by Rachel if I want to contribute as a non-developer with a marketing background. Of course, I wanted to! So we headed together with Gabor to the mentored contribution room where I was introduced to Billy and Billy from the University of Edinburgh, to Karlo from Burda, and also Baddy Breidert and Elli Ludwigson were there again.
The main purpose of this group was to find out the main hubs where people fail to get involved as mentors or contributors in general - and to talk about solutions for it. 
Within this discussion, Karlo & I submitted our first issue on drupal.org ever, yippie!! The issue addresses the problems of newbies when they first attend a Drupal event and don’t know anything about contribution options etc. Check “Arriving at DrupalCon as a Newbie Non-Developer” and help us to find solutions! After focusing on this important first step, that determines whether you win a contributor (or mentor) or not, and submitting the issue successfully, I felt that highly motivating feeling of “I can change something”. This issue addresses a huge group of people that I am - or was - part of: the newbies without any clue, with the mindset that “contribute today” was about coding and for developers.
Furthermore, we discussed possibilities to support the process of encouraging people to mentor and how the mentor group can be supported in general (stay tuned, we have big plans!!). 
All in all, it made me realize lesson 3: Join contribution-Friday, join a group, be open to utilize your skills and be a little bit bold! Everybody has something that is worth it to be contributed.

"Karlo's & my first submitted issue" - face

 
I arrived with some question-mark-salad in my brain and left Drupal Europe with the proud feeling that I contributed to this community, that I now understand what kind of issues this community also faces and that I really can help to find solutions for those issues as well.
I am a part of it, so I will contribute. 
And last but not least: Being super hyped after a Drupal event is great, it fills you with anticipation, so you can’t wait for the next Drupal event and the next issues. Simultaneously, let’s stick to the issues we just started, let’s bring it to the next level and maybe even solve it completely! 

Gateway to get involved:

What are your thoughts, ideas or concerns about this topic? Let me know via [email protected]

Contribute Today!

 
Sep 17 2018
Sep 17

At Drupal Europe, Dries announced the release cycle and end of life for Drupal's current and next version. Spoiler alert: I am beyond excited, but I wish the timeline could be expedited. More on that to follow.

Here is a quick breakdown:

  • Drupal 8 uses Symfony 3. Symfony 3 will be at its end-of-life at the end of 2021, forcing Drupal 8 into end-of-life
  • Drupal 9 will use Symfony 4 or 5 and be released in 2020 (a year before end-of-life.)
  • Drupal 7 will also end-of-life at the end of 2021, matching Drupal 8, simplifying security and release management.
Drupal 7, 8, 9 End of Life timeline

Timeline copied and cropped from https://dri.es/drupal-7-8-and-9

I feel some will use this as an excuse to bash and argue against our adoption of Symfony within Drupal core. Instead, I see it as a blessing. It is forcing Drupal to adopt new technology and force our hosting platforms and providers to do the same.

At a minimum, here are the aging technologies we are forced to support:

MySQL 5.5.3/MariaDB 5.5.20/Percona Server 5.5.8

MySQL 5.6 provides many improvements over 5.5, alone. Yes, you can use Drupal with MySQL 5.6, but the core product itself cannot harness any of its benefits. Or, what about MySQL 5.7 which includes support for JSON fields? In the 8.6 release, support for MySQL 8 was added -- but the only benefit is performance gains, not new technology.

PHP 5.5.9+ and 5.6

This is one of my biggest pain points. If you look at Drupal's PHP requirements page we support 5.5.9+, 5.6, 7.0, 7.1, and 7.2 However, Drupal 8 will drop support for PHP 5.5 and 5.6 on March 6, 2019. PHP 5.5 was end-of-life 2 years ago and 5.6 will at the end of 2018. Not to mention, 7.0 is end-of-life before 5.6!

We need modern technology in our stacks.

I am aware that hosts were slow to adopt PHP 7. Know why? Because our software was slow to adopt. We never caused them to update technology stacks. Symfony 4 requires PHP 7.1.3 or higher. Meanwhile, a stable Symfony 5 is planned to be released Nov 2019 (one year before Drupal 9 release.) I wasn't able to find information on the minimum PHP requirement, but I would assume it is at least 7.2 which means 7.3 will have full support.

I am excited for 7.3, like beyond excited. Why? Because garbage collection is severely improved. And Drupal loves to create a lot of objects and trigger a garbage collection during a request. For example, in Drupal 7 we had to disable it during a request to improve performance (was worth the tradeoffs.) Here's a link to the PR which hit 7.3.0beta3 and looks to improve the process by 5x its current speeds.

Having MySQL 5.7 would allow us to fully use JSON fields. This would be immensely useful in Drupal Commerce.

And now we wait (well, don't wait, Contribute!)

I wish we could make this process happen earlier. But that would be pretty unreasonable. There is a lot to accomplish in Drupal core to make this happen. The release managers and core maintainers have done an amazing job at managing Drupal 8 and shipping stable releases. They now have had a whole additional release branch and process thrown at them.

I encourage you to embrace this change and find ways to contribute to the 9.0.x branch, which might be easier than you think. Part of the 9.0.x effort is removing deprecated code (which is pretty easy to find.) I'm not sure if a plan has been cooked up yet, but there are issues on the 9.x branch https://www.drupal.org/project/issues/drupal?version=9.x

Sep 17 2018
Sep 17

We recently returned from Drupal GovCon and have some standout items we want to share. Overall, the experience was a lot of fun. It was exciting to get to watch Adam give the keynote on how to make an impact in the community. At Hook 42 we love giving back to the community, and it was a great reminder of how everyone who wants to give back, can contribute.

Session / BoF / Training / Track / Summit

Adam: I was honored to be able to give the keynote for the first day of the event. I have been attending Drupal GovCon for years and have always aspired to do this. On top of the keynote, I had a session on Components with Brian Perry (this was super fun) and participated in the governance and coffee BoFs. As such, I was not able to attend the full set of sessions I had wanted to. I often prefer to watch recordings anyway (thank you, Kevin Thull). I tend to learn more when it’s quiet and I prioritize spending time with people when I am at events. 

However, there are a lot of thought provoking sessions I have queued up to watch. There was some great technical content: David Hernandez Demystified Composer, Todd Nienkirk and Gerardo Maldonado both explored a future decoupled perspective on the web (in their respective sessions), and Jakob Perry dove into complexities between data structures and relationships.

There were many non-technical talks that I plan to watch as well: 

It was very clear from discussions and the energy at the conference that people spent a lot of time bringing relevant and thought-provoking topics to share at the conference. I was super impressed with both Lindsay’s and Aimee’s sessions. Overall, I was really pleased with the schedule at the event and know I’ll learn a lot.

Adam Bergstein delivering the Drupal GovCon keynote

Aimee: I had booth duty, so I didn’t go to many sessions. The caliber of speakers across the board provided a fantastic exploration on a wide breadth of topics. If you didn’t get to go to a session in person, speaking with the presenters in the “hallway track” and at social events was a learning experience not to miss. Thanks to Kevin Thull, the sessions are recorded and posted to each session page quickly. I’m still catching up on sessions! 

I’m not supposed to just talk about our team, but here we go: Adam’s keynote was inspirational and had a lot of very practical attainable improvements for helping folks navigate the Drupal Community. Lindsay did a great job covering Drupal 8 Custom Module development. She provided a clear path of how Drupal 8 module files communicate with and depend on each other. Mind blown. 

Joe from Aten presented about how to write a clear RFP. It was a time for responders and writers to discuss what works and what doesn’t when wrangling legalease to get project work done. It also had Van Halen references (David Lee Roth era) - win win! 

Dwayne from Pantheon is always a great speaker and rallies the folks, even when he closes out the camp with the last session slot. You must discover his session on Discovery!! You are a champ, Dwayne!

Lindsay: My biggest take away from GovCon is that we are a community - and that developers need to focus on accessibility. Websites are for people, so it makes sense that we want to create a platform that can reach as many people as possible. As a community, we also need to make it easier for people to contribute to Drupal.

An attendee at DrupalGovCon displaying personal pronoun sticker on their badge

Adam had a lot of great suggestions in his keynote that could help the community grow stronger. A great example of community contribution in action is Kevin Thull. Kevin gets his steps in at every conference he goes to by rushing from room to room getting every session recorded. In case you couldn’t make the trip to DC, all the recordings are available on YouTube.

While I didn’t get the chance to go to a lot of sessions, I did attend a great accessibility talk by Tearyne Glover. She gave a real-life example of how inaccessible websites hurt real users and how to fix these problems. 

Conversation

Adam: One of the points I raised in the keynote was the importance of the human connection within our community. There was a vibrant energy around this event that exemplifies this connection. Between the “hallway track” and the BoFs, much of my GovCon experience was conversation. And, that’s probably my favorite part. Since we are a distributed company, connecting with Aimee and Lindsay on our team was one of my highlights. It’s a great chance to connect with my community friends and make new ones. 

There were so many special people that attended (to name a few…): Kevin Thull, Brian Perry, Becca Goodman, Chris Urban, Dwayne McDaniel, David Hernandez, Tim Erickson, Danita Bowman, Brian Hirsh, Mike Herchel, Iris Ibekwe, Gerardo Gonzalez, Kev Walsh, Joe Shindelar, Elli Ludwigson, several of my previous co-workers at CivicActions and Acquia, and many more (by no means intentionally leaving someone out). This time together reaffirms how great our community is. Many people connected with me about my keynote. It’s these relationships that build trust and open up conversations to new and innovative things our community can accomplish.

Aimee at a Drupal GovCon session

Aimee: It was really great to connect with people who work within the government and public service space. I don’t often get to talk with folks working in those environments at camps. Working in the government, and supporting organizations, comes with challenges and strengths that take on a different tone than the private sector. It is beneficial and informative to hear about the technical and organizational needs of our public servants. 

Lindsay: It’s very hard to single out one conversation, so I’ll just say it was great to be at a Drupal event with Drupalers. Someone mentioned that the Drupal community was such a strange unique thing, because he had never heard of another group of people that voluntarily go to conferences on Saturdays. Overall, I am also just happy when I get to hang out with a great group of Drupalers. I met a lot of new people and had a great time!

Social Events

Adam: The Brickside event is one of the highlights of GovCon for me, as I often do not participate in game nights or events too far from the venue. The food, drinks, and good company at the GovCon happy hour always lift the experience. Often people continue onto karaoke, dinner, or other fun evening plans.

Aimee: The GovCon team really does a nice job putting together mixers for attendees to chat in a social venue. Filled with nachos, wings, and beer, the attendees hung out and got to chat at Brickside. Many camp organizers come to the event and it provides a great opportunity to hear how other camps across the US are being run and how they are responding to the community’s needs. There was a nice game night in the camp hotel that had a good attendance, although I only peeked through the window on the way back home.

Lindsay: Every night there was a dinner... and lots of talking... and lots of laughing. From the World of Beer, to Brickside, to Rock Bottom, to the tapas, and back to Brickside - I had a great time with great people.

Overall GovCon Experience

Adam: GovCon continues to be a great event on my schedule each year. The combination of connections, schedule quality, social events, and, honestly, the size of the event just make it special. I really appreciate all of the work done by the organizers; and, how much people invest in their sessions and booths to make the event special. 

Aimee, Adam, and Lindsay enjoying a session at Drupal GovCon

Aimee: GovCon is a wonderful event - the way it is managed, the people that attend, the relevant and timely topics, and the excellent location at the NIH. It is one of my favorite camps to attend and I look forward to returning next year. Thank you for hosting us, Drupal GovCon team!

Lindsay: This was my first GovCon and it was amazing! I met so many wonderful people, took my first trip to DC, presented at the NIH, and got to attend a very well-run camp filled with Drupalers. Awesome!

We hope to see you all at BADCamp!!

Sep 17 2018
Sep 17

This blog has been re-posted and edited with permission from Dries Buytaert's blog. Please leave your comments on the original post.

Last week, nearly 1,000 Drupalists gathered in Darmstadt, Germany for Drupal Europe. In good tradition, I presented my State of Drupal keynote. You can watch a recording of my keynote (starting at 4:38) or download a copy of my slides (37 MB).

Drupal 8 continues to mature

I started my keynote by highlighting this month's Drupal 8.6.0 release. Drupal 8.6 marks the sixth consecutive Drupal 8 release that has been delivered on time. Compared to one year ago, we have 46 percent more stable Drupal 8 modules. We also have 10 percent more contributors are working on Drupal 8 Core in comparison to last year. All of these milestones indicate that the Drupal 8 is healthy and growing.

The number of stable modules for Drupal 8 is growing fast

Next, I gave an update on our strategic initiatives:

An overview of Drupal 8's strategic initaitives

Make Drupal better for content creators

A photo from Drupal Europe in Darmstadt

© Paul Johnson

The expectations of content creators are changing. For Drupal to be successful, we have to continue to deliver on their needs by providing more powerful content management tools, in addition to delivering simplicity though drag-and-drop functionality, WYSIWYG, and more.

With the release of Drupal 8.6, we have added new functionality for content creators by making improvements to the Media, Workflow, Layout and Out-of-the-Box initiatives. I showed a demo video to demonstrate how all of these new features not only make content authoring easier, but more powerful:

We also need to improve the content authoring experience through a modern administration user interface. We have been working on a new administration UI using React. I showed a video of our latest prototype:

Extended security coverage for Drupal 8 minor releases

I announced an update to Drupal 8's security policy. To date, site owners had one month after a new minor Drupal 8 release to upgrade their sites before losing their security updates. Going forward, Drupal 8 site owners have 6 months to upgrade between minor releases. This extra time should give site owners flexibility to plan, prepare and test minor security updates. For more information, check out my recent blog post.

Make Drupal better for evaluators

One of the most significant updates since DrupalCon Nashville is Drupal's improved evaluator experience. The time required to get a Drupal site up and running has decreased from more than 15 minutes to less than two minutes and from 20 clicks to 3. This is a big accomplishment. You can read more about it in my recent blog post.

Promote Drupal

After launching Promote Drupal at DrupalCon Nashville, we hit the ground running with this initiative and successfully published a community press release for the release of Drupal 8.6, which was also translated into multiple languages. Much more is underway, including building a brand book, marketing collaboration space on Drupal.org, and a Drupal pitch deck.

The Drupal 9 roadmap and a plan to end-of-life Drupal 7 and Drupal 8

To keep Drupal modern, maintainable, and performant, we need to stay on secure, supported versions of Drupal 8's third-party dependencies. This means we need to end-of-life Drupal 8 with Symfony 3's end-of-life. As a result, I announced that:

  1. Drupal 8 will be end-of-life by November 2021.
  2. Drupal 9 will be released in 2020, and it will be an easy upgrade.

Historically, our policy has been to only support two major versions of Drupal; Drupal 7 would ordinarily reach end of life when Drupal 9 is released. Because a large number of sites might still be using Drupal 7 by 2020, we have decided to extend support of Drupal 7 until November 2021.

For those interested, I published a blog post that further explains this.

Adopt GitLab on Drupal.org

Finally, the Drupal Association is working to integrate GitLab with Drupal.org. GitLab will provide support for "merge requests", which means contributing to Drupal will feel more familiar to the broader audience of open source contributors who learned their skills in the post-patch era. Some of GitLab's tools, such as inline editing and web-based code review, will also lower the barrier to contribution, and should help us grow both the number of contributions and contributors on Drupal.org.

To see an exciting preview of Drupal.org's gitlab integration, watch the video below:

Thank you

Our community has a lot to be proud of, and this progress is the result of thousands of people collaborating and working together. It's pretty amazing! The power of our community isn't just visible in minor releases or a number of stable modules. It was also felt at this very conference, as many volunteers gave their weekends and evenings to help organize Drupal Europe in the absence of a DrupalCon Europe organized by the Drupal Association. From code to community, the Drupal project is making an incredible impact. I look forward to celebrating our community's work and friendships at future Drupal conferences.

A summary of our recent progress

Sep 17 2018
Sep 17

Let me give credit where credit is due. The Drupal community have transformed the way it works in 2018.

In years gone by, Drupal was not a very well-organized project. Everything was done in a stereotypically "open source" way with loose roadmaps and vague planning. The apex of this was the development of Drupal 8 which dragged on for over 5 years.

About 18 months ago, I wrote a post "When is Drupal 7 End-of-Life?" Unfortunately, no-one knew the answer. The deeper I looked, the more messy and confusing Drupal's plans became. The release cycles for Drupal 7, 8 and 9 were all vague and undefined.

Now in 2018, we finally have clarity.

Back in April, Drupal got a real product roadmap for the first time. Not bad for an 18 year old project!

There's also a clear roadmap for future Drupal versions:

  • Drupal 7 will be end-of-life when Drupal 9 releases in 2020, but there will be commercial support options for at least another year.
  • Drupal 8 will be end-of-life by November 2021.
  • Drupal 9 will be released in 2020, and it will be an easy upgrade.

Dries has a post called "Drupal 7, 8 and 9" which explains these timelines in detail. He includes this image which sums up Drupal's plans:

drupal 7 will be supported until november 2021

I've been criticial of Drupal's previously haphazard project management, but they're doing a superb job in 2018. There are real roadmaps, clear plans, and logical explanations. Kudos to the Drupal team.


About the author

Steve is the founder of OSTraining. Originally from the UK, he now lives in Sarasota in the USA. Steve's work straddles the line between teaching and web development.
Sep 17 2018
Sep 17

Last week, nearly 1,000 Drupalists gathered in Darmstadt, Germany for Drupal Europe. In good tradition, I presented my State of Drupal keynote. You can watch a recording of my keynote (starting at 4:38) or download a copy of my slides (37 MB).


[embedded content]

Drupal 8 continues to mature

I started my keynote by highlighting this month's Drupal 8.6.0 release. Drupal 8.6 marks the sixth consecutive Drupal 8 release that has been delivered on time. Compared to one year ago, we have 46 percent more stable Drupal 8 modules. We also have 10 percent more contributors are working on Drupal 8 Core in comparison to last year. All of these milestones indicate that the Drupal 8 is healthy and growing.

The number of stable modules for Drupal 8 is growing fast

Next, I gave an update on our strategic initiatives:

An overview of Drupal 8's strategic initaitives

Make Drupal better for content creators

A photo from Drupal Europe in Darmstadt© Paul Johnson

The expectations of content creators are changing. For Drupal to be successful, we have to continue to deliver on their needs by providing more powerful content management tools, in addition to delivering simplicity though drag-and-drop functionality, WYSIWYG, and more.

With the release of Drupal 8.6, we have added new functionality for content creators by making improvements to the Media, Workflow, Layout and Out-of-the-Box initiatives. I showed a demo video to demonstrate how all of these new features not only make content authoring easier, but more powerful:


[embedded content]

We also need to improve the content authoring experience through a modern administration user interface. We have been working on a new administration UI using React. I showed a video of our latest prototype:


[embedded content]

[embedded content]

Extended security coverage for Drupal 8 minor releases

I announced an update to Drupal 8's security policy. To date, site owners had one month after a new minor Drupal 8 release to upgrade their sites before losing their security updates. Going forward, Drupal 8 site owners have 6 months to upgrade between minor releases. This extra time should give site owners flexibility to plan, prepare and test minor security updates. For more information, check out my recent blog post.

Make Drupal better for evaluators

One of the most significant updates since DrupalCon Nashville is Drupal's improved evaluator experience. The time required to get a Drupal site up and running has decreased from more than 15 minutes to less than two minutes and from 20 clicks to 3. This is a big accomplishment. You can read more about it in my recent blog post.


[embedded content]

Promote Drupal

After launching Promote Drupal at DrupalCon Nashville, we hit the ground running with this initiative and successfully published a community press release for the release of Drupal 8.6, which was also translated into multiple languages. Much more is underway, including building a brand book, marketing collaboration space on Drupal.org, and a Drupal pitch deck.

The Drupal 9 roadmap and a plan to end-of-life Drupal 7 and Drupal 8

To keep Drupal modern, maintainable, and performant, we need to stay on secure, supported versions of Drupal 8's third-party dependencies. This means we need to end-of-life Drupal 8 with Symfony 3's end-of-life. As a result, I announced that:

  1. Drupal 8 will be end-of-life by November 2021.
  2. Drupal 9 will be released in 2020, and it will be an easy upgrade.

Historically, our policy has been to only support two major versions of Drupal; Drupal 7 would ordinarily reach end of life when Drupal 9 is released. Because a large number of sites might still be using Drupal 7 by 2020, we have decided to extend support of Drupal 7 until November 2021.

For those interested, I published a blog post that further explains this.

Adopt GitLab on Drupal.org

Finally, the Drupal Association is working to integrate GitLab with Drupal.org. GitLab will provide support for "merge requests", which means contributing to Drupal will feel more familiar to the broader audience of open source contributors who learned their skills in the post-patch era. Some of GitLab's tools, such as inline editing and web-based code review, will also lower the barrier to contribution, and should help us grow both the number of contributions and contributors on Drupal.org.

To see an exciting preview of Drupal.org's gitlab integration, watch the video below:

[embedded content]

Thank you

Our community has a lot to be proud of, and this progress is the result of thousands of people collaborating and working together. It's pretty amazing! The power of our community isn't just visible in minor releases or a number of stable modules. It was also felt at this very conference, as many volunteers gave their weekends and evenings to help organize Drupal Europe in the absence of a DrupalCon Europe organized by the Drupal Association. From code to community, the Drupal project is making an incredible impact. I look forward to continuing to celebrate our European community's work and friendships at future Drupal conferences.

A summary of our recent progress
Sep 17 2018
Sep 17

1 minute read Published: 17 Sep, 2018 Author: Herman van Rink (helmo)

In honor of DrupalEurope and all the earlier DrupalCon’s we’ve thrown together a quick Drupal 8 site that tracks all the songs covered in the DrupalCon prenote! sessions. Drupal songs logo

Thanks to all those who came to the stage to wake us up before the Driesnotes.

Come and sing along at DrupalSongs.org.

Sep 16 2018
Sep 16

Introduction

Today, we will take you on a journey through some important insights we achieved as builders of educational portals.

Portals in which Drupal plays a part and how we managed to create added value to educational portals we built over the years.

Of course we like to give some examples in how we succeeded, but it is just as interesting to look at some flaws that actually helped us to do it better the next time.

Educational portal?

But first, just what is an educational portal?

portal

With the word educational we actually say two things:

Educational in a sense that it involves around education.

Educational in a sense that the portal brings more knowledge or insight to the user.

Another word for a portal might be entrance. That said, an educational portal has a broad understanding. In this talk, we would like to focus at applications that have a clear internal focus for our university as a whole, our students, our teachers and staff. You can think of electronic learning platforms, digital learning (and working) environments and intranet systems for universities.

Recent years: digital workspace

digital workspace

As part of the digital transformation every university is going through, the term “digital workspace” is floating around in this context. A digital workspace brings together all the aforementioned subsystems into one intuitive, platform.

We’ll touch on that subject later on.

Role of Drupal

top universities

Secondly, how do educational portals / digital workspaces relate to Drupal?

Universities around the world have been using Drupal for some years now, even going back to version 4.x. Drupal is particularly popular because of:

  • High modularity

  • Flexible API for integrations

  • Identity and access management

  • Authentication with external providers, OAuth, SSO in place via contribs

  • Open source nature / General Public License

  • Very flexible but yet fine-grained management of roles & permissions

And that is exactly where we would like to start today.

Target Audiences

target

We could say that the typical challenge of education is the broad collection of target audiences.

When developing an educational portal it’s important to know your target audience, not only are you gonna deal with Teachers and Students and cater to their needs, but you’d also have to keep in mind that Parents may be visiting the site, as are Alumni, Heads of Faculties, potential sponsors, researchers, general staf, journalists and the general public.

And we are probably still not complete in our list.

personas

One way to tackle this is making use of Persona’s, a method of visualising your potential users.

With this method you create fictional characters that represent one of the user roles. (Afbeelding user roles)

With the persona’s defined you can make an educated guess of the type of user journey the users of the portal are gonna follow.

The next step is wire framing. An efficient way to achieve a shared view on “what we need” is to invite the target audiences to literally DRAW what they have in mind and bring all these views together in user experience sessions.

deadpool

After this, we can use these views in wire frames. This is quite essential in managing expectations. And there is a hidden advantage in this way of working: it can be a superb way of bringing together groups that are not necessarily ‘best friends’ or at least have opposite goals.

Prototyping the application and perform usertests with a select group of users which represent the roles defined earlier.

usertest

[dit nog aanvullen en bruggetje naar technische tip hieronder]

From a Drupal perspective we would like to share another important insight we achieved during development of portals. As we concluded that Drupal has a flexible basis for role and access management, we need to make sure it is still manageable. The actual handing out of permissions can of course be carried out in Drupal itself, but large organisations should prevent this multilayered approach. In easier words: we want to make sure all permissions are stored in one central location, like for instance Active Directory. In the end this will prevent flaws like abusing the system while no one notices it.

Politics in Education

Watch-Pakistani-Politicians-Fighting-On-Live-TV

Working with large educational institutes brings some special challenges in the form of different fractions in the organisation. There are not only the IT and business side of the organisation, but also lots of different faculties who all think they are the most important faculty of the university.

Getting all these different teams on the same page can be a daunting task and sometimes lead to extensive rework on your project.

Essential in preventing these issues is understanding what the goal of the various stakeholders is and realising that, sometimes, it just isn’t possible to please everybody and still have a great product, so you have to make compromises now and then.

There are however some factors which can either make your life a little better, the most important being a good product owner and a competent analyst to really get a feel of what is essential in your project.

Another crucial part of the process is to make proper wireframes, mockups and have a clear content strategy so all parties involved can get a good feel of the expected functionalities. Make sure everybody is on the same page as early in the process as possible!

Also having proper Persona’s and have people involved take a good survey can be a great help in preventing bickering and arguing.

Integrations

Organisations in Higher Education probably already have a multitude of systems and programs that need to be incorporated in some way in the portal. Examples of types of application you’d have to interface with are: HR applications, Scheduling programs, Learning Management systems, Publications repositories, mailing lists, external websites, Document Repositories, Course management software, and so on, the list seems endless.

singlepoint

Of course you could write an importer for the xml which comes from the HR application, a feed processor for the external websites’ RSS feed and a file fetcher and processor for the archaïc publication repository.

The universities we saw do not have 3 systems.

tools

Abetter way to handle all these streams of data would be to create a standalone piece of software to act as a middleman, a so called Enterprise Service Bus or ESB.

Garbage in, Garbage out!

trashgiphy

The ESB is built to adapt multiple intgrations and normalize the data, which is distributed in a uniform way to our portal and any other clients. With an enterprise service bus Drupal only has to take care of a standardized and centralized integration. This heavily reduces complexity in our portal.

Some of the advantages of using an ESB are:

  • decoupling the requesting party and the distributing party

  • Simplifying and standardising the interfaces between the two parties

  • Stimulating the re-use of data (as they are centrally available it promotes the re-use)

  • Centralised location of monitoring of services

  • Reducing time-to-market

  • Sanetising and validating

esb

While the ideal of an ESB is great, reality is unfortunately different and in some cases you will have to manage external connections to the portal within Drupal.

This simply means that there will probably exist some point-to-point integrations in your portal.

To handle this not so ideal situation, we should implement some control management inside Drupal.

To be more specific: standardize this within your Drupal application.

We need a referee

ezgif-1-11cbf96784

A Gatekeeper, or, as you wish, some kind of referee

This will require two essential things for each integration:

Some sort of gatekeeper functionality which will prevent to import garbage.
Proper logging system which will help keeping track of unwanted side effects of integrations with third party software.

Testing

QuarterTo9

Yes, it is a clock and it is a quarter to nine. True.

It actually represents the starting time of the students who were going to use the new portal first day at school after holiday break. We proudly launched the portal the week before. As teachers were already using it, we had a positive shared view on the use and especially the performance of the system. But, as the students day schedule now was part of the portal, and somehow we could have foreseen that, well, EVERYONE would check their day schedule at the latest moment possible, we ran into some big time performance problems.

This is a typical example of peak traffic. We hadn’t taken peak times into account.

As a development team we found out that we failed to address the cost of quality on this matter. It would have been better to have some proper stress testing in place.

So, we quickly fixed it by shoveling some extra power to our servers and immediately sitting down with IT people of our client.

plane

Although it is quite tempting. Running away will eventually bring more problems. We sat down with IT people and created the solution we wanted.

meeting

Different types of tests

  • Unit / Kernel / Browser & Javascript tests
    Tests which check if your code is working as supposed

  • Behavior tests (e.g. Behat)
    With behavioral test you run scenario’s / user stories

  • Visual Regression tests (e.g. BackstopJS)
    Visual regression tests check visually if anything changed on the page

  • Performance tests (e.g. JMeter)
    Test the performance of the application

Performance testing = Being prepared

Steps

Some general steps to running tests on your application.

  • Analyse existing data

    • Google Analytics / Logs

    • What are the top pages

    • What pages give errors

  • Prepare testscenario

    • Use the results of the analysis
  • Configure tooling

    • Pick your tool (Jmeter?)
  • Run the test

  • Analyse results

    • Profiling & monitoring

APDEX

apdex

APDEX is a standard for measuring user satisfaction based on pageload time.

Basically it works like this, you set a baseline that’s acceptable and one that’s frustrating for your application (which for an LMS might be a different baseline then for a webshop). Then when you run your test, firing of a gazzilion requests to your application, you get a set of results mapped to your baselines following a pretty simple formula:

apdexruntime

Unfortunately…

APDEX is not the holy grail

Nowadays there are a lot of onepage / javascript apps, you have bigpipe which skews results. Also the resulting APDEX score is an average, so shifting the numbers might give you the same score, while the frustrated results can be higher.

So you should always use monitoring, alerts and, if available analytics to be sure that during expected peak times the system is working as expected.

A nice thing to mention here is the current trend of containerisation of environments, making use of systems like Docker, Kubernetes and OpenShift. A hugely effective feature is autoscaling of the environment without facing downtime. For the first day, when facing problems of performance nature, it can take away the harshness of coping with organisational agitation and disgrace. Moreover, it gives you time to fix things the right way.

Technical Choices / architecture

cloud 1

So we were talking about the ESB. What would happen if we considered Drupal as actually being one of the distributing systems, a client to the ESB? We would simply consider Drupal as a content management system, out there to serve content to whatever external system we want.

This is typically the case when operating in an omnichannel communication strategy.

cloud 1

A user experience is partly determined by the online ‘obstacles’ that a user encounters. Removing frictions within the customer journeys of users makes the experience positive. We also believe that omnichannel communication is becoming increasingly important in the online world. In concrete terms, this means that the publication and distribution of content and information via a website is no longer sufficient. Channels such as (native and mobile) apps and other websites are becoming more and more part of the communication strategy. It is crucial that a CMS has the right interfaces and tools to make this possible. The CMS as a publishing machine, which provides direct communication to all channels and chain partners in combination with a front-end interface for the distribution of function, form and content, will form the basis.

Go away, obstacle!

The news here is: Drupal is not necessarily the portal itself.

In fact, we are aiming to serve a unified experience for our users across all channels.

multichannel---didital-workspace_11

A definition:

“The digital workspace is a new concept that enables tech-savvy employees to access the systems and tools they need from any device—smartphone, tablet, laptop, or desktop—regardless of location. ”

Forbes

And that, in our opinion, is a very unpretentious definition. One could image that, for instance, when you work together in a group for a school project, that all these subsystems “know” you and also “know” you are part of that group. When asking questions to tutors that apply to the group, you would expect the whole group.

Sep 16 2018
Sep 16

Privileged to be given the opportunity by organisers at Drupal Europe to share Peace Through Prosperity‘s journey with the Drupal community. Thank you!

This was the third rendition of this talk since 2015, and in this time our charity, our work, progress of our beneficiaries and our learnings from it have come a long way.

What started as a one way street for transfer of frameworks, tools and strategies from digital transformation to effect societal transformation has gone full circle over past couple of years. Eight years into the journey and am now cross-pollinating approaches and ideas from societal transformation back into my work as a digital transformation coach and consultant.

Suppose it was a matter of time when I started seeing patterns from marginalised individuals and communities back into the work place with disengaged teams and individuals! But that’s for another post!

As mentioned in my session there are two call to actions to further Peace Through Prosperity’s journey to continue and scale our work…

  1. We are looking to partner with organisations on their Corporate Social Responsibility(CSR) programs – kindly reach out to your organisation’s CSR people and suggest sponsoring Peace Through Prosperity just as DropSolid currently do! We are looking to raise €30k with which we’d be able to engage with 800 micro-entrepreneurs in a 12 month period!
  2. Steal our stuff – connect us with your friends, customers and acquaintances in the charity sector, we would like for them to steal our open source products and programs, incorporate them in their existing work and we will support them in the task! it’s free!

My session at Drupal Europe coincided with Peace Through Prosperity running a mini-MBA for our third all female cohort in Lyari, Karachi! here’s 35+ micro-entrepreneurs from a marginalised community in Karachi stepping out of their comfort zone and graduating from the program! Well done ladies!

Interested to learn more? would you like to get involved? Cool! get in touch, you know how to find me!

And lastly I’d like to add a special mention for Druid from Finland! these folks brought along SWAG for kids! their T-shirts are an absolute hit with mine! #Thankyou

#DrupalEurope #Agile #Transformation #Society #Entrepreneurs #InternationalDevelopment

Sep 16 2018
Sep 16

Joris Snoek - Business Dev

+31 (0)20 - 261 14 99

'There's a module for that', this applies to many use cases with Drupal. What is not possible with modules we develop tailor-made instead. But because customization is costly, it is good to keep abreast of the available modules. I try to keep track of this every month; although that does not always work, at least here is what struck me about module updates in the last month:

1. Security Kit

Has been quite some time in development and quite popular, but recently received an update. Always good to mention once again, within this Drupal module a number of measures are taken against common safety issues:

  • Cross site Scripting
  • Cross-site Request Forgery
  • Clickjacking

https://www.drupal.org/project/seckit

2. Twig tweak

Provides a number of handy Twig extensions, which makes the life of a Drupal developer / themer easier. See also this cheat sheet for the concrete possibilities.

https://www.drupal.org/project/twig_tweak

3. Field Block

For me a blast from the past, we used this module a lot in Drupal 7 installations. It offers a light weight way to position the output of your fields via blocks on a page. Blocks with relevant fields can then be placed lean via the Context module for example.

If you compare this with positioning via for example, Panels, Display Suit or Views it is very lean and mean.

However, a caveat: this approach is meant for developers, if you want to build non-technical content manager pages this is a less suitable method.

It is also possible to position fields with the Layout Builder, nowadays in the Drupal core. See this video.

https://www.drupal.org/project/fieldblock

4. Track da files

The Drupal 8 core has a good file management system, for both public and private files. But there are no statistics / reports in, this module provides for this to include the following features:

  • One list with all files
  • Number of downloads per file
  • IP address statistics
  • Export data to CSV

https://www.drupal.org/project/track_da_files

5. Heading

When you work with Paragraphs, you will understand the usefulness of this Drupal module: you simply need a simple header field which you can position between paragraphs or other sections in your page: plain text and choose h1-h6.

https://www.drupal.org/project/heading

6. File hash

An addition to the standard Drupal file system, with which all uploaded files are uniquely characterized by a hash. With this you can, for example, detect duplicate files and verify copies against original files.

A unique hash per file is stored in MD5, SHA-1 and/or SHA-256 format.

https://www.drupal.org/project/filehash

7. Smart IP

This Drupal module collects all kinds of visitor information based on the IP of the user, such as:

  • Place of residence
  • Country
  • Time zone
  • Postal code (approximate)
  • Degrees of latitude and longitude (approximate)

Please note the necessary reports regarding AVG / GDPR.

https://www.drupal.org/project/smart_ip

8. Freelinking

A 'looser' way for content managers to create links. By default you have to enter a 'hard' link to a page, but after installing this Drupal module you can also use the page title, in which case you enter: [[nodetitle:Title of the Page]].

This module automatically creates a working link.

https://www.drupal.org/project/freelinking

9. Facets

Building a relatively easy "faceted search" in Drupal 8: filtering as you may know from Marktplaats.nl. This module works with the Drupal core search or the commonly used Search API module.

https://www.drupal.org/project/facets

10. Show email

A micro module that can show the e-mail address on a user profile page.

https://www.drupal.org/project/show_email

11. Iframe

Generates an extra field, which you can use to load an external website via an iframe. You can set height and width, optionally set a title and attributes for frameborder and scroll styling.

https://www.drupal.org/project/iframe

12. Views Bulk Edit

Change bulk values of fields in nodes or other entities. This module uses the popular Views Bulk Operations module.

https://www.drupal.org/project/views_bulk_edit

13. Menu Item Extras

Do you want to add extra fields to menu items? Install this module. You can see it as 'Fieldable menus', allowing you to store and display all kinds of additional information in a menu item.

https://www.drupal.org/project/menu_item_extras

14. Redirect after login

A mini module, with which you can set which page someone ends up on after logging in.

https://www.drupal.org/project/redirect_after_login

15. Lockr

When you work with encrypted data (eg user data), Drupal always needs a key to decrypt it, otherwise you can not use that data in the Drupal platform. If this key is on the same server, a hacker would potentially still have all the data at hand. If this key is on a different server, it will be a lot more difficult. This module provides for the latter.

https://www.drupal.org/project/lockr

16. Automatic IP ban (Autoban)

Drupal security module which analyzes visitor behavior: when suspicious actions are detected, the relevant IP address is added to a black list.

There are various settings possible, so you can adjust how strict the module operates.

https://www.drupal.org/project/autoban

17. Bootstrap menu items

A fan of the Bootstrap HTML framework in your Drupal site? Then this module may be useful: make easy drop-down menu items and separators between menu items.

https://www.drupal.org/project/bootstrap_menu_items

18. Chosen

Makes the selection of items (eg Drupal taxonomy terms) a lot easier for content managers in your Drupal system.

/Drupal-chosen.png

https://www.drupal.org/project/chosen

19. Paragraphs jQuery UI Accordion

Do you use Paragraphs and want to show an accordion? You guessed it: this module can help a long way in the right direction.

https://www.drupal.org/project/paragraphs_jquery_ui_accordion

Wrap up

Ok, that's it for this month. Expect a new version next month!

Sep 15 2018
Sep 15

Who Are We?

The Drupal Community Working Group (CWG) is responsible for promoting and upholding the Drupal Code of Conduct and maintaining a friendly and welcoming community for the Drupal project.

The CWG is an independent group chartered directly by Dries Buytaert in his capacity as project lead. The original members of the CWG were appointed by Dries in March of 2013. Since then, new CWG members have been selected by the group from the Drupal community, and then approved by Dries. The CWG is made up entirely of community volunteers, and does not currently have any funding, staff, legal representation, or outside resources.

The CWG’s current active membership is:

  • George DeMet (United States): Joined CWG in March 2013, chair since March, 2016.
  • Michael Anello (United States): Joined CWG in December 2015.
  • Jordana Fung (Suriname): Joined CWG in May 2017.

Rachel Lawson (United Kingdom) was a member of the CWG from May through December 2017, when she started a new position as the Drupal Association’s Community Liaison.

Emma Karayiannis (United Kingdom) and Adam Hill (United Kingdom) have informed the CWG of their intention to formally step down from the CWG once replacements can be found for them; we are currently engaged in a search process to identify new members to fill their positions.

The CWG is also building a network of volunteer subject matter experts who we can reach out to for advice in situations that require specific expertise; e.g., cultural, legal, or mental health issues.

What Do We Do?

The CWG is tasked with maintaining a friendly and welcoming contributor community for the Drupal project. In addition to maintaining and upholding the Drupal Code of Conduct and working with other responsible entities within the Drupal ecosystem to ensure its enforcement, the CWG also helps community members resolve conflicts through an established process, acting as a point of escalation, mediation, and/or final arbitration for the Drupal community in case of intractable conflicts. We also provide resources, consultation and advice to community members upon request.

Other activities the CWG has engaged in in the past year include:

  • Sharing experiences and best practices with representatives from other open source projects, both in a one-on-one setting and at various open source community events.
  • Recognizing community leadership through the Aaron Winborn Award, which is presented annually to an individual who demonstrates personal integrity, kindness, and above-and-beyond commitment to the Drupal community.
  • Helping to ensure the community’s voice is represented in the governance process. While the CWG’s charter does not allow it to make community-wide governance decisions, the CWG did work with other interested members of the community to help organize and facilitate a series of community governance meetings in the fall of 2017 following the results of a survey conducted by the Drupal Association. Results and takeaways from these meetings were also shared with the community-at-large.
  • Organizing a Teamwork and Leadership Workshop at DrupalCon Nashville to explore teamwork, leadership, and followership in the context of the Drupal community. Our goal was to expand the base of people who can step into leadership positions in the Drupal community, and to help those who may already be in those positions be more effective. Takeaways from this event were also shared with the community-at-large.
  • With input from the community, drafting and adopting a Code of Ethics for CWG members that clearly defines expectations for members around subjects such as confidentiality and conflicts of interest.

Incident Reports

The CWG receives incident reports from Drupal community members via its incident report form or via email.

  • In 2017, the CWG received 43 official incident reports submitted.
  • From January 1 through September 14, 2018, the CWG has received 33 official incident reports.

In addition, we regularly receive informal reports from community members, which are not included in the totals above. With informal reports, we often encourage the community member to file an official report as well to establish a written record of the incident and to ensure that they have as much agency as possible over how the issue is addressed.

The types of issues that the CWG has received in the last year include:

  • Community members being disrespectful and rude in issue queues.
  • Technical disagreements and frustrations that turn into personal attacks.
  • Abusive language and harassment in Drupal Slack and IRC.
  • Appeals of bans made by Drupal Slack moderators.
  • Inappropriate language and content at community events.
  • Harassment and trolling of community members on social media .
  • Physical harassment of community members (both in and outside of community spaces).
  • Ongoing issues involving specific community members with established patterns of behavior that are disruptive to others.
  • Drupal trademark questions and issues (these are referred to Dries Buytaert, who is responsible for enforcing the Drupal trademark and logo policy).

The CWG also chose not to act on several reports it felt were being made in bad faith and/or in an attempt to harass or intimidate other community members. As per its charter, the CWG also does not respond to requests to take specific punitive action against members of the community. Our goal is to help people understand and take responsibility for the impact that their words and actions have on others.

The CWG relies primarily on its established conflict resolution process to address incident reports. Depending on the situation, this may involve one or more CWG members providing mediation between the parties in conflict or suggesting ways that they can resolve the issue themselves. For matters that may take an unusually long time to resolve, we provide all involved parties with regular status reports so they know that their issue is still being worked on.

In cases of a clear Code of Conduct violation, the CWG will take immediate steps as necessary to ensure the safety of others in the community up to and including recommending permanent or temporary bans from various Drupal community spaces, such as Slack, IRC, Drupal.org, or DrupalCon and other Drupal events.

Other outcomes may include:

  • Discussion of the issue with involved parties to try to find a mutually acceptable and beneficial outcome.
  • Asking one or more of the involved parties to apologize and/or take other actions to address the consequences of their behavior.
  • Discussion of the issue with the involved parties, after which someone may choose to leave the community voluntarily.
  • Asking someone to leave the community if they are not willing or able to address the consequences of their behavior.
  • Recommending bans from various community spaces, including virtual spaces

In some cases, we may receive an after-the-fact report about a situation that has already been resolved, or where the person making the report has asked for no action to be taken. In those cases, we review the incident, decide whether further action is necessary, and keep it on file for reference in case something similar happens in the future.

While the CWG has in the past directly acted as code of conduct enforcement contacts for DrupalCon (which is run by the Drupal Association and has its own code of conduct distinct from that of the community), as of November 2017 those duties have been assumed by DrupalCon staff. The CWG and DrupalCon staff continue to coordinate with each other to ensure that reports are handled by the appropriate responsible body.

Sharing With the Community

The CWG publishes anonymized versions of its weekly minutes that are shared with the community via our public Google Drive folder. These minutes are also promoted via the CWG’s Twitter account @drupalcommunity.

In addition to the public minutes, the CWG also occasionally issues public statements regarding issues of importance to the broader community and beyond:

The CWG also maintains a public issue queue on Drupal.org. Following a series of community discussions in the spring of 2017, the CWG filed a series of issues in this queue to clarify points of confusion and address outstanding concerns about its role in the community.

The CWG also presents sessions at DrupalCon, as well as other camps and events. Sessions presented at DrupalCon in the last year include:

In addition, CWG members have also organized, spoken, and/or participated in Q&A sessions about the CWG at the following events:

  • MidCamp (Chicago, IL)
  • DrupalCamp Asheville (Asheville, NC)
  • Twin Cities DrupalCamp (Minneapolis, MN)
  • DrupalCamp Colorado (Denver, CO)
  • FOSS Backstage (Munich, Germany)
  • Community Leadership Summit (Portland, OR)
  • Edinburgh Drupal User Group (Edinburgh, Scotland)
  • Open Source North East (Newcastle upon Tyne, England)
  • All Things Open (Raleigh, NC) - Upcoming

The CWG is also exploring ways it can make itself available more often to the community via real-time virtual channels such as Slack, Google Meet, or Zoom.

New Challenges

Online Harassment

The number of incidents that the CWG handles relating to online harassment, particularly on social media, has increased significantly in the last couple of years. Because this harassment is often perpetrated by individuals or groups of people posting from behind anonymous accounts, it is sometimes difficult for the CWG to positively identify those responsible and hold them accountable for their actions. This is compounded by the apparent lack of interest from leading social media companies in taking action against abusive accounts or addressing harassment that occurs on their platforms in any effective or meaningful way.

The Drupal community’s switch from IRC to Slack for much of its real-time communication has also provided another vector for harassment, particularly targeting people who participate in communities of interest that focus on topics such as diversity, inclusion, and women in Drupal. While it is possible to ban individual Slack accounts, it is fairly easy for perpetrators to create new ones, and because they are not always tied to Drupal.org IDs, it is sometimes difficult to identify who is responsible for them.

Sexual Harassment and Abuse

Following reports last year relating to sexual harassment in the Drupal community, the CWG understands that there are likely additional incidents that have occurred in the past that have gone unaddressed because we are unaware of them. While our code of conduct is clear that we do not tolerate abuse or harassment in our community, we also know that people don’t always feel safe reporting incidents or discussing their concerns openly. As a consequence, nothing is done about them, which undermines the effectiveness of our code of conduct and in turn leads to fewer reports and more incidents that go unaddressed.

It is our opinion as a group that open source communities across the board need better mechanisms and procedures for handling reports of sexual abuse, harassment, and/or assault. We also need to keep better records of incidents that have occurred, so that we can more quickly identify patterns of conduct and abuse, and better ways to recognize and address incidents across projects so that people who have engaged in harassment and abuse in one community aren’t able to repeat that behavior in another community.

Staffing and Resources

We need to ensure that the CWG is adequately staffed to assist with the increasing number of incident reports we receive each year. While several members have pursued relevant professional development and training opportunities at their own expense, the CWG currently has no direct access to funds or resources to pursue them as a group. As a volunteer community group chartered by the project lead, the CWG also currently operates without the benefit of legal protection or insurance coverage.

Initiatives for 2018/2019

Governance Changes

While the CWG is not allowed to make changes to its own charter, in early 2017 we explored a number of potential changes that we had intended to propose to Dries to help make our group more effective and better positioned to proactively address the needs of the Drupal community.

That work was put on hold following a series of community discussions that occurred in the spring of 2017.  Those conversations surfaced questions, suggestions, and concerns about the accountability, escalation points, and overall role of the CWG, many of which we documented and addressed in our public issue queue. While we were able to address many of the issues that were raised, some can only be addressed with changes to the CWG’s charter.

We fully support and appreciate the ongoing work of the Governance Task Force to update and reform Drupal community governance. While we understand that additional changes may occur pending the outcome of the overall governance reform process, we also feel that there are some changes related to the CWG that need to be made as soon as possible. These proposed changes are currently under review both internally as well as with Dries and other involved stakeholders, and will be shared with the community for review and comment prior to adoption.

Updating the Community’s Code of Conduct

The current Drupal community code of conduct was published in 2010 and is based on the Ubuntu code of conduct.  As per its charter, the CWG is responsible for “maintain[ing] the Conflict Resolution Process (CRP) and related documentation, including the Drupal Code of Conduct”. The CWG has made several changes to the code of conduct over the years, the most significant of which was the addition of the conflict resolution policy in 2014, much of which was inspired by work done within the Django community.

While Drupal was one of the first open source projects to adopt a code of conduct, many others have done so since, and there are a variety of models and best practices for open source community codes of conduct. Based on feedback that we have received over the past year, the CWG is working on an initiative to review and update Drupal’s community code of conduct with input and involvement from both the community-at-large as well as outside experts with code of conduct experience from other projects. Our goal is to introduce this initiative before the end of 2018.

Dealing with Banned Individuals

Some local event organizers have asked the CWG for better tools to ensure that they weren’t inadvertently providing a platform to people who have been banned from speaking at or attending other events due to code of conduct violations.  While the number of people who have been banned from attending DrupalCon and other Drupal events is very small, a comprehensive list of the identities of those individuals is currently known only to the CWG and the Drupal Association.

While the CWG does not generally publish the names of individuals who have been asked not to attend Drupal events, we do reserve the right to publish their names and the reasons for their ban if they do not abide by it.  While we believe that this is effective at deterring individuals from attending events they have been banned from, we also understand that it does not always provide other attendees and/or conference organizers with the tools they need to ensure a safe environment at their events.

Members of the CWG have discussed this issue with their counterparts in other communities, and it does not appear that there are consistently established best practices for handling these kinds of situations, particularly in communities as decentralized as Drupal. With the input of the community, we would like to establish clear and consistent guidelines for local event organizers.  

Community Workshops and Training

In 2016, the CWG conducted a survey and interviews of Drupal core contributors to identify sources of frustration during the Drupal 8 development cycle. One of our recommendations was for the project to focus more on developing skills like creative problem solving, conflict resolution, effective advocacy, and visioning in order to broaden understanding of Drupal’s community, its assets and its challenges.

Following the success of the teamwork and leadership workshop that the CWG led in collaboration with the Drupal Association at DrupalCon Nashville in 2018, the CWG is exploring opportunities for additional workshops and training at DrupalCon Seattle and other events.

Summary

Over the past few years, the Drupal project and community has grown rapidly, bringing a series of new and evolving challenges. Not only has the project grown progressively more complex with each major release, but the time between releases has increased and more is being asked of the developer community by customers and end-users.

We believe this is a significant contributing factor in the increase in the number of documented incidents of negative conflict, which left unaddressed may result in a decline in contributor productivity and morale. The work of the Community Working Group seeks not only to mitigate the impact of negative conflict, but also to provide the community with the tools and resources it needs to make the Drupal project a safer, more welcoming, and inclusive place.

Sep 15 2018
Sep 15

“You don’t get to control everything that happens to you, but how you *respond* is a matter of choice.”

That response is based on our values. Call it a belief your parents or society pushed you to pursue or something that you learned with life. Our values condition our responses. 

But how different are the values that we follow in our personal life from the values that build organizations or for that matter a community?

When it comes to the craft of building Drupal and the community we, as a part, need to recognize the art of building software and website, first. 

We share some common values both at OpenSense Labs and at Drupal Community. Let’s talk about these core values and practices that support us. 

“The Drupal Values and Principles describe the culture and behaviors expected of members of the Drupal community to uphold.”

The Road to Software Needs to be Strong

In order to build and later maintain a community, it is important that the core values are strong. When building a website or a software it is important we have certain written or unwritten codes of values that we abide by. 

Ensuring the community has the best of what is being offered is done by building a product that doesn’t exclude anyone. This ensures that the features we add are accessible by everyone. 

A clear communication in the community is also important to ensure that the people using that software understand the process of it.  

Impacting the digital landscape that the Drupal community has, we cannot afford to be careless.

Evan Bottcher, ThoughtWorks, explains some core values and practices to build a software. The diagram below is a part of it.  

a pink circle divided into many parts

Each of the eight core practices (in the outer circle) support one or more of those core values. These practices are the actions as an organization and community we need to perform, and it depends a lot on the methods or approaches that we apply. 

Core Values To Build a Software:

  1. Ensuring Quality with Fast Feedback: Quality is not the sole responsibility of the QA. Follow whatever method, if the person building the software doesn’t take the responsibility for the product, nothing will work. 

    It is important that as a software agency we value being able to find out whether a change has been successful in moments not days. The lesser the time we take, the better it is. 
     

  2. Repeatability: Confidence and predictability comes from eliminating the tasks that introduce weird inconsistencies. We also want to spend time on activities that are more important than troubleshooting something that should have just worked.
     
  3. Simple and Elegant: Softwares that contain complexity than what is needed are of no use. Sounds rude? Well, it is the truth. 

    What use will it be if people outside the organization can not work on it? 

    This also brings with it the idea to future-proof the content. While we build for what we need now, and not what we think might be coming there should be enough scope to meet the future requirements. 
     

  4. Clean Code: Talking of making the software future proof means people outside the immediate team can work on it. This requires the code to be clean, which allows the third developer to make relevant changes. 

Values That Build Drupal and Organizations

  • Making Impact

With a community as large as Drupal’ the circumference to affect the number of people increases. But this just doesn’t restrict to people who are working on the core, issues, credits, or documentation. This includes those as well who interact with a Drupal-powered website. 

This is where the idea to impact the lives of people makes more sense. The Article 26 Backpack for Syrian refugees a platform to helps Syrian Refugees secure and share their educational credentials. 

Similarly, as part of our Corporate Social Responsibility, we are open to helping Non profits from a web development and digital strategy perspective. If you are or know a non-profit looking to get a website overhaul or planning digital transformation, please get in touch at [email protected]

We derive meaning from our contributions when our work creates more value for others than it does for us.

  • United We Stand, Divided We Fall

The community ensures the environment remains as transparent as possible, with decisions being collaborative and not authoritative. The community elections are important and equally transparent where everyone can contribute. 

Asking questions or sharing ideas can be difficult, especially if the questions or ideas are not fully formed or if the individual is new to the community. Drupal groups and forums are the places where people can openly ask questions and put their thoughts among the community members. 

At OpenSense Labs, we are also committed to maintaining a transparent environment which includes not only discussing organizational goals but individual goals as well. This enables every member to participate, learn, and grow. Creating an environment where individual goals are taken care of ensures that the team grows. Not only in numbers but with their output as well. 

We also value the behavior of feedback. The product, after all, belongs to all and not just to a few. This brings in the sense of ownership which helps grow us manifold. We learned this from the Drupal community. Each feature people work relentlessly to improve the state of Drupal. 

Teamwork can empower every contributor. Throughout the history of the Drupal community, many individual contributors have made a significant impact on the project. Helping one person get involved could be game-changing for the Drupal project.

  • Give Respect and Get Respect

Every person is important. For the organization and the community. Just as the community our team is equally diverse. This requires building an environment that supports diversity, equity, and inclusion. Not because it is the right thing to do but because it is essential to the health and success of the project. 

Prioritizing accessibility and internationalization is an important part of this commitment.

  • Work Hard, Party Harder

Working is good, but be sure to have fun. It is important to feel empowered and help others but it is equally important to enjoy and share the company of those you work most of the time with. 

We believe in the concept of work hard and party harder. 


Our values and principles need to be robust as well as flexible to ensure we don’t end up being too rigid. This, of course, involves discussing them regularly with the team and community. 

Check out Drupal Values and Principles

Sep 14 2018
Sep 14

Illustration showing multiple components of an SEO strategy 

Drupal has a bunch of great SEO tools. Here are several tips and suggested modules for fine tuning SEO within Drupal. Easy SEO wins can be achieved through configuring metatags and URLs. Don’t forget to setup an XML sitemap of your site and submit to major search engines. SEO isn’t a once and done effort, make sure to constantly research and update with search trends.

Yes, but is it good for SEO? This is a question we hear all the time when we mention all of the wonderful capabilities of a Drupal site. First off, let's dispel the myth that there is a CMS that automatically does magical SEO and makes all of your pages rank higher in search. If you want good SEO, the most important thing that you can do is write good and unique content that humans actually want to read. The CMS or web software has nothing to do with it. So let's assume that you already have great content and semantically perfect markup, there are tons of other little things that you can do to further boost your content in the eyes of search engines and Drupal is a great tool for implementing them.

To get the most out of Drupal SEO, you are going to want to download a couple of contributed modules from drupal.org.

The following is a list of our goto modules for SEO that I am going to talk about in this post:

Using Metatags to Help Search Engines

Metatags are important for search engines to index, categorize, and understand the content of your webpage. There are a lot of different metatags but a couple that really matter for SEO are the meta description and the title tags. Meta descriptions can be used as a summary in search engines, so it is important to write some compelling content here. It’s the first pitch to a potential site visitor so you may want to put a little thought into it. What if you have hundreds or thousands of pages on your site? The Drupal contributed Metatag module provides a way to dynamically set metatags based on content type, or on other content rules you may have. Working with the Token module you can have all of your metatags, including the description, generated based off of your content. For those pages that you are really trying to squeeze the SEO juice out of, Metatag allows you to override for when you need to fine tune things.

Which CMS is best for your website?  Take our CMS Quiz and find out!

If you want to take things further with metadata, you can also install the Schema.org Metatag module which extends the base Metatag module. You can read more about the Schema.org project here. In a nutshell Schema.org is making a push for people to further define what kind of content they are writing by breaking things into categories of content that a search bot can read. The types of content that they have defined is very granular with deep sub categories. Check them all out here. Having Schema.org metadata, can give you a leg up on your competition as more devices and services start reading and prioritizing web sites based on this content categorization data.

URLs Should be Informative and Human Readable

Having URL paths that make sense can go a long way for SEO. Search engines are able to parse relevance from the words in a URL. For example a URL that is “example.com/node/34” gives no information as to what the topic of the page is. Alternatively, this URL “example.com/store/shirts/blue-shirt” can tell a lot more to a search bot. The Pathauto module enables you to make descriptive URLs. Similar to the Metatag module, you can use this with the Token module to automatically build new URLs based on the type of content you are creating. These are referred to as “patterns” in the Pathauto module. Paths generated by Pathauto can also be changed on a one by one basis, so you can overwrite the generated name in favor of a custom one.

Another useful module related to URLs is the Redirect module. The redirect module does a handful of useful things. Every time you go and change a URL, the redirect module will create a 301 redirect from the previous URL to the new URL. This is helpful when you are updating a page that may have been bookmarked or linked to elsewhere. 301 is the status code that a web server sends when a requested page has been moved and tells the browser to redirect to the new page. 301 redirects are essential to having good SEO, search bots give a poor evaluation to sites with a bunch URLs that go nowhere and humans don’t really like it either.

The Redirect module also comes with a really handy utility page called Fix 404 pages. 404 is the status code that a web server sends when a requested page doesn’t exist. We have all seen these annoying messages from time to time. Sometimes the page has been deleted and sometimes it has simply been renamed and moved, with a 404 message there is no way to know where the page you are looking for is and will leave you thinking that maybe you just visited the page in a dream. The Fix 404 pages utility gives you a report of all of the 404 URLs that your site is sending, it also tells you how many times a URL has been tried and the last time someone tried to go there. This report gives you the opportunity to add a redirect for those 404 URLs and send those users to a relevant page. This is a big boost for SEO because 301 > 404 in the eyes of a search bot.

Provide a Sitemap to Better Direct Search Bots

Search bots work hard, 24/7 365 days a year they are out there crawling the web to make your search experience better. So make it easy on them and provide a roadmap for traversing your site. This is done with an XML sitemap. An XML sitemap is simply an outline of your site’s pages with priority and update frequency all wrapped up in the XML format. We typically build a custom solution for generating an XML sitemap, but there is a Drupal contributed module out there to help you do it without needing to know how to write XML. The XML Sitemap module allows you to configure your sitemap based on things like content types or menu structure. Once you have a sitemap, go ahead and give those search bots a jump start and submit it to the search engines. Each search engine has a different process for doing this, so make sure you submit to more engines than just Google, the XML Sitemap module has a built in tool for submitting to search engines as well.

Research and testing

Lastly, let's talk about Google Analytics and so I don’t have to write that out a bunch of times i'm going to refer to Google Analytics as GA. GA won’t do anything to help your SEO, but it is a crucial tool for analyzing how effective your SEO work has been. The Drupal contributed Google Analytics module makes it easy to set up on your Drupal site. A good SEO strategy is all about testing and adjusting. Make some assumptions about what topics or keywords you think will drive traffic to your site but don’t stop there. Turn your assumptions into tested data with GA. Your website should be a testing ground for new search words, as you see traffic spike up around a search term adjust the rest of your content to cater to those search terms. GA is currently the best tool available for tracking visitors on your site. With testing and study eventually you will land on the right terms and words to use so that the right people find their way to your amazing content.

 image with text offering access to our free CMS Selection quiz.

Sep 14 2018
Sep 14

Vijay tells us about the fourth day's highlights in Darmstadt, Germany.

Keynote

The 4th day of Drupal Europe began with a discussion by a panel made up of Dries Buytaert, Barb Palser, Heather Burns, Hurley Mautic, and Timothy Lehnen, about the future of the open web and open source. Some interesting points were made, especially how we have the responsibility of making open source better, and how we can better protect the four software freedoms principles.

First session

Decoupled Drupal: Implications, risks and changes from a business perspective

Next up was our very own Michael, who gave a presentation on Decoupled Drupal. Some interesting points were made in this presentation. As a developer I love the fact we can experiment with technology, however, I never really gave a second thought about how this can have an impact, both for the company and potential clients. Decoupling for sure has success and failures that we all are going to experience. For example, time to train the team to be up to date with the latest technology and with this come cost. In the end, however, it is an investment. One clear message from this presentation that I took was we should expect failure, and we should not get discouraged by it, but rather learn from it. We should also celebrate the success.

JavaScript Modernisation Initiative

The third presentation I went to was the JavaScript Modernisation Initiative, presented by Lauri Eskola, Matthew Grill, Cristina Chumillas, Daniel Wehner, and Sally Young. As a contributor to this initiative, it was great to hear how this idea came about as this was something I didn't really know. I came to learn that it all began at DrupalCon Vienna, where the idea of how to create a decoupled backend, with a redesigned, and modern administration experience in Drupal came up. As of now, the product is clearly in the prototype stage, with plans to remove the current implementation of Material UI and update using the design created by Christina, which is in the early stages of concept. If you would like to get involved in this initiative, you can find out more on the Drupal website.

Improving the Editor Experience: Paragraphs FTW

After lunch, it was time for Stew to give his second presentation of the week, this time on his own. His presentation was all about paragraphs, a beginners overview of using paragraphs to make the editors experience more fun. Stew went on to explain how to give more control over content layout, and the pros and cons of some of the contrib modules that support paragraphs. Even though this presentation was about Paragraphs, Stew did mention that there were other alternatives to this great module. Way to go Stew, two presentations in one week.

Stew's session

Decoupling Drupal with GraphQL & Twig

The final presentation I attended was by Philipp. He explained what GraphQL is and what it is not, and how much more it can do, such as Search API indexing, and feed Twig templates. One exciting part of this session was the reuse of fragments, meaning you can write one query and reuse it across many templates. It is clear to see why GraphQL is very popular, however, one interesting point that was brought up was that it isn't the same as injecting SQL into Twig. Phillip responded by saying a GraphQL query is not something that is executed, it is a definition of requirements, which you request from the implemented backend. Phillip also thanked Sebastian Siemssen, who happens to be both a core maintainer of the GraphQL module and an ex amazee.

Phillipp's session

Closing

After the conference, we headed back to the hostel to refresh and then headed out to eat for our final night in Darmstadt. After that we headed back to the venue for trivia night, this was my first time at trivia night, and it was full of fun, great people, atmosphere, food and drink, and great questions. After six rounds of questions, lots of laughter, and a small hiccup with their Google doc, the scores were tallied, and team 16 had won first prize, of which included Stew and Mostfa.

Winners

You could also say that Day 4 was pretty “Amazee-ing” with lots happening with our team. Congratulations to all from everyone at Amazee, both at the conference and those left behind.

I would also personally like to thank the Drupal Association for giving me a diversity ticket without which I would not have been able to attend this great conference and have a week of both excellent presentations and being able to continue to contribute to great initiatives.

Sep 14 2018
Sep 14

This blog has been re-posted and edited with permission from Dries Buytaert's blog. Please leave your comments on the original post.

Seven months ago, Matthew Grasmick published an article describing how hard it is to install Drupal. His article included the following measurements for creating a new application on his local machine, across four different PHP frameworks:

Platform Clicks Time Drupal 20+ 15:00+ Symfony 3 1:55 WordPress 7 7:51 Laravel 3 17:28

The results from Matthew's blog were clear: Drupal is too hard to install. It required more than 15 minutes and 20 clicks to create a simple site.

Seeing these results prompted me to launch a number of initiatives to improve the evaluator experience at DrupalCon Nashville. Here is the slide from my DrupalCon Nashville presentation:

Improve technical evaluator experience

A lot has happened between then and now:

  • We improved the download page to improve the discovery experience on drupal.org
  • We added an Evaluator Guide to Drupal.org
  • We added a quick-start command to Drupal 8.6
  • We added the Umami demo profile to Drupal 8.6
  • We started working on a more modern administration experience (in progress)

You can see the result of that work in this video:

Thanks to this progress, here is the updated table:

Platform Clicks Time Drupal 3 1:27 Symfony 3 1:55 WordPress 7 7:51 Laravel 3 17:28

Drupal now requires the least time and is tied for least clicks! You can now install Drupal in less than two minutes. Moreover, the Drupal site that gets created isn't an "empty canvas" anymore; it's a beautifully designed and fully functional application with demo content.

Copy-paste the following commands in a terminal window if you want to try it yourself:

mkdir drupal && cd drupal && curl -sSL https://www.drupal.org/download-latest/tar.gz | tar -xz --strip-components=1
php core/scripts/drupal quick-start demo_umami

For more detailed information on how we achieved these improvements, read Matthew's latest blog post: The New Drupal Evaluator Experience, by the numbers.

A big thank you to Matthew Grasmick (Acquia) for spearheading this initiative!

Sep 14 2018
Sep 14

Selling products online is not just about successful eCommerce, but managing data as well as customer engagement across the platform. Drupal integrated with Drupal commerce offers unprecedented results that are highly secure, stable, create engaging web experiences and drive website traffic. The combination also ensures that both users and customers have a seamless experience, reduced development time, easy maintenance, and control of SEO, CRO, and website analytics tool among others.

In this post, we have shared 10 great examples of websites (from different industries) built on Drupal commerce that are setting the benchmark. These will surely help you with the creative process. Read on the features, functionalities and 3rd party integration used by these companies.  

Urbany's

When your website is all about fashion accessories, you need a site that draws people attention, offers seamless navigation and secured payment gateway. The Swiss e-commerce store leverages Drupal commerce as it was specifically designed to fit in with Drupal 7 using the latest features and APIs. However, the store leverage Drupal 8 for its improved loading speed, mobile toolbar and responsive theming.  

Further, Bootstrap is used as a front-end framework due to its responsiveness, development speed, customization, simple integration and other. The site is integrated with analytics tools like Google Analytics and Matamo for measuring the success and utilizes the payment processing service of Visa, Mastercard, Paypal, American Express.

Lush

British skincare and handmade cosmetics store Lush presents a clean astonishing website that features attractive colors and fonts. Built on Drupal 7, the website is complemented by a wide range of features such as a single page checkout to pay securely with Mastercard, PayPal, Visa, American Express and BitPay. Lush uses CloudFlare as a content delivery network as it automatically optimizes the delivery of web pages to reduce page load time.

The e-commerce store is integrated with Mautic to connect all of their digital properties and channels. Further, the site uses Varnish as a caching tool and Google Analytics as a digital analytics software to measure its success.

Olsson & Gerthel

Olsson & Gerthel - a Sweden-based furniture store is well-known for features world-class designers on their Drupal Commerce website. The site stands due to its up-to-date style, seamless navigation and more importantly, a side panel makes it easier to filter the object as per our requirement. The e-commerce store uses Zendesk Chat for the live chatting feature, Google analytics, and CKEditor - a WYSIWYG text editor that allows the user to write content directly on web pages or online applications. 

Pam Kerr

New Zealand-based online jewelry store Pam Kerr designs uses Drupal commerce for their website to showcase the latest collections. A simple layout and clean design give an enchanting and smooth user experience. The e-commerce site is integrated with Stripe for payment processing. Built on Drupal 7, the site offers various payment options including PayPal, Visa, Mastercard, and American Express. Google PageSpeed has been utilized as a caching tool and Google Analytics for measuring the success. 

fooda

Fooda, an American meal services firm, partners with companies and office building to provide a restaurant-based meal. The website, which uses Drupal Commerce for a clean layout and easy navigation, uses Bootstrap as a front-end framework. Third-party APIs are also utilized throughout the site, including HubSpot marketing automation tool and analytics tool like Crazy Egg, Optimizely, Google Analytics, Matomo, Mixpanel. Further, AdRoll - an advertising network - is used to collect, analyze, and act on their customer data to deliver marketing campaigns.    

Eurocentres

Switzerland-based Eurocentres is one of the leading organization that offers academic and professional English language courses for adults and juniors on six continents. Nearly, 13,000 students enroll every year from all over the world. Built using Drupal commerce, Eurocentres offer a rich experience, seamless navigation to search destinations, languages, and courses offered. The language learning site uses Visual Website Optimizer and New Relic for analytics and Varnish as a caching tool.

QDOS

The UK-based QDOS - an e-commerce store for phone screen protectors, cases & power products - is beautifully designed to offer seamless navigation and find a relevant product on the homepage itself. The online store, which is built on Drupal commerce, boasts different functionalities like multilingualism, 3rd party integration of various social media channels and accept payment in different currencies like EUR, GBP, and USD. QDOS also offers a great alternative to signing up with your Facebook account, in lieu of creating a new account.  

Third-party APIs are also utilized throughout the site, including MailChimp for marketing automation, LivePerson for live chat and Gauges & Google Analytics for measuring success.

Tuan Nguyen

Landscape photographer Tuan Nguyen uses Drupal commerce to develop to share high-resolution landscape photographs. The online store boasts an image carousel on the homepages segregated into different columns. Though the site looks very simple and elegant, it has fast page downloading, seamless navigation and integration with social media channels to promote the content and drive users back to the site. 

Muzeo

French art gallery Muzeo offers a state-of-the-art experience with high-resolution pictures showcasing different categories that redirect to a specific landing page where you can filter the art pieces accordingly and purchase. Built on Drupal commerce, the homepage features a menu section on the top left side to redirect to different landing pages. The art store also allows users to narrow their search by filtering the pieces using header and side panel. Whereas the footer section features payment options, return policy, rating, comments, and third-party integration with social media channels. Users can also subscribe to the newsletter by just entering their email IDs.

Guerlain

Founded in 1828, French perfume, cosmetics, and skincare house use Drupal commerce to feature its products online. The header houses different categories where you can find a list of products along with the new product available in that category. Each product has a dedicated landing page with product description, an option to add on the wishlist and zoom the product images to have detailed look. Landing pages also include point of sales option where you can find your nearest store and share button to share the products with your kith and kin.

We, at Valuebound - a Drupal web development company based out of New York, help enterprises with Drupal migration, Drupal support, third-party integration, performance tuning, managed services, and others. Get in touch with our Drupal experts to find out how you can enhance user experience and increase engagement on your site.

Suggested Readings:

Sep 14 2018
Sep 14

Seven months ago, Matthew Grasmick published an article describing how hard it is to install Drupal. His article included the following measurements for creating a new application on his local machine, across four different PHP frameworks:

Platform Clicks Time Drupal 20+ 15:00+ Symfony 3 1:55 WordPress 7 7:51 Laravel 3 17:28

The results from Matthew's blog were clear: Drupal is too hard to install. It required more than 15 minutes and 20 clicks to create a simple site.


[embedded content]

Seeing these results prompted me to launch a number of initiatives to improve the evaluator experience at DrupalCon Nashville. Here is the slide from my DrupalCon Nashville presentation:

Improve technical evaluator experience

A lot has happened between then and now:

  • We improved the download page to improve the discovery experience on drupal.org
  • We added an Evaluator Guide to Drupal.org
  • We added a quick-start command to Drupal 8.6
  • We added the Umami demo profile to Drupal 8.6
  • We started working on a more modern administration experience (in progress)

You can see the result of that work in this video:


[embedded content]

Thanks to this progress, here is the updated table:

Platform Clicks Time Drupal 3 1:27 Symfony 3 1:55 WordPress 7 7:51 Laravel 3 17:28

Drupal now requires the least time and is tied for least clicks! You can now install Drupal in less than two minutes. Moreover, the Drupal site that gets created isn't an "empty canvas" anymore; it's a beautifully designed and fully functional application with demo content.

Copy-paste the following commands in a terminal window if you want to try it yourself:

mkdir drupal && cd drupal && curl -sSL https://www.drupal.org/download-latest/tar.gz | tar -xz --strip-components=1
php core/scripts/drupal quick-start demo_umami

For more detailed information on how we achieved these improvements, read Matthew's latest blog post: The New Drupal Evaluator Experience, by the numbers.

A big thank you to Matthew Grasmick (Acquia) for spearheading this initiative!

Sep 14 2018
Sep 14
Cache tags are a game changer for your caching strategy in Drupal 8.
Sep 13 2018
Sep 13

We are building a 12 factor app with Drupal. This is part two in our series, building a 12 factor app. Today I’m talking about Factor Two: Dependency Management.

What’s up internet? Tom Friedhof here, Solutions Architect here at activelamp. If you didn’t catch my last video on factor one, go check it out. I’ll walk you through how to set up a local development environment on Docker. Today, I’m picking up where we left off and continuing to build on top of that app that we started from factor one. Factor two states Explicitly Declare and Isolate Dependencies. What are your dependencies in a Drupal app? Well, if you’re building a Drupal site, one of your dependencies is Drupal core. If you’re using any contributed modules, those are also dependencies. Basically, you can think of a dependency as any code that you’re not maintaining yourself.

These dependencies you don’t want in your working repository, keep these out of your working repository. How do you bring those dependencies into your app? That’s what a dependency manager is for. I’m going to show you today, how to use composer and how to pull down Drupal core and any contributed modules that we want to use.

One of the other benefits that you get with keeping your dependencies out of your working repository as it makes upgrading your dependencies a piece of cake. Basically, if you want to update Drupal core, it’s a matter of changing a version number in a composer.json file and then rerunning your build. Composer will bring down the dependency that you asked for and put it into its place where it’s supposed to go. Only your custom code unique to your application should be in your repository. Let’s jump back into a demo with that Drupal app that we started in the last video and start defining some dependencies with composer.

All right, so here we are back in our 12-factor-demo app that we started in the last video. And just as a reminder, if you want to go grab this off of GitHub, you can go to the activelamp repository and grab it at 12 factor demo. Now, I have added one commit since the last video. And so if we go take a look at that, essentially all I did was update to the latest Docker sync there and remove some settings that we no longer need due to the upgraded Docker sync. All right, so let’s go ahead and boot this app up. And so if we head over to our terminal and type in Make Start, that’ll actually start the stack up and just to kind of remind you of what that command actually did is we have a make file over here that has the different commands that we can execute using the new Make Command and so make start essentially executes this bundle exec docker-sync-start command.

What that did over here is that started up our docker stack with docker sync. You can see we have three containers that started up here, then we have DB container, the PHP container, and the Nginx container. There was also a sync container that was started as well called Drupal-sync. All of that was covered in the first video. If you’re not familiar with what I’m talking about, definitely go check out that first video because that’s where we covered all this information. And just real quick, if I go into this Docker compose file, you’ll see there’s where those containers are defined as well.

All right, so in this video, we’re going to introduce the composer dependency manager in PHP. So if we hop over to a browser and type in Composer, you’ll see the first like in Google is this Dependency Manager for PHP. And so this is how we’re going to pull in our dependencies for Drupal. As I was mentioning earlier, when you’re building a Drupal site, Drupal core is actually a dependency, and so we’re going to pull in Drupal core with Composer. Now, in the previous video, the way we were actually pulling in Drupal core was using this Drupal image from Docker Hub, and that included Drupal core in there. We’re going to continue to use this image but we’re not going to use any of the code in that image.

Now, you could just switch this over to a PHP image, but for simplicity sake, I’m just going to keep this particular image and then just pull in our own code so that we’re not tackling any Docker configuration in this video. We just want to mess with the Composer Dependency Manager with PHP. There’s a composer template that you can go use to do this. If you just Google for Composer Template Drupal, you’ll see that there are some docs here to actually create a Drupal composer project. That’s exactly what we’re going to do in our code base. And so let’s grab this command, and we’ll head back into our terminal here. Let’s actually get to the correct directory.

All right. Right now, the way we have this directory structure set up on our local file system is in the source directory we have this web directory and inside that web directory we have the Profiles Directory which just has our custom code in it. We need to pull our custom code out so that we can use the Composer Template here, and so our custom code lives in this activelamp directory. Let’s for now grab that activelamp directory and move it out of the source directory. We’ll just say move web profiles activelamp and let’s move that up one directory, and then we’re going to get rid of the source directory completely.

All right, so now we can paste that Composer command that we got from the Composer Template file. Instead of creating this project in a directory called [inaudible 00:07:02], we’re going to create this project and a directory called source. Basically, what this is doing, is this is pulling out the, it’s checking out the Drupal Composer, Drupal Project Template, and it’s putting that into this source directory. Now, with the composer template, you get quite a bit of functionality. This is probably a topic for another video, we really won’t get into everything that this composer template gives you, but this README file is definitely worth checking out on the Composer Dump Template for Drupal projects on GitHub. Let’s see how far this has gotten.

All right, so now we have a Drupal core in our source directory, so if we head back to our code editor now, this should have Drupal core in our code editor. Like I was saying earlier, the dependencies are the files that you don’t manage yourself, you don’t want to have in your repository. And so let’s see what actually is in our repository. Now, if we type in git status, these are all the files that are going to get committed to our repository. Now, some of these files come from what’s called the Drupal scaffold. If I go back over to this Composer Template for Drupal projects, the Composer Template uses something called the Drupal scaffold which basically creates files like the index.php or the update.php file for you when you run a composer update.

If I click into this project here, this will tell us which files are provided by this scaffold, and so we can actually add these files to our .gitignore file as well so that we’re not actually adding this to our composer. Excuse me, our project repository. Let’s go into the .gitignore file here and let’s go down to the bottom and we’ll just say ignore scaffold files and then let’s paste that there and then this, that, and that aren’t file names, so we’ll remove that.

Now, let’s go ahead and save this and then look at, see what a terminal looks like, see if it looks a little bit better. Okay, so there’s fewer files that we’re adding now, but these files are actually files that we do want to add in. Some of these are empty directories like the modules directory in the themes directory, if we look in there. Those are empty directories that we need to actually have in place, so that Composer has a directory to place modules when we’re asking for a module dependency from drupal.org. This activelamp directory right here, we need to actually move that into the profiles directory, so let’s do that real quick.

This is going to go inside the source web profiles directory. All right. And so now this looks like this can be ready to be committed. We’re not going to commit it just yet, we’re gonna finish setting up our stack here. So now that we have the entire Drupal root inside this source directory, we actually need to update our Drupal or excuse me, our Docker sync config. files. Let’s go in there because before Docker sync was just syncing over the web profiles into the container. And so now we actually want to sync all of source into the container. I’m just going to delete that, so basically this whole directory is going to get synced in to the Docker container.

Let me go to our Docker compose dev file, so that sync container is going to be mounted in our PHP container here. We actually don’t want it to be in HTML profiles anymore. We just want it to be at var/www. On the Docker compose file, let’s see. We are sharing a volume with the Nginx container, so we’re sharing val/www/html with the Nginx container. We actually need to have this say web now because the Composer Template actually creates a web directory and not an HTML directory. Let’s go ahead and change that real quick. I’m not going to change it in the dockercompose.yemo file. I’m gonna change it in the dockercompose.dev file because this is really for dev environments. When we create these containers to be shipping containers that we can push to production, we’ll spend a little bit more time on this Docker compose yemo file. But for now I’m just going to create the volume and the Docker compose Dev yemo file so that we at least have the volume set up in our dev environment.

Let’s change this to Nginx and back this up like so. All right, so now in our Nginx container, we’ll get the same mount that the PHP container has to that Drupal-sync container that’s created by Docker sync. All right. So that Composer Template sets up the Drupal doc route in a web directory. We previously had our Nginx Server configured to look at the HTML directory, and so just we go in here. We can see we’re putting in a configuration file on the internet server that’s coming from our config directory Nginx site.com. If I come in here, we have a root here specified as var/www/html. We need to change this to web here so that it’ll actually pick up the correct directory that we’re syncing in.

That should be all that we need to do to get the stack working again. I’m going to go back to the terminal and I’m going to stop this by hitting control C, and then I’m going to run Make Clean. This will basically clean out the containers and the volumes and let us start from a fresh slate. I can type in Make Start and this will boot up the containers again from scratch, create the Docker-sync container and sync the files again. And once that’s done, we should be able to hit the browser and see the latest version of Drupal that we pulled down with Composer.

All right. Now that our stack is back up and fully booted, let’s hit the browser and see if we can get Drupal to load and just for review the Nginx servers listening on port 7080. Let’s hit that and see what happens. I open up a new tab here within a local host, and we’ll go to 7080, and there we go. There is our Drupal install. We’re running the 8.5.6 version of Drupal. And again, we are in that act of lamp profile. So it’s picking up that profile that we put into that directory, and now we can install this as we did before.

One thing that the Drupal Composer Template does for you is it puts your configuration sync directory outside of your files directory, and so you need to actually create this config sync directory. For now what I’m going to do is create this manually. When you’ve got this on your web server, you want to make sure that the web server has access to be able to do this itself, but I’m just going to do this right now manually. I’m going to go into this source directory and create a config. directory. And right now, I’m just going to make it world readable, but really, this should only be read in readable by your web server.

Now if I go back to the Install screen, I should be able to hit try again, and there we go. Now I can actually install this is. Our credentials are Drupal, and this is on a server called [inaudible 00:16:35].

All right, so there’s our freshly installed site, and so just to show that it did install the profile, I look for the 12 factor module that we created in video one. It is, in fact, here. Here’s where Composer really becomes a huge benefit when you’re using the Composer Template for Drupal is when you want to add new modules, all you have to do is just run a composer require statement and it will run out to Drupal and download that dependency, put it in your composer that JSON file and place it in the correct spot in your Drupal install. Let’s go ahead and give that a shot. I go back to our terminal here. I’m in the source directory of the code base. I can run a Composer Require. Let’s pull down the Drupal JSON API module.

What this did is it went out to Drupal.org and grabbed the latest version of the JSON API module and it put it in our Drupal site. Now, if we go back to our code base, and we go inside of our web directory and into our modules directory, into control, we can see there’s the JSON API module. So let’s verify that we actually see this in our code base. Let’s go back to our terminal. I’ll just to show you that when we add new files, the sync is automatically watching, and so that synced over to our code base.

Let’s get into the site again, hit the Refresh button here. If I type in JSON API, that should show up. And so there, in fact, it is. Another benefit that we get with Composer as well as if we need to make version changes, it’s real simple to make version changes because it’s all handled in a manifest file called composer.json. Let me go back to the code base and show you what that looks like. In our source directory, we have a composer.json file that shows us all of our dependencies. Most of these dependencies actually pretty much all the dependencies came from the Composer Template that we were looking at earlier.

If we want to specify a specific version of Drupal, we can come over here and update this Drupal core version and put in whatever version we want. If for example we wanted the latest version of 8.4, we can come in here and type in 8.4. If we wanted to require a specific version of 8.5, say for example we wanted 8.5.5, we can basically take away this Tilda and then run the Composer update.

You can see here that it took Druple 8.5.6 and moved it down to 8.5.5. And then the scaffolding that I was showing a little bit earlier downloaded the 8.5.5 versions of those files and put them in the correct spot. Now if we go back into the Drupal site, and then come under the reports, so the database is already updated for 8.5.6, this isn’t really good example. Let’s go ahead and re populate that database so I can finish demonstrating that this did in fact work.

Now again, if you’re moving forward, this is likely not going to be an issue but because there were likely schema changes going from 8.5.5 to 8.5.6, that’s why this is likely happening. Let’s try something here.

Let me just delete the database so that we can reinstall this. I’m going to clear the stack and then I’m gonna do a docker volume ls. Do a docker volume ls and grep 12. That doesn’t work. Let’s do factor. There we go. I’m gonna delete the data here. All right. Delete the container that’s using that data and then delete the data. And so now if we start this again, it’ll recreate that my SQL database and that we should be able to install 8.5.5 from scratch. Let’s see what happens.

There we go. There’s 8.5.5. As you can see, using a dependency manager makes managing your dependencies much easier than not doing it. If you weren’t using a dependency manager, you would actually have to move those files in and out of where they’re supposed to go manually. Also, one of the benefits that we get is all of these dependencies like the JSON API and Drupal core aren’t actually going to be committed to your repository. If we look at this repository, we can see the only things that are going to get committed are these files, we don’t see the core, Drupal core, we don’t see the JSON API module in there. It’s just the files that we really need to manage. Let me go ahead and add those files to our repo, and push that up to our repo in GitHub.

As you can see, we’ve got a lean code base that we’re managing in our repository. And we’ve got an easy way to pull an updated dependencies with Composer. Not only that, we’ve even specified our infrastructure as a dependency of our app. Your code needs something to run on, right? But executing a few commands, we’re able to build our app and have it served by Docker containers that will eventually ship to production. That’s all I’ve got for you today. If you liked this video, make sure to give us a thumbs up and hit that Subscribe button. See you next time.

Tom Friedhof Tom Friedhof Senior Software Engineer

Tom has been designing and developing for the web since 2002 and got involved with Drupal in 2006. Previously he worked as a systems administrator for a large mortgage bank, managing servers and workstations, which is where he discovered his passion for automation and scripting. On his free time he enjoys camping with his wife and three kids.

Please enable JavaScript to view the comments powered by Disqus.

Sep 13 2018
Sep 13

Yesterday at Drupal Europe, Drupal founder and lead developer Dries Buytaert gave a keynote that outlined the future for Drupal, specifically the release of Drupal 9, and how it impacts the lifespan of Drupal 7 and Drupal 8.

For the TL;DR crowd, the immediate future of Drupal is outlined in the snappy graphic above, and shared again below (thanks, Dries!).

The big takeaways are:

  • Drupal 9 will be released in 2020.
  • Drupal 7 end-of-life will be extended out to 2021, even though Drupal usually only supports one version back.
  • Drupal 7 and Drupal 8 will be end-of-life in 2021.

Wait… what? This proposed schedule breaks with tradition – Drupal has always supported one version back. And this schedule gives D8 users a single, short year to upgrade from Drupal 8 to Drupal 9.

So what now? Wait until 2021 to move your site off Drupal 7? Do two (possibly costly) upgrades in three years? Bail on Drupal entirely?

First and foremost, Don’t Panic.

Let’s explore each of the options in a little more detail to help inform your decision making process.

Upgrade from Drupal 7 to 9

When Drupal 8 became available, a lot of organizations using Drupal 6 opted to wait and bypass Drupal 7 entirely. The same is certainly an option for going from D7 to D9.

On the plus side, taking this route means that it’s business as usual until 2020, when you need to start planning your next steps in advance of 2021. Your contributed modules should still work and be actively maintained. Your custom code won’t have to be reworked to embrace Drupal 8 dependences like Symfony and the associated programming methodologies (yet).

Between now and then, you can still do a lot to make your site all it can be. We recommend taking a “Focused Fix” approach to your D7 work: rather than a wholesale rebuild, you can optimize your user experience where it has the most business impact. You can scrub your content, taking a hard look at what is relevant and what you no longer need. You can also add smaller, considered new features when and if it makes sense. And savvy developers can help you pick and choose contributed solutions that have a known upgrade path to Drupal 8 already.

But it isn’t all roses. Delaying potential problems in updating from 7 to 8 doesn’t make those problems go away. Drupal 9 will still require the same sort of rework and investment that Drupal 8 does. It is built on the same underlying frameworks as Drupal 8. And Drupal is still going to push out some updates to Drupal 7 up until its end-of-life, most notably requiring a more modern version of PHP. Changes like this will definitely affect both community-driven modules and any custom code you may have as well.

Upgrade from Drupal 7 to 8 to 9

“Ginger Rogers did everything [Fred Astaire] did, backwards and in high heels.”

— Bob Thaves

Colloquially, the most efficient way to get from Point A to Point B is a straight line. Major versions of a platform are effectively a line. In this case, you can think of that “straight line” as going from D7 to D8 to D9, instead of trying to go around D8 entirely.

It’s critically important to understand one unique feature of Drupal 9: It is designed from the ground up to be backwards compatible with Drupal 8.

Angie Byron, a.k.a. Webchick, gave an excellent talk about what this really means at BADCamp last year.

[embedded content]

Again for the TL;DRs — “backwards compatibility” means that code is deprecated and ultimately removed  from a code base over time in a way that provides a lot of scaffolding and developer notice. This practice results in major version upgrades that require very little rework for the site to stay functional.

The backwards compatible philosophy means that the hard work you do upgrading to Drupal 8 now will still be relevant in Drupal 9. It won’t be two massive upgrades in three years. As long as your Drupal 8 site is up to date and working properly, D9 should not bring any ugly surprises.

Have more questions about Drupal 7 vs 8 vs 9? Contact us and we’d be happy to help with your project.

Let’s talk community code

When Drupal 8 was released, one of the BIGGEST hurdles the community faced (and continues to face) was getting contributed modules working with the new version. It required ground-up rewrites of… well… pretty much everything. A lot of modules that people were using as “basics” in Drupal 7 were folded into Drupal 8 core. But a number were not, and people volunteering their time were understandably slow to bring their contributed code over to Drupal 8. As a result, many sites were hesitant or unable to upgrade, because so much work would have to be customized to get them to same place the were on Drupal 7.

So will it be the same story going from Drupal 8 to Drupal 9? Will we have to wait years, in some cases, for our business-critical tools to be updated?

According to Dries’ post, the answer is no. Drupal is extending the backwards-compatible philosophy to the contrib space as well.

… we will also make it possible for contributed modules to be compatible with Drupal 8 and Drupal 9 at the same time. As long as contributed modules do not use deprecated APIs, they should work with Drupal 9 while still being compatible with Drupal 8.

— Dries Buytaert

Assuming  this plays out as intended, we shouldn’t see the same dearth of contrib support that we did when Drupal 8 became a reality.

And yes. There are a lot of assumptions here. This is Drupal’s first pass at a backwards-compatible upgrade methodology. There is inherent risk that it won’t work flawlessly. All we can say for sure is that the community is very hard at work getting to a reliable release schedule. A thoughtful upgrade approach should make the “Drupal Burn” associated with major version upgrades a thing of the past.

So which way should I go?

So which approach is best? For starters, think about whether an upgrade benefits you in the immediate term. Read a little about Drupal 8, audit your site with our website checklist, and if you still aren’t sure, you can start with our quiz.

If all of this feels overwhelming, contact us. Kanopi Studios is known for its great support (if you choose to stay on D7), as well as great design and build execution (if you choose to go to D8). Whichever way you choose, we’ve got you covered.

Sep 13 2018
Sep 13

The marketing landscape is vastly different than it was when Drupal 7 was released in 2011. Since then, there has been a shift, placing the marketing team in the driver’s seat more often and almost always involved in the CMS decision. In this post, we’ll outline some of the ways you can up your SEO game with Drupal 8.

Traditional SEO is dead.

No longer will well-placed keywords alone get you to the top of the SERP ranks. Content is still King in the world of marketing and it’s what helps you improve your SEO.

Every algorithm change Google has made has one thing in common: it aims to provide the best content based on what it "thinks" the user is trying to find. In other words, - what is the users intent. If you want your rankings to stick past the next update, don't try to cheat the system. Attract your prospects with informative, entertaining pieces that they can use to take action. And avoid no value posts that are keyword stuffed with your industry and the word "best" 100 times. Google can see through it and so can all of your users.

That said, there are a few other factors that are critical to keeping your rankings high that can’t be ignored including quick load times and mobile-friendliness. Drupal 8 is built with several of these factors in mind to help us make needed improvements quickly and effectively.

Mobile First Mentality

Drupal 8 is created with responsive design capabilities built in, so you can begin to address any problems immediately. That’s not to say all of your responsive problems will be solved. Content editors will still need to think through their content and imagery, themers will still need to do configuration to establish things like breakpoints, etc. but Drupal 8 will set you on the right path, giving you and your team many of the tools you need.

You’ll also have the option to choose different images and content for desktop and mobile versions right from the WYSIWYG editor, making it easier to see the differences for every piece of content when you add it and before you publish. This means a solid visual of both versions in real-time for faster publishing and peace of mind knowing exactly what your users experience on any device. 

The Need for Speed

Another big factor that could affect your rankings is speed on both desktop and mobile. Google places such high importance that they’ve given you a PageSpeed Insights test to show where and how your website is slowing visitors down. Drupal 8 is “smart” in that it caches all entities and doesn’t load JavaScript unless it has to. This means the same content won’t be reloaded over and over and instead can be loaded quickly from the cache.

Drupal 8 also uses industry-leading caching technology to allow updated content to be served fresh to a client, while preserving the cache on content that hasn’t changed. So, after your visitors come to your website once, they won’t have to wait for all content to load each time, making load times much faster.
Another way Drupal 8 improves speed is through feature velocity. Because so much new functionality is built into Drupal 8 core, creating and publishing new dynamic content experiences is significantly faster than in Drupal 7. A blog post that features dynamically updated data, relevant to and powered by your content can be built in the UI in Drupal 8, something that in Drupal 7 would have taken custom development and several modules.

Responsive design is a must-have in today’s digital landscape and speeding up your website on both desktop and mobile is a surprisingly effective way to contribute to your SEO efforts. In short, if you’re marketing team is focused (as you should be) on top rankings, Drupal 8 provides many of the tools to make that happen. 

Accessibility = Key for Search

The release of D8 marked a big push toward improving web accessibility, including: 

  • Overall community commitment to accessibility 
  • Technical features for improved accessibility like controlled tab order and aural alerts 
  • All features conform with the World Wide Web Consortium (W3C) guidelines

This is important because, as we know, the relationship between web accessibility and SEO is closely intertwined.

Drupal 8 SEO Modules

Here are some top Drupal 8 SEO Modules to use when optimizing your site. 

  1. Pathauto - helps save you time from manually having to create URL path/aliases.
  2. Metatag - allows you to automatically provide structured metadata, aka "meta tags", about a website.
  3. Sitemap - provides a site map that gives visitors an overview of your site. It can also display the RSS feeds for all blogs and categories.
  4. Redirect - Almost every new site needs to incorporate 301 redirects for old page URLs. This gives site admins an easy interface for creating those redirects in Drupal.
  5. Google Analytics - This simple module allows site admins the ability to easily configure Google Analytics in Drupal.
  6. Easy Breadcrumbs - uses the current URL (path alias) and the current page's title to automatically extract the breadcrumb's segments and its respective links. 
  7. SEO Checklist - uses best practices to check your website for proper search engine optimization. It eliminates guesswork by creating a functional to-do list of modules and tasks that remain. 

Conclusion

Drupal’s content management system is perfectly structured for search optimization and its core features support many of the critical SEO elements. But, SEO is only part of the story. In the next post, we’ll explore some of the do’s and don’ts and things to keep in mind once you’re on Drupal 8. 

Sep 13 2018
Sep 13

Choosing a platform on which to build your website can be a daunting task. There is an ever-growing list of content management systems (CMS) from advanced platforms like Drupal and WordPress to all-inclusive DIY website builders like Wix and Squarespace. The right choice depends on factors such as desired functionality, flexibility, available budget, and your ability to manage the site after launch.

Where you fall on the spectrum between mom-and-pop shops and enterprise businesses will also heavily influence your decision.

  Mom-and-Pop <—————————> Enterprise

Questions to consider before choosing your CMS

  • How often do you want to post or update content?
  • How many content editors will be adding to the site?  
  • Do your editors need varying degrees of access and permissions?
  • Will your site have a heavy reliance on search, interactivity, or 3rd-party integrations?
  • Do you have specific design needs that require multiple custom layouts?
  • Will you be able to support the site without developer support?
  • What is your project budget?  
  • What is your post-launch support budget?

Scalability vs Simplicity 

WordPress and Drupal have many things in common. Both are open source and freely available, are supported by their developer communities who contribute code to the projects including regular security updates, and offer extensive add-on functionality to the CMS core through plugins and modules.

Site builders or content managers who have used both systems often have a bias for WordPress over Drupal, considering WordPress the more user-friendly of the two. Before one can accurately make such an assessment, I believe the comparison must be apples to apples between comparably sized sites with similar functionality or complexity. If one compares how user-friendly WordPress is for creating and managing a personal blog or small business website that requires no customizations and has static content versus the complexities of using Drupal to build a site for the enterprise with dynamic relationships between various data points, that is not a reasonable comparison.  It is true that Drupal has a higher learning curve than WordPress largely due to the amount of available customization that is built into its core. WordPress is simple to use, especially for blogs or small sites, but not necessarily scalable or suited for larger more complex sites. If pushed to the enterprise end of the spectrum above, would WordPress still maintain its user-friendliness and be able to scale? Conversely, Drupal is best suited for enterprise level sites with custom requirements and would add unnecessary development overhead if chosen for a small site or blog.

If WordPress and Drupal were Lego types...

I’ve often thought of Wordpress and Drupal in terms of Lego whereas:

Lego Duplo set, simple with large building blocks like Wordpress

Source: Lego.com

WordPress is like Lego Duplo where you can build things easily with preformed shapes as long as those preformed shapes match your specific needs. These preformed shapes equate to plugins to add functionality and pre-designed theme templates that determine the styles and layout of your site. Duplo blocks are appropriate for ages 1-5 or, in other words, personal projects or small to medium businesses with simpler requirements. 

 

Lego Technic race car is complex like Drupal

Source: Lego.com

Drupal is like Lego Technic where you can build whatever you can imagine with little to nothing preformed. Like Technic pieces, Drupal has highly configurable plugins that provide granular control over the functionality of your site and do not impose pre-selected designs to your theme. They are appropriate for ages 7-16 or, in other words, medium to large businesses or organizations with complex requirements. 

With that analogy in mind, let's explore some of the advantages of each platform.

Advantages of WordPress

Confession: I love WordPress. It’s true! As a non-developer with several personal projects outside of work, whether it was for my consultant friend who needed a five-page site with a contact form, a guitarist wanting to promote his music, or managing several blogs, WordPress meets those needs perfectly. Below are the features that stand out in my experience from which people draw the conclusion that WordPress is so user-friendly. 

Dashboard

Upon logging into WordPress you are presented a user-friendly and intuitive admin interface from which you can figure out almost instinctively how to manage your website. You can quickly navigate to various types of content or site functionality from the left rail admin toolbar. The admin toolbar has appropriately named menu items. Hovering over each one triggers a slide out sub navigation making it easy to find the action or setting for which you are looking.

Screenshot of Wordpress user-friendly dashboard

Media Library

Adding images to your content or as a featured image above a post or page is quite simple. With a click of a button, you can add images, audio or video files, documents, and PDFs. Images are automatically given responsive image styles so that they adapt appropriately to the width of one’s browser window or mobile device.

Though not specifically part of the media library, inserting YouTube or Vimeo videos into a post is as simple as pasting the URL. WordPress will render the video as embedded on the page (also works with Twitter and Instagram posts).

Adding Content

As noted above, the Dashboard provides quick access in a few different ways to add new content. The Add New Post (or another type of content) edit page has a visual WYSIWYG editor for formatting your content with links to add media, categories, tags, and visibility of your new post. You can easily view revisions after content has been published and revised with functionality that is provided out of the box.

Screenshot of Wordpress admin interface for adding a new blog

Plugins and Themes

I’m grouping these two together because here is where we begin to add to WordPress core and its out of the box functionality. I’ve used 3rd-party plugins to add custom forms, simple e-commerce capabilities, invoicing and client management features, automated backups, and SEO enhancements to WordPress sites. The WordPress Plugin Directory boasts 56,182 available plugins to add functionality that is not included or as customizable within WordPress core. Many plugins are completely free or offer freemium versions with more advanced premium features available for a one-time charge or subscription fee.

Wordpress.org ecommerce plugins

Likewise, the WordPress Theme Directory offers many free or commercial templates searchable by layout options, features, or subject (topic matter of your site). Themes typically have some customization built-in to control layout options, widgets, background images, and the like.

Screenshot of Wordpress themes and layout options

Updates

WordPress Core, installed plugins and themes can be updated with the click of a button through the Dashboard. 

screenshot of Wordpress plugin updates

*Plugins are a double-edged sword in that they add flexibility from a non-developer standpoint while simultaneously introducing more risk from a security standpoint. The more 3rd-party plugins you use, the more dependence you will have on those 3rd-parties keeping their code secure by providing timely updates. Security issues with WordPress are introduced most often through vulnerabilities exploited in plugins.

Lower development costs 

This isn’t a feature of WordPress, but it’s worth mentioning that if the “out of the box” solutions meet your needs and you are able to build a site without the assistance of a developer, it will cost you less. If you fall on the mom-and-pop end of the spectrum, have a lower development budget, and are not picky about every detail of design or functionality, WordPress is likely a great option for you.

Advantages of Drupal

Custom content types and views 

Whereas WordPress comes with two content types (posts and pages), Drupal also comes with two content types out of the box (article and basic page). However, it not only allows you to edit the fields for those content types but also create new content types and views without custom code that meet your specific requirements. If your site needs a blog, you can create a content type for blog posts and a view that displays them the way you want. If you need a staff directory, you can create a content type for staff that has fields for name, title, profile picture, bio, etc., and then create a view to display the staff in a list, a grid, or to whatever your specs require.

This is one way in which Drupal and WordPress differ. Drupal is an application framework that allows you to build what you need the way you need it. WordPress core starts as a blog that makes you add to core in order to manipulate its built-in behavior. For example, in order to disable blogging in WordPress, you have to install a 3rd-party plugin such as Disable Blogging in WordPress.

If you compare WordPress core and Drupal core, Drupal is far more robust than WordPress.

Access control and user permissions 

Out of the box Drupal core allows you to create and define your own user roles and associated permissions for each. If your site requirements call for multiple levels of user permissions with varying degrees of access, Drupal lets you create new roles and assign them with custom permissions. And, unlike WordPress, Drupal allows granting more than one role to your users. This gives you fine-grained control over what they are allowed to do. Building on the previous example of a staff directory, you could create a role for Staff and only give that role permissions to edit one’s bio page. All of these customizations for roles and permissions can be done in the admin without adding any custom code.

Screenshot of managing roles in Drupal CMS

screenshot of permissions in Drupal

adding a new user in Drupal CMS

Taxonomy 

Whereas the tagging system in WordPress is flat, in Drupal you can have multiple types of categorization and determine how much information you want to track on each one. Drupal allows you to create more complex and custom data relationships across various types of content.

screenshot of taxonomy terms in Drupal CMS

Internationalization 

Want the Drupal admin to display in the native language of your officemate overseas? No problem! Native language handling is now built into Drupal 8’s core APIs which improve the ease of globalization management. Building a multilingual site no longer requires installing multiple contributed modules. 

Drupal 8 multilingual configuration

Security 

Drupal is known for having a volunteer security team and a standardized set of policies and procedures for dealing with security issues. Security advisories are routinely posted on https://www.drupal.org/security for Drupal core as well as contributed projects. For enterprise clients with specific security needs, the Drupal distribution Guardr is available with a combination of modules and settings to enhance the Drupal application’s security.   

Drupal.org security advisory

Customization

As a web application framework, Drupal can be adapted to meet very specific requirements. For example, the Drupal entity system allows tracking specific data points and values that are needed when building applications. At times, Content Types aren’t the best choice for these data elements, and more custom entities allow for improved performance and fit the requirements best.

If this has you scratching your head, you’re not the only one. I’m purposely skirting around the complexity of the section because it is beyond the scope of what I’m trying to speak to here. The important difference here is that Drupal allows tracking points of data without cluttering up the editorial experience. Sometimes the data needs to be seen but not heard. Drupal lets you do that. And site editors may never even realize it’s happening.

Conclusion

As a site builder who has built dozens of sites in HTML, Joomla, and WordPress and worked for five years as a project manager at Mediacurrent (almost exclusively with Drupal), I realize that the Lego analogy may be helpful but at the same time not completely accurate. After all, WordPress boasts such enterprise level sites such as Techcrunch, Sony Music, and Time, Inc. But my experience reinforces the perception that WordPress is amazing at simple sites or blogs while Drupal is the go-to for more complex sites. 

I’ve found that clients will like a template design exactly the way it comes except for “insert numerous design changes” or the plugin functionality as-is “if you change this one behavior that isn’t built into the plugin.” And at that point, the gains of using out of the box functionality and design offered by WordPress (either via core WordPress or plugins and themes) are lost to customizations and a custom Drupal implementation is preferred. If you fall on the enterprise end of the spectrum and have deeply refined technical requirements, Drupal is likely a great option for you.

It comes down to the level of complexity for which you need to plan. If you are building a large site that is essentially brochureware (static pages), WordPress will work for you. If your site requirements call for a dynamic application with a heavy reliance on custom search results, interactivity, or 3rd-party integrations, or if you have specific design needs that require multiple custom layouts, your best bet is to use Drupal 8.

Sep 13 2018
Sep 13

on September 13th, 2018

Website redesigns are a common occurrence in growing businesses, but many people get confused as to when they’re supposed to do one. Your website is a window for the world to get a look at your company. It’s a very important part of your business' marketing efforts. It’s critical to get the timing right.

While there’s certainly space between a redesign being a nice “want-to-have” and it being a “need-to-do,” here are some signs that will tell you when it’s time for a refresh.

Mobile Unfriendliness

Over half of all internet traffic is now coming from a mobile device. If your website is not formatted effectively to be viewed and used on a wide variety of screen sizes, then the redesign should come much sooner rather than later. Having a design that makes the content illegible on a mobile device will send your user elsewhere.

Responsive layouts, navigation links that break up into big, tap-friendly menus, data plan-friendly image optimization, and other considerations for mobile users are what constitutes a mobile-friendly design. Google provides a Mobile-Friendly test tool you can use to check your own website.

Mobile Versions or Responsive Design?

One approach to address this is to develop two versions of your website, one for mobile and the other for desktop users. The web server detects the device that your visitor is using and routes them to the correct version. The advantage of this system is that the mobile version can be optimized to be lightweight in data and speedy to load, specifically for mobile users. That means you can sideline any non-applicable considerations in your design. The biggest disadvantage is that you need to then maintain twice as many web pages: your mobile site and your desktop site.

We recommend responsive web design for our clients, instead. It's just more efficient.

Rather than developing both a desktop and a mobile version, you should have one website that will adjust its layout and navigation based on screen size. Skilled web developers can deliver fast websites to both platforms by optimizing and compressing images, using minified code (which means to strip out all unnecessary code), and other speed improvements.

By setting 'breakpoints' in the layouts, you can also have different layouts and navigation for different screen sizes. A giant drop down animated menu that looks great and is super useful on a desktop is gonna drive your mobile users bonkers.

Via breakpoints, you can set the navigation menu to collapse into a simpler menu with big finger-friendly buttons when it's served to someone on a phone.

Unprofessional Design

Your website is the first impression your company makes on a user, and you want that impression to be a good one. Customers are qualifying companies as much as companies are qualifying customers. They use channels like social media, company websites, and online reputation platforms to see if the company is a good fit for their needs. Compare your website to that of your competitors. Have coworkers critique the website. Look at websites in your industry that you enjoy visiting. Does your website stack up?

Trends shift in web design, as they do in fashion - what looked great in the past can be jarring or cringe-inducing now. Showing up to a pitch meeting in dated business attire projects the impression that you either don’t care about or are ignorant of modern clothing trends. When a visitor lands on your website, dated design projects that same impression.

Web design can look unprofessional if its inconsistent with your brand. Your website needs to clearly call out your company's value statements to your visitors. Unappealing fonts, low-quality icons, slapdash layouts, and thoughtless color palettes confuse and build mistrust in your visitors

User Experience and Design

Good design is about more than just the visuals of your website. It considers the users' needs and their experience while navigating and using your site.

Intuitive navigation needs to tell the user where they are, how they got there, how near their destination is, and how they get there. Thoughtful categorization of content complements your design. By grouping things in a way that makes sense to your visitor, you make it easy for them to solve their problems or satisfy their needs. 

High Bounce Rate

Bounce rate is a metric describing the percentage of your visitors that leave your website within moments of arriving from a search results page. Either they were sent away by a technical problem or something about your website compelled them to leave of their own volition.  You can see your bounce rate in analytics suites, like Google Analytics, assuming you have the code installed.

If you DON’T have this software installed, you have no way of knowing how effective or ineffective your website is. Bounce rates are considered to be great if they're in the 20's to the 30's (percentage-wise) and acceptable in the 40's and mid-50's. Upper 50's and up, is considered to be a high bounce rate.

There are two important things to note here. First is that these classifications are generalizations across a broad swathe of industries. Websites in some industries have a lower bounce rate since their content is more engaging. Second is that you should only be worried about human visitors to your website when it comes to bounce rate.

In your web analytics software, it's important to filter out bots and crawlers from your data. Moz has a great explanation and guide to filter out bots from Google Analytics

A high bounce rate means that your website is not serving its basic function in some fundamental way. This is a major problem that needs to be addressed as soon as possible. There are a number of reasons that visitors could be bouncing from your website, but some major ones are:

Slow loading pages

When a visitor arrives on your site, they expect the content to load nearly instantly. High load times (or latency) could be caused by bloated code (an inexperienced developer used way more code to achieve a result that a more experienced developer could have done with less). It could also be due to an inefficient system of fetching and displaying content or it might simply be large images that aren't optimized for the web.

The longer the loading time, the greater the chance that your visitor is going to head back to the search results and try the next option. Since your site likely appeared in their search results because you offer something they were looking for, this means your visitors went to a competitor.

Confusing Titles or Meta Descriptions

The page title (as denoted in your website by the <title> tag) appears in search results. It's read by search engine robots and used to categorize your website in their indexes. Meta descriptions (which appear in <meta> tags) are brief summaries of the content of the page (By default, this will be filled with the first few lines of text if you leave it blank). 

While search robots don't pay much attention to meta descriptions, visitors do. They read it and the title tag to decide if the answer to their problems lie on your page. If they arrive on your page and the content doesn't match the title or meta descriptions, they're really likely to head back and try another result.

Technical Errors

For some visitors, they could land on your website and not find the content they're looking for. The URL they clicked on leads to a page that does not exist. There's no reason to stay, so the visitor heads back to the search results. Or they arrive and are redirected to a redirect in a  permanent loop until they give up and try a different result.

Errors like 404 (Page not Found) or 301 (Permanent Redirect) loops are a very poor experience for the visitor and they can contribute to a high bounce rate.

Frustrating Content Administrator Experience

Administrator experience is a term that describes the ease of use of the website for normal operations. Updating copy, adding new articles, adding products to an online store are some everyday tasks for your webmasters and content editors. They need to be straightforward and simple to accomplish. If you need a professional web developer to make content changes or updates, you’re in dire need of a redesign. A good solution might be switching to a content management system like Drupal or WordPress. They excel at making life easier for website administrators who are not developers. This is particularly true if you have multiple people adding content to the website.

One of the simplest ways to improve an administrator experience is to review permissions for each user and limit them based on needs. A content administrator can focus on just the tasks they need to accomplish, making it easier to familiarize themselves with the interface.

Drupal has pretty granular permission systems in place right out of the box, letting you choose what each user can do. WordPress' permissions are role-based, meaning you assign a person to a category (Administrator, Editor, Author, etc) and they inherit all the permissions of that role. WordPress can be extended with plugins to grant more permission setting ability.

benefits of a content management system

Outdated Code

Even the best website will eventually need to be refreshed. Web technology evolves and improves constantly. New versions of programming languages like PHP, Ruby on Rails, and Java (to name a few) are released in updates. Eventually, much older versions of software stop being regularly updated.

This is a problem. The outdated code is a big security weakness, making it one of the first targets for malicious hackers. When support ends for older versions of software, it becomes more difficult and more expensive to maintain that website (since any fixes and updates have to be custom development). This becomes even more of a problem when the outdated software has dependencies or other software that requires it.

A redesign can be a good opportunity to refresh all of the software at once, bringing your site’s code up to the latest versions in one fell swoop.

Is it time to redesign your website?

Trends in web design, user experience, and digital marketing shift relatively rapidly. You can expect to redesign your website every 3-5 years if you want to stay current. For companies, this means that what visitors to your site will both expect and accept also changes. If your site doesn't meet the expectations of your customers, they'll leave. On the Internet, they're not starved for choice.

Send us a message if you'd like to talk about redesigning your website. We'd be happy to do a free site review!

Sep 13 2018
Sep 13

The journey from a visitor to the client doesn’t happen overnight nor over a single screen. 

It is unfair on the part of organizations to assume that all readers will be using the same screen to consume their content. 

In case organizations are working towards targeting various visitors it is important to have a durable and centralised content dissemination platform to serve digital content through various screens.

Therefore it is equally important that various mediums ensure a smoother journey and the backend - content repository - provides a seamless translation of information to various touchpoints. 

What is a Content Repository?

“A content repository is a database of (digital) content with an associated set of data management, search and access methods allowing various application-independent access to the content with the ability to store and modify content.” 

The content repository acts as the storage engine for a larger application such as a CMS which adds a user interface on top of each of the repository's application user interface.

a diagram with a heptagon in middle with 7 boxes connected to it

The proliferation of content across a variety of sources can create an enormous business challenge. As the unstructured content grows, organizations need to look for a flexible approach that supports interoperability with a wide array of popular systems and products. 

A robust central content management repository should store a variety of content formats, facilitate read/write capabilities, control access. 

Here are some of the features of a content repository:

  • Efficient storage to integrate content
  • Query and Search 
  • Versioning 
  • Import/export the content 
  • Editor accessibility for all the documents and the content. 
  • Records retention management systems
  • Document capture systems and document-imaging (Complementary systems) 

Difference between a Content Repository and CMS
A content management system manages the creation and modification of digital content and typically supports multiple users in a collaborative environment.
While a content repository disseminates the content to be shared between disparate websites, different kinds of devices or channels such as mobile phones, tablets, kiosks, Facebook or syndicated via an API.

How Does a Content Repository Work?

A central content repository allows the content editors to edit content directly from the backend of one site. The content editors simply choose the topics that the content belongs to, and the sites subscribe to those topics and it is then available to all the connected sites automatically. 

a flow chart with five blocks in it

A Content Repository Workflow works like this:

Content creation of a topic happens on Site A.

  • The content is shared via a central content repository.
  • Site B is subscribed (sync rules) to receive updates whenever the content for the same topic is created.
  • Site B, C, D receive the notification and pull in the content. 
  • If any user on site C searches for the new content published through site A, she will get it through the content repository.

Drupal 8 is well suited to act as a central content repository, as it has built-in support for REST web services, a serialisation component, and can be configured to work with publishing workflows and notifications.

Search web service such as Apache Solr or ElasticSearch can best provide a lookup service for each site. Rather than subscribing to a particular topic, content editors can simply search for the content they wish to import from.

Application of Drupal as a Central Content Repository

  • Content management
  • Document management
  • Digital asset management
  • Records management
  • Revision control
  • Social collaboration
  • Web content management

Building Consumer Experience with a Central Content Repository

Content is not only the material you use to develop your CXM strategies—it’s also the interactions between customers and prospective customers have with you. Talking about the online customer experience, a CMS is part of the process of designing and supporting CX strategies. 

Simply because it stores all the content you need to manage the experience. However, customer experience management is about more than the online channels. 

In order to successfully manage the customer experience, the CMS needs to be able to quickly access and react to the elements of a customer interaction. Not just this, the elements should be accessible to the editors as well. 

Managing every single version of the web pages is a heck of a job and ensuring that the content looks just the same is another fight. 

Most, if not all, CMSs are designed to store content not just as HTML pages, but as individual components that can be easily reused across different web pages. Across various devices, mobile sites and apps, and social networks.

In this way, the content repositories can be leveraged to provide content as well. 

Content integration is the key to a well-managed content repository. Managing the content by integrating it with all the other systems. 

A central content repository also allows you to develop the support applications that have access to customer information easily, including information from CRM systems, traffic information, and the like.

Having it all accessible in a centralized content repository will help you identify, design, and refine your CX strategies quickly.

Building a Central Content Repository for FarmJournal Media 

For Farm Journal Media, OpenSense Labs have implemented a similar centralised content management system. 

Technologies Used 

  • Express.js 
  • MongoDB 
  • Drupal 8 

How Did It Work?

Express.js- node.js framework provided a library of many pre-built functions which were leveraged for the CCMS. 

It allowed simultaneous access to multiple authors without compromising on speed. This could be done by leveraging its events loop based asynchronous task handling. 

The interface to serve content was developed via MongoDB. The system triggered updates of content from CCMS to MongoDB asynchronously and in real time. This ensured the cron jobs do not overload the sites as the webhook request will be triggered only when required. 

Due to this layered architecture, the overall content journey once the editor hits save, to consumer site was at max 3 seconds.  

An increase in consumer sites, update count and pull requests do not affect the load on CCMS Drupal. 

A special fail handler was built to sanity check between CCMS, Mongo and consumer sites. This ensured there was no duplicity and maintain an error log for missing articles during the journey it takes with an exact failure points reported. 

homepage of greenbook with various blocksOne of the sites of FarmJournal

How Did the CCMS Worked?

It allowed the team of editors to:

  • Centrally manage the content through one platform
  • Cross-publish articles on full networks of FarmJournal sites
  • Use a simple site vs category mapping for automated syndication of articles. 
  • Have a centralised reporting to boost the editorial teams’ productivity & article publication pace. 

The Scope of Building a Content Repository in Drupal

Coupled CMS (with supporting API)

A traditional website on Drupal allows content editors to add or edit content with a preview for the content as well. This is because a traditional CMS is tied (or coupled) to a front end (which is the case with Drupal).

Taking the front end out of the equation can bear its own challenges.  

The front end is what a user sees when viewing an application, which, in Drupal’s primary case, is a website. 

Content editors can view the content before it’s published using a wide array of tools such as inline editing or pre-published previews. 

Available modules in Drupal allow for quick and relatively easy modification to how the data is displayed on the frontend. Developers aren’t always needed to make simple changes, which can be more efficient for both time and cost, possibly a huge benefit to using a coupled CMS.

Drupal 8 has a strong emphasis on providing many API services out of the box, and there is a strong push for the API-first approach.

Headless CMS (the API-only approach)

With API-first Initiative at the forefront, Drupal 8.0 was shipped with a built-in REST API which spelt the beginning of Drupal’s transformation as an API-first platform.

A headless CMS often confused with a decoupled CMS is considered an API-only approach. 

It provides a hub for the content sans any frontend. 

The backend allows content editors to publish content distributing it automatically to any integrated application. Since there is no coupled frontend interface to immediately view the data applications such as Digital signage need be developed and integrated in order to access this content. 

In such a scenario trialing and proofing content before publishing can be difficult. Another challenge is the layout which can be a limitation to the marketing teams. 

The Drupal community has already taken steps towards making sure Drupal continues to be a relevant contender as either a coupled OR headless CMS.

Drupal distribution Open Y can be used to build such applications for a Digital Signage.

Drupal Distribution Contenta can be used as an API to connect the backend of Drupal with any application. 

Conclusion

Previously unstructured and inaccessible content comes alive in digital business applications that engage customers, automate business processes, enhance collaboration and govern and protect content throughout its lifecycle. 

Content management services and solutions from OpenSense Labs support your digital transformation and help you build a cognitive business that is confident, efficient and competitive. Drop a mail at [email protected].  

Sep 13 2018
Sep 13

This blog has been re-posted and edited with permission from Dries Buytaert's blog. Please leave your comments on the original post.

Since the launch of Drupal 8.0, we have successfully launched a new minor release on schedule every six months. I'm very proud of the community for this achievement. Prior to Drupal 8, most significant new features were only added in major releases like Drupal 6 or Drupal 7. Thanks to our new release cadence we now consistently and predictably ship great new features twice a year in minor releases (e.g. Drupal 8.6 comes with many new features).

However, only the most recent minor release has been actively supported for both bug fixes and security coverage. With the release of each new minor version, we gave a one-month window to upgrade to the new minor. In order to give site owners time to upgrade, we would not disclose security issues with the previous minor release during that one-month window.

Old Drupal 8 security policy for minor releases

Illustration of the security policy since the launch of Drupal 8.0 for minor releases, demonstrating that previous minor releases receive one month of security coverage. Source: Drupal.org issue #2909665: Extend security support to cover the previous minor version of Drupal and Drupal Europe DriesNote.

Over the past three years, we have learned that users find it challenging to update to the latest minor in one month. Drupal's minor updates can include dependency updates, internal API changes, or features being transitioned from contributed modules to core. It takes time for site owners to prepare and test these types of changes, and a window of one month to upgrade isn't always enough.

At DrupalCon Nashville we declared that we wanted to extend security coverage for minor releases. Throughout 2018, Drupal 8 release managers quietly conducted a trial. You may have noticed that we had several security releases against previous minor releases this year. This trial helped us understand the impact to the release process and learn what additional work remained ahead. You can read about the results of the trial at #2909665: Extend security support to cover the previous minor version of Drupal.

I'm pleased to share that the trial was a success! As a result, we have extended the security coverage of minor releases to six months. Instead of one month, site owners now have six months to upgrade between minor releases. It gives teams time to plan, prepare and test updates. Releases will have six months of normal bug fix support followed by six months of security coverage, for a total lifetime of one year. This is a huge win for Drupal site owners.

New Drupal 8 security policy for minor releases

Illustration of the new security policy for minor releases, demonstrating that the security coverage for minor releases is extended to six months. Source: Drupal.org issue #2909665: Extend security support to cover the previous minor version of Drupal and the Drupal Europe DriesNote.

It's important to note that this new policy only applies to Drupal 8 core starting with Drupal 8.5, and only applies to security issues. Non-security bug fixes will still only be committed to the actively supported release.

While the new policy will provide extended security coverage for Drupal 8.5.x, site owners will need to update to an upcoming release of Drupal 8.5 to be correctly notified about their security coverage.

Next steps

We still have some user experience issues we'd like to address around how site owners are alerted of a security update. We have not yet handled all of the potential edge cases, and we want to be very clear about the potential actions to take when updating.

We also know module developers may need to declare that a release of their project only works against specific versions of Drupal core. Resolving outstanding issues around semantic versioning support for contrib and module version dependency definitions will help developers of contributed projects better support this policy. If you'd like to get involved in the remaining work, the policy and roadmap issue on Drupal.org is a great place to find related issues and see what work is remaining.

Special thanks to Jess and Jeff Beeman for co-authoring this post.

Sep 13 2018
Sep 13

Each month, we revisit out top Drupal blog posts of the month, giving you the chance to check out some of our favourites. Let’s look at the top blog posts from August 2018.

First one on the list is The Marketer’s Guide to Drupal 8: 10 Reasons Enterprise Marketers Choose Drupal by Ally DelGuidice-Bove from Mediacurrent. When it comes to implementing marketing processes, it’s important to have a system that promotes ease and efficiency, and Drupal provides a variety of integrated tools offering just that. Ally made a list of reasons why enterprise marketers adopt Drupal so well.

We continue our list with Pros and Cons with Docker by Mark Labrecque from Affinity Bridge. Mark has been using Docker for more than a year now. In this blog post, he explains what he sees as the pros and cons of the Docker. 

The third spot is reserved for a blog post 6 Popular CRM Platforms & How to Integrate Them with Your Drupal Site by Nikki Smith from Sevaa Group. Nikki first explains what CRM is, then introduces us to 6 different CRM Platforms, and tells us how to integrate them with Drupal. 

Let’s continue with Drupal Admin UX Study: the Survey Results Are In! by Suzanne Dergacheva from Evolving Web. Suzanne is a part of an Admin UX User Study group in the Drupal community. They are doing research to help Drupal admin UI to improve. So far, there are 260 participants, and the first results are quite interesting.  

computer

Our fifth choice is Caring about webform accessibility by Jacob Rockowitz. We often don't understand how people with disabilities use our application, so we forget about accessibility. Because more accessible your website is, the more users reach out and engage. Jacob introduces us with tools that show us obvious problems. Let's all make the accessibility optimization a part of the web development process. 

The sixth blog post we would like to highlight is Early Rendering: A Lesson in Debugging Drupal 8 by Matt Oliveira from Lullabot. Matt came across an error on his client’s site, and in this blog post he shows us the issue and what did he learn while solving it. 

The next one is The Path to Migration by Cindy McCourt from Promet Source. Cindy is diving deep into migration, answering the questions like: how can a new site look after a migration, what are triggers for a project migration, what paths can be taken, and how to create the right team. 

Eight one in a row is a Progressive Decoupling With Drupal 8 and ReactJS by Tom Mount from Eastern Standard. Tom explains what he has learned during the Admission site for UPenn. He takes us through the background of a project and explains how we arrived at the decision to implement a progressively decoupled portion of the site.

And we conclude our list with a blog post Null Users and System Users in Drupal by Oliver Davies. Oliver has developed two new modules that introduce new types of users in Drupal 8. System users and Null users can be used for development and administrative purposes to perform tasks on Drupal sites, such as performing actions based on an API request, or for sending an internal site message.  Thank you, Oliver, for your contribution to Drupal. 

These are our top blogs from August… We will be collecting best Drupal blog posts in September too. Stay tuned.   

Sep 13 2018
Sep 13

A sportsperson is rewarded for his anticipatory calls which he does to judge the next move of his opponent. When done right, it can make a world of difference in deciding the fate between a marvellous triumph and a drudging defeat. A business enterprise is not much different which has to rely on its decision-making whenever it has to choose between technologies for their projects. Choosing Drupal for your next web development project can be the most significant decision for your organisation.

Illustration showing a bulb being picked up through a machine from the stack


No matter where you are today, your next step is crucial to take you to the leader’s position of the table or even slide down the bottom of the bottle. And when it comes to projects involving web development, selecting the right CMS in the incipient stage becomes really important. So, how can you transform the whole digital experience of your next project by choosing Drupal as the content store?

Why opt for Drupal?

As a technology professional, you seek for a reliable, safe and flexible web content management for creating the features that you want for your project and leave out weighty features. Drupal as an out-of-the-box web content management tool and a customisable platform allows business and technology leaders to power digital innovation.

Every time you come up with a significant business goal of achieving preeminence and ponder over Drupal’s ability in building what you want, the answer is nearly always ‘“yes”. With Drupal’s horizonless potential accompanied by native functionalities and module extensions, there is no limit to imagining what you can do with disrupting technologies without deranging your business.

Security

With a proven record of being the most secure CMS and application framework, Drupal beats the big players in the CMS market by standing resilient to critical internet vulnerabilities. Thanks to the Drupal Security Team for actively validating and responding to security issues.

Bar graph showing the statistics on Drupal securitySource: Sucuri

You can enable a secure access to your Drupal site as it has the in-built support for salting and repeatedly hashing account passwords when they are stored in the database.

It also supports the enforcement of strong password policies, industry-standard authentication practices, session limits, single sign-on systems.

Drupal offers granular user access control to give administrators full control over who gets to see and who gets to modify different parts of a site.

It is possible to configure Drupal for firm database encryption in the top-of-the-line security applications.

Drupal’s Form API ensures data validation thereby preventing XSS, CSRF, and other malicious data entry.

Drupal limits the number of times login attempts are made from a single IP address over a predefined time period. This helps in preventing brute-force password attacks.

Drupal’s multi-layered cache architecture helps in mitigating Denial of Service (DoS) attacks and makes it the best CMS for some of the world’s highest traffic websites.

Notably, the functionalities that Drupal has to offer addresses all of the top 10 security risks of Open Web Application Security Project (OWASP).

No wonder, a report from Sucuri shows that Drupal is the best-security focussed CMS when compared to the likes of Wordpress and Joomla. If internet security is one of your top priorities, Drupal is your best bet.

Scalability

If you aspire your site to be amongst the busiest or if you already are so popular and are trying to cope with a colossal amount of traffic to your site content, Drupal can scale with your needs.

Infographic showing the statistics on the scalability of NASA website with a tablet showing the site of NASANASA, powered by Drupal, manages peak loads efficiently including 2017 Total Solar Eclipse Coverage
Source: Mobomo

The scalability that Drupal provides supports the most content-rich sites and experiences. No matter if you have one or over a thousand content contributors, Drupal can manage a voluminous amount of visitors, content, and Drupal users.

Content Workflow

Drupal’s magnificent tools make it easy for the content authors to create and publish content on the site. Authentication and permissions bring in efficacy in the editorial workflow and previews show how exactly your content will look on different devices.

Your content team can assess, edit and approve content from mobile devices anytime and anywhere.

Drupal also allows the creation of content with a WYSIWYG editor. You can even perform in-place authoring where you just have to browse the page, click on the content and edit right there. All the alterations and revisions are trackable.

You can see what stage your content is in - from creation to review to publication - and it helps in handling user roles and actions automatically.

Drupal administration interface showing the content state as unpublished


Content tagging and taxonomy is a great feature of Drupal where it helps in defining content elements, tag content on the basis of attributes, create a relevant taxonomy for content to make it searchable.

To make content authoring as easy as it can be, Drupal can be a lovely choice for your next project.

Multilingual

Out-of-the-box support for language handling helps you to deliver localised digital experiences thereby saving time and money. Drupal 8 core comes with 4 core modules for enabling translation of every content on the site.

Homepage of Al Jazeera in Arabic languageAl Jazeera Media Network, built on Drupal 8, produces news content seamlessly in English and Arabic languages.

Not only does Drupal give configuration and content translation workflows, it also gives an interface language of administrators and content producers. Thus, it enables the business organisations to speak in the language of their customers, 

Without the need for any additional components, Drupal 8 can be installed in over 90+ languages.

Once you install Drupal, languages packages can be safely and automatically downloaded and implemented without hampering your customised translations.

So, if you are in the need of quickly building customised sites in any language of your choice or an intricate multilingual web application with dynamic, language-based displays, Drupal is a praiseworthy option.

Content-as-a-service

If you want to allow your front-end developers to create engaging customer experiences, Drupal’s content-as-a-service approach lets you think outside the page-based mentality.

Flowchart showing the workflow of Coupled and Decoupled Drupal with rectangular boxes


Drupal’s CaaS solution helps in delivering infinitely reusable, future-proof content by decoupling the back and front ends where-ever useful. Separating the backend from the frontend also helps the frontend developers change the look and experience of the sites in a snap.

Moreover, front developers can build better experiences with Drupal’s presentation-neutral content and RESTful API and leverage tools like Angular, Ember, Backbone and more.

Ingestion of content from third-party content, for instance, from aggregators and syndicators, to bring content into your Drupal environment is possible which can be pushed to any channel.

With Drupa’s CaaS capability, content is easily consumed by other websites and application that you choose.

Web content is no longer pushed to a web page to viewed through a desktop browser. Go for Drupal’s content-as-a-service approach if you want content flexibility in your pursuit of delivering an ultimate digital experience.

Mobile-responsive

In this day and age, almost everything is happening on-the-go. Website development is not far behind.

Infographics showing the statistics on mobile responsive sitesSource: ArachnidWorks

Drupal enables the development of responsive sites and web applications to deliver optimal visitor experiences to the online visitors.

By supporting the best practices of responsive web design approach, Drupal helps in ensuring an impeccable content experience to the users every time and on every mobile device.

Pick Drupal for mobile-friendly and fully responsive sites and web apps.

Speed

Business projects do not end in perfection through dilatory strategies. If you are a digital marketer or anyone looking to incorporate celerity in business workflow, you know how the word ‘speed’ matters.

Drupal’s pliable platform allows digital marketers and developers to surmount the logjam and delay thereby running a steadfast and agile team.

For ensuring a continuous delivery of web development projects, Drupal can be a wonderful option.

Third-party integration

Outside of Drupal, there are plenty of great technologies that can be an astounding asset to your website.

Drupal integrates seamlessly with a variety of marketing technologies and business applications. This allows you to leverage the merits of the best set of tools out there outside of Drupal.

Drupal’s API-first approach helps in connecting content to other sites and applications thereby making content more vibrant and powerful.

If you are someone who wants to flex with the awesome third-party tools, Drupal gives you the liberty to do that flexibly.

Content architecture

The flexibility that Drupal has to offer for creating the right content architecture is immense and that shows in its ability to enable that using the Admin Interface or even do it programmatically.

You can exhibit apt content for each context with the help of stupendous display mode tools and Views. It constitutes a wide array of media types.

It provides a reposeful user experience by offering customisable menus and creating paths to content across several devices.

Drupal is the answer for the flexibility in the content architecture.

Multisite

When you have a plethora of business, ventures, it calls for multiple websites for different segments of your digital firm.

Drupal allows you to administer multisite setup across your enterprise, brands, geographies and promotional campaigns on a centralised platform. This helps in providing a faster and simple way of creating and deploying multisite ecosystem.

Business-driven

Nobody likes to be dictated how to do things in a business. And Drupal understands that. It does things as the business demands.

It helps in creating a solution that supports your business requirements. Thus, it paves the foundation for boundless solutions.

Drupal is your sure-shot choice to sway things your way as your digital business demands.

Perfect tech stack

Drupal comes with a modern LAMP technology stack including Linux, Apache, MySQL, and PHP to meet the requirements of fast-paced, agile and flexible organisations who are committed to building a next-generation digital platform.

Drupal is your perfect CMS with a strong stack foundation.

Robust community presence

Thousands of organisations build solutions with Drupal and in the process build Drupal itself. That’s the beauty of being an open source software.

From design to system architecture, Drupal experts make their valuable contributions back to the community. The Drupal community across the globe shares its knowledge on the right ways of doing things.

If you have a question, just drop in your queries and the active community will always have someone waiting with an answer.

Lead by modern web standards, you can create innovation for clients, the community and the world.

Big players

Business leaders like Tesla Motors, Pfizer, the Government of Australia, Grammy, Rainforest Alliance, The Economist, Oxford University and many more across the planet are powered by Drupal.

So, when it comes to the question of who is using Drupal, there is no dearth of big names in the tech industry. Join the league!

What value does it bring to your business?

The Drupal Values and Principles emphasise the culture and behaviour that each member of the community has to adhere to. These principles guide both the technical and non-technical decision-makings and show how contributors and thought leaders can support the Drupal community and the project.

The illustration below shows the values and the principles that Drupal has been offering over the years to the business enterprises around the world.

Illustration showing columns of values and principles of DrupalSource: Dries Buytaert’s blog

Creating impact

Drupal values have been instrumental in creating the sort of impact to the business enterprises that serve a great purpose in their growth. It has been a force to reckon with when it comes to developing software that is easy, accessible and secure to be leveraged by everyone. Choose Drupal for the impact performance!

Fostering togetherness

Drupal has been committed to building a learning environment thereby fostering togetherness. It does so by putting everyone in the community on the pedestal through collaborative decision-making, provision of encouragement to others to get them involved. In this pursuit, it lets everyone to take leadership challenge in order to take the community forward. Drupal is your go-to option for a collaborative business workflow.

Targeting excellency

In order to attain excellence in a web development project, Drupal allows you to perpetually reassess and embrace the changes as it comes making your project as great as it can be. Go for Drupal if excelling in your project endeavours is your agenda.

Better treatment

Drupal community strives to negate any sort of intolerance towards others. It is committed to understand each other well and give constructive animadversion thereby staying optimistic. It is a wise decision to opt for a CMS that professes to treat others with dignity and respect.

Relishing what you do

Who does not want to have fun while working on a project? Drupal firmly stands by its perspective to let its community enjoy while tinkering and innovating something unique with Drupal. Want the amalgam of innovation and fun to be incorporated into your project? Drupal is the answer.

What’s new about Drupal?

September 5, 2018 marked the commencement of a new era in this digital age. Being a pioneering content store, Drupal community, in its efforts towards making Drupal more and more wonderful, unveiled a major upgrade to Drupal 8.

Drupal 8.6, the new upgrade, comes with an improved user experience for the digital marketing and the content editing teams in addition to simpler installation and more stable upgrades for technical teams.

Considering Drupal can lend your content authors a whole new experience. This new upgrade has added support for remote media types that streamlines the embedding of Youtube or Vimeo content in your videos.

Moreover, it has made rapid strides with the quotient of ease of use. For instance, Workspaces, experimental Drupal module, offers sophisticated content staging capabilities.

The Layout Builder, another experimental Drupal module, is proving to be the saviour for site builders by allowing the creation of layouts with dynamic sections, thus, creating more opportunities for custom layouts.

Before the release of Drupal 8.6, downloading and installing it was an intricate and time-intensive process. But now, you can have an out-of-the-box experience by installing Drupal in minutes using the new Umami demo profile. This is especially great for showing enormous capabilities of Drupal right out of the box to the prospective clients.

Website of Umami food magazine with images of food on a plate and spoons


These are some of the highlights that act as the stepping stone for a whole lot of exciting stuff that is about to transpire in the Drupal platform. Drupal 8.6 is stupendous and the road ahead looks sparklingly bright.

The Bottom Line

While choosing the best platform for the governing the cornucopia of content that your site possesses may seem like an arduous task and why not? After all, it is your public-facing website that needs to be built with the utmost care.

Amidst the growing demands of businesses to improve their workflow with the incorporation of emerging technologies, Drupal has been able to stay relevant and useful and is still growing to be even better.

Selecting Drupal as the CMS of choice can act as the harbinger of success for your future endeavours. Opensense Labs has been cultivating a robust culture with its partners and is always ready to assist you to build a great digital experience with Drupal development.

Contact us at [email protected] for enabling a digital transformation of your business using Drupal.

Sep 13 2018
Sep 13

Mustapha tells us about the third day's highlights in Darmstadt, Germany, and some exciting announcements!

Drupal Europe 2018 - Wednesday 

The third day of Drupal Europe was a big day, we had the prenote and the Driesnote with some exciting announcements, the group photo, and a lot of interesting sessions.

The Prenote:

Our big day started at 8:15 with the prenote, which is very important because it shows you how awesome this community is. We were singing together and laughing very loudly about some "geek" jokes which would seem strange to others but not to us because we are living those jokes each day. The prenote is important because it makes you feel that you're not lonely, but you have all this family from around the world.

prenote

Driesnote:

At every Drupal conference, Dries Buytaert, the leader of the Drupal project, shares updates on the current state of Drupal and makes some announcements on the way forward.

Dries

He firstly spoke about the Drupal 8.6 release which has some great content management improvements, which can be discovered here. Then the announcement party started and here are some of the highlights: 

- The adoption of React and JSON API to build a new decoupled administration UI.

- Drupal 9 will be released in 2020.

- Drupal 7 will have an end of life by 2021.

- Drupal 8 will too have an end of life by 2021, but it will be an easy upgrade to Drupal 9.

- Drupal.org <3 Gitlab: drupal.org code will be moved to Gitlab.

- There will be a Drupalcon next year organized by the Drupal Association and it will be held in Amsterdam.

Amsterdam

After those exciting announcements, everybody went outside the Darmstadtium for the Group Photo which was taken by our own, Josef Dabernig.

Talking about Josef, he had a great a session entitled "Upgrading vs. Upcycling - How to stay ahead of the curve". It covered the life cycle of a Drupal project, how to audit your Drupal website, and which improvements you can propose to clients.

Josef

Last but not least, after such an exciting day, we went to do our Amazeeng "Team Dinner" and finished off our big day with lots of fun.

Team dinner

Thursday's Program: 

Thursday's speakers:

Sep 13 2018
Sep 13
We’re number (two-hundred-and-forty) one!  Earlier today, Canadian Business and Maclean’s released its 30th annual Growth 500 list, and we’re proud to announce that we’ve made the list for the second, consecutive year. Digital Echidna ranks as no.…

Pages

About Drupal Sun

Drupal Sun is an Evolving Web project. It allows you to:

  • Do full-text search on all the articles in Drupal Planet (thanks to Apache Solr)
  • Facet based on tags, author, or feed
  • Flip through articles quickly (with j/k or arrow keys) to find what you're interested in
  • View the entire article text inline, or in the context of the site where it was created

See the blog post at Evolving Web

Evolving Web