Mediacurrent: Setting up CSS Modules + Sass in a Gatsby Website

Planet Drupal - Tue, 2020/10/27 - 6:11pm

For many years styling websites with CSS has been pretty standard. A CSS stylesheet exists somewhere in your project which provides styles for your pages or components. Even with the introduction of CSS preprocessors like Sass, Less, Stylus, and PostCSS to mention a few, the ultimate result is for stylesheets to serve styles to your pages and website.  

With the introduction of JavaScript frameworks such as React, NextJS, and others, the approaches for writing and serving CSS styles have become more complex and at times controversial. Things like CSS-in-JS ( defines this as “a pattern where CSS is composed using JavaScript instead of defined in external files"), can make some people question whether we are getting ourselves in trouble and whether we will regret going in this direction. It wouldn’t be the first time we find ourselves undoing practices we have followed for years because we realized there was a better way.

In GatsbyJS, a library of React, we can use different methods for styling a website.  Some of these approaches include:

  • Plain CSS
  • Inline styles
  • Styled Components
  • CSS Modules
  • Others

In most cases, people who lack the in-depth knowledge of CSS will opt for the easier way possible to style a website.  This is not always the best way to go about it, but unfortunately, it is the reality.  As someone who has worked with CSS for many years, I could technically pick any of the approaches above and accomplish my goal of styling a website, but I see issues with some of those practices and prefer to use an approach that provides flexibility, control, and best practices.

Choosing a Styling Method 

Working for an agency where we build websites for clients of all sizes, many times the method we choose for doing something depends on the client’s preferences or skill level of their team.  Meaning that we want to build a website that a client could take over and maintain on their own after our engagement with the client has scaled down.  So even if I have a personal preference but the client has no experience or desire to work with that approach, I would need to provide a way for the client to work with a system or approach that may be more comfortable to them.

The one thing to keep in mind when choosing a method for styling your websites, Gatsby or otherwise, is that at the end of the day, we are producing plain CSS and as such, it should be well-written, and easy to maintain and scale. I am a fan of keeping styles simple, flat, and to a minimum. I don’t see the point of using over-engineered methods that complicate the most simple task.

CSS Modules

My approach of choice for styling React or Gatsby websites is CSS Modules because it most closely resembles the traditional way of styling websites I have grown accustomed to. As I alluded to before, my ultimate goal is to write proper CSS, following best practices, while leveraging styles scope, performance, and scalability. CSS Modules allows me to do all these things while providing an environment I am familiar with. I am not against learning new ways of doing things (I welcome them), but if new approaches don’t offer significant benefits, I don’t see the need of complicating my life and that of clients who will interact with my code.

In a typical Gatsby website, CSS Modules works out of the box without any special configuration. You can create any CSS files in your project, import them into the components you are working with and your styles will work. This is great and can get you very far if you are working with a simple website. However, this only works with plain CSS and not Sass. I personally like Sass because it provides features that are currently not available in CSS. Things like Mixins and nesting to mention a few. I will use Sass and SCSS interchangeably in this post to refer to the preprocessing process of compiling SCSS into plain CSS code.

Add Sass to Your Gatsby Website

Adding Sass to a Gatsby website is relatively easy. It’s a two-step process that includes installing a Gatsby plugin and adding a line of code to gatsby-config.js. Let’s do this now:

  1. While In your Gatsby project root directory, run the following command to install the gatsby-plugin-sass and node-sass plugins:

    npm install node-sass gatsby-plugin-sass
    Gatsby-plugin-sass has a dependency of node-sass and therefore we need to install both.
  2. Edit gatsby-config.js (located in the root of you gatsby project), by adding the new plugin to the plugins array:

    plugins: [`gatsby-plugin-sass`]
    If you already have other plugins in place, you can add each new plugin in a new line within the array.

That’s it! Now Sass is available on your site.

Updating CSS Modules to use Sass

Now that we have Sass available, the last thing to do is to update CSS Modules to use Sass versus plain CSS. This is a two-step process:

  1. Rename any existing .css files to use .scss
  2. Update any imports of these files to also use .scss

Now you can take advantage of CSS Modules and Sass for writing great styles. Let’s go over a quick example of how CSS Modules works.

Using CSS Modules and Sass in Gatsby

Consider the following HTML/JS in your Gatsby Component (hero):

import React from 'react'; import PropTypes from 'prop-types'; import Image from 'gatsby-image'; import Heading from '../Heading'; import Link from '../Link'; import {fluidImage} from '../../global/js/customPropTypes'; const Hero = ({ title, image, body, path }) => { return ( <section> <div> <Image fluid={image} /> </div> <div> <Heading> {title} </Heading> <div> {body} </div> <Link to={path}>Learn more</Link> </div> </section> ); }; export default Hero; Hero.propTypes = { title: PropTypes.string, body: PropTypes.string, image: fluidImage, path: PropTypes.string };

Styling the Hero component above with CSS Modules will require we create a stylesheet for the Hero. Assuming you have a Hero folder inside components, which has an index.js for the component’s markup and JavaScript, create a file called hero.scss with the following code:

.hero { background-color:$color-white; position: relative; } .media { img { display: block; height: auto; max-width: 100%; } } .content { left: 50%; position: absolute; transform: translate(-50%, -50%); top: 50%; } .title { color: $color-secondary; }

And finally, you would update index.js by first importing the hero’s stylesheet as follows:

import styles from './hero.scss';

Then adding the respective CSS classes to each of the HTML elements in the Hero component. The end result of index.js would look like this:

import React from 'react'; import PropTypes from 'prop-types'; import Image from 'gatsby-image'; import Heading from '../Heading'; import Link from '../Link'; import styles from './hero.scss'; import {fluidImage} from '../../global/js/customPropTypes'; const Hero = ({ title, image, body, path }) => { return ( <section className={styles.hero}> <div className={}> <Image fluid={image}></Image> </div> <div className={styles.content}> <Heading classes={styles.title} headingLevel={1}> {title} </Heading> <div className={styles.body}> {body} </div> <Link to={path}>Read the full article</Link> </div> </section> ); }; export default Hero; Hero.propTypes = { title: PropTypes.string, body: PropTypes.string, image: fluidImage, path: PropTypes.string };
  • When we imported the Hero styles into the component we used styles as the namespace in the import.
  • To apply each of the CSS classes found in hero.scss to the markup in index.js we are using the className attribute since class is a reserved keyword in React/Gatsby.
  • Then in curly brackets we apply each class by prefixing them with styles. For example:  <section className={styles.hero}> <div className={}> … </section>


If you render this component in the browser, what you will see as a result when you inspect the code is something similar to:

  • Main things to note from the image above are the CSS classes added after css-modules--. These are the classes we created in hero.scss.
  • The end of the class names (i.e. akrigl, woitn, w95ls9), are dynamic strings created by CSS Modules which ensure they are unique CSS classes.  This prevents issues of regression and styles from leaking into other parts of your website.
  • CSS Modules restricts the scope of its styles to only the component they are written for.


In closing

I like CSS Modules because it provides a familiar approach to working with Sass similar to that of a traditional Sass project. This works well with clients who are not well-versed in React or Gatsby but still want to be able to update styles.


Lullabot: An Accessibility Checklist for Your Website: Part 2

Planet Drupal - Tue, 2020/10/27 - 4:12pm

This article is part 2 of a series that outlines key points to consider when designing and building more accessible websites.

It takes a coordinated team effort in making sure a site is accessible. Whether it's reviewing your design for color contrast, conducting usability testing to assure you address any usability issues, or developing for readability and proper text spacing, great teamwork makes for great accessibility.


Evolving Web: Building Business-Friendly Intranets with Drupal [White Paper]

Planet Drupal - Tue, 2020/10/27 - 3:10pm

TL;DR: If you're planning an intranet project, you should read our new white paper. It's called Building Business-Friendly Intranets with Drupal, and you can download a free copy right here.

Love it or loathe it, having a centralized intranet portal is a must-have for most organizations—especially when your users need the ability to collaborate in real time with other team members in different locations, as is the case for so many of us these days.

We dislike the in these trying times cliché as much as anyone, but current circumstances have undeniably sparked renewed interest in intranet solutions among organizations of all sizes and scopes. With that in mind, our team felt it was a perfect time to put together a decision-making resource for businesses that are currently considering which technology they should use to power their portal.

Because when it comes to corporate intranets, there's no one-size-fits-all.

Businesses and institutions face a dizzying variety of unique, specific challenges that can be addressed with different intranet styles and approaches. Some of those challenges include:

  • The need to work and share content securely with external collaborators, suppliers, or clients
  • Managing large volumes of content and data that need to be easily searchable and accessible
  • Unifying a diverse, decentralized workforce
  • Juggling legacy technologies, closed-source ecosystems (cough, SharePoint, cough), licensing fees, and platform updates
  • Poor user adoption of existing intranet (often caused by a subpar user experience)

What this all means, in a nutshell, is that the key ingredient for a successful intranet project—whether you're planning a migration, a redesign, or a brand new build—is flexibility. And that's exactly where open-source solutions such as Drupal truly shine.

The Evolving Web team has worked on intranet projects of all shapes and sizes, and we've compiled some of our top insights—backed by real-life case studies—in a brand-new white paper.

📝 Download your copy now!

What's inside?
  • Drupal backgrounder. What is Drupal, anyway? Get the quick-and-dirty overview.
  • Drupal intranet examples. Real-life Drupal intranet case studies, including McGill University's graduate application platform
  • Features and capabilities. An in-depth look at what businesses can build for their intranet with Drupal
  • First-hand knowledge. Valuable intranet design tips and insights from our highly experienced team
  • And more!

Get your free copy of Building Business-Friendly Intranets with Drupal today (and don't hesitate to reach out if you'd like to continue the conversation).

+ more awesome articles by Evolving Web

Specbee: What To Expect From Drupal 9.1

Planet Drupal - Tue, 2020/10/27 - 1:00pm
What To Expect From Drupal 9.1 Malabya Tiwari 27 Oct, 2020 Top 10 best practices for designing a perfect UX for your mobile app

Drupal 9.1 is set to release in December 2020 but will enter the alpha phase this month, Oct 2020 and will have a beta release in November 2020. The minor version update of Drupal will see more deprecations and updating third party packages. However, there are 2 notable changes which will be happening in the Drupal 9.1 release.


A New Default Drupal Theme

Olivero is the new Drupal theme which is in the experimental state. The default theme Bartik has been around since 2011 and has served well over the years. After the Drupal 8 release, a new version of Bartik was released which was responsive out of the box. However, with the change in web design trends, the Bartik theme seems outdated compared to the prowess of Drupal 9 which needed a new modern & clean theme. This is also necessary for evaluators of Drupal to have a good first impression then they assess Drupal for their next big project.

The Olivero theme is added to the Drupal core and will be shipped with Drupal 9.1.0 as an experimental theme. The maintainers are planning to have a stable release and make it the default theme swapping out Bartik in the next minor release - Drupal 9.2

Native Image Lazy Load

One of the biggest factors for a successful website is how performant the site is. Lazy-loading of page elements, especially images, is a powerful way to increase perceived performance, reduce time-to-first-render, and reduce user friction on the web.

Images are the most requested assets during a page load and takes up more bandwidth than other resources. Lazy loading images can be done using JavaScript plugins or using Intersection Observers. In Drupal there are contributed modules available which does the job. However, these solutions are not native and often requires some complex setup and configurations to achieve a proper lazy loading of images.

The html 'loading' attribute used by Chrome platform which implies to simple add a loading="lazy" to the images to defer loading of the resource until it reaches a calculated distance from the viewport.

This is now added to all images out of the box and will be available in the Drupal 9.1.0 release. Supports any Chromium based browser like Chrome, Edge, Opera, and Firefox (with support for Safari still in progress). This will highly impact the perceived performance of Drupal sites and combined with other mechanisms like Big Pipe, it will greatly improve the performance.

Updated to PHPUnit 9

Another update which Drupal 9.1.0 will receive is for developers. The third-party dependency, PHPUnit which powers solid the testing framework used in Drupal will be updated to the latest version while keeping the support of 8.4 for backward compatibility. This update was added to make Drupal 9 ready for PHP 8 which will be releasing on November 26th, 2020. 

Other changes which are included are mostly deprecation of methods and introducing overridable services. A full list of change records can be found here.

Although the Drupal 9 release was huge, there were no significant changes made other than cleaning up of deprecated code. Drupal 9.1 is the first release with new and exciting features to look forward to. 
Want to create your next website on Drupal 9? Contact our Drupal experts today

Drupal Planet Shefali ShettyApr 05, 2017 Subscribe For Our Newsletter And Stay Updated Subscribe

Leave us a Comment

  Shefali ShettyApr 05, 2017 Recent Posts Image What To Expect From Drupal 9.1 Image All about Progressive Web Apps and Implementing it in Drupal 9 Image Business Process Automation with Drupal – Top Drupal 8 (and 9) modules and distributions Want to extract the maximum out of Drupal? TALK TO US Featured Success Stories

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


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


Discover how a Drupal powered internal portal encouraged the sellers at Flipkart to obtain the latest insights with respect to a particular domain.


Joachim's blog: Different ways to make entity bundles

Planet Drupal - Tue, 2020/10/27 - 12:52pm

A lot of the time, a custom content entity type only needs a single bundle: all the entities of this type have the same structure. But there are times where they need to vary, typically to have different fields, while still being the same type. This is where entity bundles come in.

Bundles are to a custom entity type what node types are to the node entity type. They could be called sub-types instead (and there is a long-running core issue to rename them to this; I'd say go help but I'm not sure what can be done to move it forward), but the name 'bundle' has stuck because initially the concept was just about different 'bundles of fields', and then the name ended up being applied across the whole entity system.

History lesson over; how do you define bundles on your entity type? Well there are several ways, and of course they each have their use cases.

And of course, Module Builder can help generate your code, whichever of these methods you use.

Quick and simple: hardcode

The simplest way to do anything is to hardcode it. If you have a fixed number of bundles that aren't going to change over time, or at least so rarely that requiring a code deployment to change them is acceptable, then you can simply define the bundles in code. The way to do this is with a hook (though there's a core issue -- which I filed -- to allow these to be defined in a method on the entity class).

Here's how you'd define your hardcoded bundles:

/** * Implements hook_entity_bundle_info(). */ function mymodule_entity_bundle_info() { $bundles['my_entity_type'] = [ 'bundle_alpha_' => [ 'label' => t('Alpha'), 'description' => t('Represents an alpha entity.') ], 'bundle_beta_' => [ 'label' => t('Beta'), 'description' => t('Represents a beta entity.') ], ]; return $bundles; }

The machine names of the bundles (which are used as the bundle field values, and in field names, admin paths, and so on) are the keys of the array. The labels are used in UI messages and page titles. The descriptions are used on the 'Add entity' page's list of bundles.

Classic: bundle entity type

The way Drupal core does bundles is with a bundle entity type. In addition to the content entity type you want to have bundles, there is also a config entity type, called the 'bundle entity type'. Each single entity of the bundle entity type defines a bundle of the content entity type. So for example, a single node type entity called 'page' defines the 'page' node type; a single taxonomy vocabulary entity called 'tags' defines the 'tags' taxonomy term type.

This is great if you want extensibility, and you want the bundles to be configurable by site admins in the UI rather than developers. The downside is that it's a lot of extra code, as there's a whole second entity type to define.

Very little glue is required between the two entity types, though. They basically each need to reference the other in their entity type annotations:

The content entity type needs:

* bundle_entity_type = "my_entity_type_bundle",

and the bundle entity needs:

* bundle_of = "my_entity_type",

and the bundle entity class should inherit from \Drupal\Core\Config\Entity\ConfigEntityBundleBase.

Per-bundle functionality: plugins as bundles

This third method needs more than just Drupal core: it's a technique provided by Entity module.

Here, you define a plugin type (an annotation plugin type, rather than YAML), and each plugin of that type corresponds to a bundle. This means you need a whole class for each bundle, which seems like a lot of code compared to the hook technique, but there are cases where that's what you want.

First, because Entity module's framework for this allows each plugin class to define different fields for each bundle. These so-called bundle fields are installed in the same way as entity base fields, but are only on one bundle. This gives you the diversification of per-bundle fields that you get with config fields, but with the definition of the fields in your code where it's easier to maintain.

Second, because in your plugin class you can code different behaviours for different bundles of your entity type. Suppose you want the entity label to be slightly different. No problem, in your entity class simply hand over to the bundle:

class PluginAlpha { public function label() { $bundle_plugin = \Drupal::service('plugin.manager.my_plugin_type') return $bundle_plugin->label($this); } }

Add a label() method to the plugin classes, and you can specialise the behaviour for each bundle. If you want to have behaviour that's grouped across more than one plugin, one way to do it is to add properties to your plugin type's annotation, and then implement the functionality in the plugin base class with a conditional on the value in the plugin's definition.

/** * @MyPluginType( * id = "plugin_alpha", * label = @Translation("Alpha"), * label_handling = "combolulate" class MyPluginBase { public function label() { switch ($this->getPluginDefinition()['floopiness']) { case 'combolulate': // Return the combolulated label. } } }

For a plugin type to be used as entity bundles, the plugins need to implement \Drupal\entity\BundlePlugin\BundlePluginInterface, and your entity type needs to declare the plugin:

* bundle_plugin_type = "my_plugin_type",

Here, the string 'my_plugin_type' is the part of the plugin manager's service name that comes after the 'plugin.manager' prefix. (The plugin system unfortunately doesn't have a standard concept of a plugin type's name, but this is informally what is used in various places such as Entity module and Commerce.)

The bundle plugin technique is well-suited to entities that are used as 'machinery' in some way, rather than content. For example, in Commerce License, each bundle of the license entity is a plugin which provides the behaviour that's specific to that type of license.

One thing to note on this technique: if you're writing kernel tests, you'll need to manually install the bundle plugins for them to exist in the test. See the tests in Entity module for an example.

These three techniques for bundles each have their advantages, so it's not unusual to find all three in use in a single project codebase. It's a question of which is best for a particular entity type.

Categories: Reflecting on Drupal Slack

Planet Drupal - Tue, 2020/10/27 - 11:09am

Over the last year or so, I've got quite engaged with Drupal slack. I've loitered in channels like #d9readiness and #config, discussed issues with members of the security team, and asked questions to module maintainers (and received answers!). But most of all, I've helped people out in the #support channel. This has been an interesting experience in many ways, so I thought I'd share my reflections. The Drupal slack workspace is intended for the community, so if you're reading this - it's probably for you too. Hopefully my thoughts might help prepare you to use it as an effective tool.

Ultimately, I've got stuck in as a way to contribute to the Drupal community in a new way as part of our CM contribution challenge. That has given me motivation to give more than I get, but I've been pleasantly surprised how much I - and ComputerMinds - have benefitted from being part of Drupal slack. When we've been unsure about the status of a module or the way forward with an issue, it's been great to be able to reach out to exactly the right people. Especially in the current climate that limits our ability to meet people in-person (e.g. at Drupalcon). So, thank you to those people that have helped me :-) We've even received sponsorship to work on some module issues after discussion on slack - we ended up becoming responsible for releasing security fixes for the Commerce Ingenico project after it had been shut down due to vulnerabilities. That's a win for us, and it's a win for the community, who can use that module once again.

Slack has benefits, but also drawbacks, as it is yet another system clamouring for attention in a crowded digital world. So it's important to use it appropriately for the good of the community, but also wisely for your own sanity. Drupal's challenging learning curve means that there are a lot of people out there wanting help, and the #support channel is full of them. (I've spotted some of the most experienced drupallers asking for help there too; so it's not just for newbies.)

Source: Learning Curve for Popular CMS

Sustaining a good level of support is a challenge, especially doing so with a friendly manner. My approach has been to answer questions I know I can help with and avoid those that I know other people would be better placed to answer. Some questions can suggest a shaky foundation of understanding, so unless I'm sure I can help fix that, I tend to stay away from those too. Often a question is a symptom of a deeper issue - either with someone's website, or their understanding of Drupal components. On the whole, I believe I have helped a lot of people - and not just with their immediate questions. Some people come back to me with direct messages weeks or months later, knowing that I might be able to help.

Unfortunately my mental health has suffered a bit since the coronavirus pandemic began, so I've had to keep an eye out for things that may be contributing to that. Slack offers connection to people 24/7 - which can be good, but it's not a truly deep connection, and can be relentless. While my motivation for interacting with Drupal slack was to try and contribute to the community, that's not entirely for it's own sake. ComputerMinds want to help Drupal and its community flourish - but that's partly because we want that for our own benefit! So I decided to focus on supporting people that might be within closer reach, by skipping over most posts from outside UK business hours. (I'll happily reply to DMs/threads asynchronously though if necessary.)

In conclusion, I think Drupal slack is a really handy tool for connecting with the Drupal community. I'm very glad to help people through it, even if that means only making a difference slowly, to one person at a time. There are some incredibly helpful people on there who I see answering questions again and again. I tried to be one of those for a while, though I learnt to take care to make my offering sustainable. If you need help, try out Drupal slack. If you don't .... then you can probably be a help to someone there! Most of us are a mix of those extremes anyway. Try to be kind on slack - to yourself and others. I figure if we all help each other, we might make climbing that Drupal learning cliff a bit more personal, and a bit more pleasant. Win-win!


Photo by Paul Gilmore on Unsplash


Dries Buytaert: Acquia Engage Keynote 2020

Planet Drupal - Tue, 2020/10/27 - 9:06am

Acquia Engage took place last week. For the first time in seven years, it was an all-virtual event.

The virtual conference lobby of Acquia Engage, modeled after our Boston office's lobby.

The best way to learn about what Acquia has been up to, is to watch the recording of my opening keynote. In 30 minutes, I cover 10 major updates to Acquia's Digital Experience Platform. We packed the presentation with short product demos. You can also download a copy of my slides (65 MB), but you won't get the see the demos.

Acquia Drupal Cloud updates

First, I talked about new features for Acqiua's Drupal Cloud. All features are focused on helping developers migrate, develop, design and launch Drupal sites faster.

I covered the following new features for Acquia's Drupal Cloud:

  • Acquia Migrate: A family of products that help you migrate to Drupal 9 five times faster and easier.
  • Acquia Cloud IDE: A cloud-based development environment optimized for Drupal and Acquia.
  • Acquia CMS: An easy, out-of-the-box distribution of Drupal 9. It comes pre-integrated with Acquia's products.
  • Acquia Site Studio Page Builder: A new page builder for Acquia's low-code/no-code website building tool. It's optimized for marketers and content creators.
  • Acquia Cloud Next: A container-based cloud hosting environment optimized for speed, scale and security.
Acquia Marketing Cloud updates

Next, I covered new Marketing Cloud features. Marketers today are using more and more tools to get their jobs done. Unfortunately, many of these tools are not well-integrated. This lack of integration results in siloed customer information and inefficient marketing. Ultimately these silos lead to poor customer experiences. Acquia Marketing Cloud solves these problems by eliminating these silos. We combine or unify customer data profiles, segments, analytics, and machine learning capabilities into a single, easy-to-use platform.

New announcements for Acquia's Marketing Cloud include:

  • Unified real-time user profiles: Aggregates customer actions across platforms into profiles in real-time. Use them instantly in marketing campaigns.
  • Universal segments: Use consistent segments across every tool within Acquia Marketing Cloud. A segment created in our Customer Data Platform (CDP) automatically becomes available in our website personalization product and multi-channel marketing automation solution.
  • 360º marketing analytics: Measures marketing campaign effectiveness across the Acquia Marketing Cloud.
  • "Predictive sends" machine learning model: Uses machine learning to predict the best time to send campaign emails.
  • COVID-19 dashboard: Helps you understand your customers' shift from offline to online, as well as changes in channel preferences, product preferences and opportunities for growth.
Closing words

I'm proud that Acquia is innovating faster than ever before. I want to thank our product and engineering teams for working incredibly hard in the midst of a pandemic.


Aram Boyajyan: Drupal 8 JS event after opening AJAX modal

Planet Drupal - Tue, 2020/10/27 - 8:04am
Drupal 8 JS event after opening AJAX modal

Drupal provides a few custom events for AJAX modals. Even though the modal itself is provided by jQuery UI library, these events are custom and are provided by Drupal itself.

There are a few events you can use here:

superuser Tue, 27/10/2020 - 08:04

Josef Kruckenberg / dasjo: Participate in the COVID-19 Client Relationships Retrospective Survey

Planet Drupal - Tue, 2020/10/27 - 1:00am

How did the COVID-19 crisis affect client relationships and what can we take out of it? Take our global survey to help collect insights about how client relationships developed through the last year, what were our high and low lights and what can we take out of it?

The survey is open until November 8, 2020.

An anonymised summary of the survey results will be published in a blog post on Drupal Planet in November 2020.

You can then also participate in our online retrospective session at DrupalCon Europe, Wednesday 9th December - 15:15 to 17:15 UTC

Thank you for sharing your insights to help everyone grow. The data collected in this survey will be processed respecting everyone’s privacy. Link to the survey.

Photo by Julia M Cameron from Pexels


1xINTERNET blog: Three nomination for the German and Austrian Splash Awards

Planet Drupal - Mon, 2020/10/26 - 1:00pm
This year 1xINTERNET has three nominations for the German and Austria Splash awards taking place next Thursday 29th of October. The event will be virtual this year and is free for everyone.

PreviousNext: Join us at the DrupalGov 2020 Code Sprint

Planet Drupal - Mon, 2020/10/26 - 5:28am

This year DrupalGov is virtual. The PreviousNext team is sponsoring and helping to run the DrupalGov 2020 Sprint Day on Wednesday 4 November, and there are a few things you can do now to hit the ground running on the day.

by kim.pepper / 26 October 2020 This year the DrupalGov sprint will be virtual

We’ll start the day with a brief Zoom meeting to introduce the organisers, and outline how the day will run.

We’ll use #australia-nz Drupal Slack as the main communication channel, with ad hoc Zoom or Meet video calls for those who want to dive deeper into a topic.

For the majority of the day, we’ll be using Slack threads to keep track of sprint topics and reduce the noise in the main channel.

Join us on Slack

If you haven’t already done so, now is a great time to sign up and join the Australian / New Zealand Drupal community in Slack. Instructions for how to join are here:

Let us know about your experience

Please fill in the following survey to let us know about your experience with Drupal, and the areas you’re interested in Sprinting on. This will help us better prepare for the day.

How to contribute

Sprint day is not just for developers! Contribution comes in many forms. If you’re interested in the different ways you can contribute to this amazing project, see the list of contributor tasks:

Tagging issues to work on

If you want to see what might be an interesting issue to work on, head over to the Issue Queue and look for issues tagged with 'DrupalGov 2020'. These are issues that others have tagged.

You can also tag an issue yourself to be added to the list.

Set Up a Development Environment

There is more than one way to shear a sheep, and there is also more than one way to set up a local development environment for working on Drupal.

If you don't already have a local development environment setup, we recommend using Docker Compose for local development - follow the instructions for installing Docker Compose on OSX, Windows and Linux.

Once you've setup Docker compose, you need to setup a folder containing your docker-compose.yml and a clone of Drupal core. The instructions for that vary depending on your operating system, we have instructions below for OSX, Windows and Linux, although please note the Windows version is untested.

Mac OSX mkdir -p ~/dev/drupal cd ~/dev/drupal wget git clone --branch 8.9.x app docker-compose up -d docker-compose run -w /data/app app composer install Windows git clone --branch 8.9.x app docker-compose up -d docker-compose run -w /data/app app composer install Linux mkdir -p ~/dev/drupal # or wherever you want to put the folder cd ~/dev/drupal wget clone --branch 8.9.x app docker-compose up -d docker-compose exec app /bin/bash -c "cd /data/app && composer install"

If you have any issues, join us on Drupal slack in the #australia-nz channel beforehand and we'll be happy to answer any questions you might have.

Install dreditor browser extension

Dreditor is a browser extension that makes it easier to review patches on Its a must for anyone contributing to Drupal.

There are versions for Firefox and Chrome.

Find Issues to Work On

If you want to see what might be an interesting issue to work on, head over to the Issue Queue and look for issues tagged with 'DrupalGov 2020'. These are issues that others have tagged.

You can also tag an issue yourself to be added to the list.

Being face-to-face with fellow contributors is a great opportunity to have discussions and put forward ideas. Don't feel like you need to come away from the day having completed lines and lines of code.

Code of conduct

To provide a safe and inclusive environment, the sprint day will abide by the DrupalSouth Code of Conduct:

We look forward to seeing you all there!

Tagged Code Sprint, DrupalSouth, DrupalGov 2020

Spinning Code: SC DUG October 2020: Getting Started in Consulting

Planet Drupal - Sat, 2020/10/24 - 8:03pm

This month’s SC DUG featured Mauricio Orozco posing questions about getting started as a consultant to long-time members who have all done some work with Drupal as a consultant.

If you would like to join us please check out our upcoming events on Meetup for meeting times, locations, and remote connection information.

We frequently use these presentations to practice new presentations, try out heavily revised versions, and test out new ideas with a friendly audience. So if some of the content of these videos seems a bit rough please understand we are all learning all the time and we are open to constructive feedback. If you want to see a polished version checkout our group members’ talks at camps and cons.

If you are interested in giving a practice talk, leave me a comment here, contact me through, or find me on Drupal Slack. We’re excited to hear new voices and ideas. We want to support the community, and that means you.


Drupixels: Export and import Drupal database with drush command

Planet Drupal - Fri, 2020/10/23 - 6:34am
Drush is the ultimate tool and companion for Drupal and it does a great job in situations where we want to import or export our Drupal database.

Amazee Labs: Why enterprises trust the Amazee Labs Open Source Tech Stack over Adobe Experience Manager

Planet Drupal - Thu, 2020/10/22 - 10:37am
<img src=";itok=nM74aYm4" width="1120" height="630" alt="Graphic of blog title, Why enterprises trust the Amazee Labs Open Source Tech Stack over Adobe Experience Manager" title="Why enterprises trust the Amazee Labs Open Source Tech Stack over Adobe Experience Manager" class="image-style-leading-image" /> Amazee Labs has been contributing to Drupal since the very early days of the project. Our contributions range from writing patches and maintaining modules, through to contributing to new releases and we’re proud to be one of the most experienced Drupal agencies in the world. In recent years, we have moulded our technology stack from several key components, some of which go beyond Drupal. 

Third & Grove: Acquia Engage 2020 Winner: CloudHealth by VMware

Planet Drupal - Thu, 2020/10/22 - 5:12am

Third and Grove was recognized in the 2020 Acquia Engage Award program, winning an award for Leader of the Pack - Technology, for work with CloudHealth by VMware.


Third & Grove: Acquia Engage 2020 Winner: The Carlyle Group

Planet Drupal - Thu, 2020/10/22 - 5:09am

Third and Grove was recognized in the 2020 Acquia Engage Award program, receiving an award for Leader of the Pack - Financial Services, for work with The Carlyle Group.


Promet Source: Pandemic Sparks Web Accessibility Breakthroughs

Planet Drupal - Thu, 2020/10/22 - 4:29am
The impact of this years’ shelter-in-place orders and social distancing guidelines, along with every aspect of how we have coped -- or not coped -- with Covid-19 will be analyzed for years to come. Big changes have emerged in the ways that we interact with the world, and the next normal will likely bring with it many differences in the ways that we live, work, and play.  

Lullabot: Web Development Strategy in a Drupal 9 World

Planet Drupal - Wed, 2020/10/21 - 4:21pm

The Drupal 8 to Drupal 9 upgrade path represents a big change for the Drupal world. The big change is that…your organization’s website won’t require a big change. The first iteration of Drupal 9 is just Drupal 8 with all of the deprecated code removed, mimicking Symfony’s model of major release upgrades.

This is good news. Keeping your platform up-to-date with the next version is no longer an “all hands on deck” situation.