Planet Drupal

Subscribe to Planet Drupal feed - aggregated feeds in category Planet Drupal
Updated: 9 min 34 sec ago

ActiveLAMP: Drupal 7 or 8: DrupalCamp LA 2016 Table Talk - pt. 1/5

Fri, 09/09/2016 - 17:01

We got a few shop owners together at DrupalCamp LA 2016, at UC Irvine to talk Drupal. This is Part 1 of 5 of that conversation, talking about using Drupal 7 or Drupal 8 for new projects that we’re building.

Categories: Elsewhere

Code Enigma: Introducing the Selective Watchdog Backend module

Fri, 09/09/2016 - 16:20
Introducing the Selective Watchdog Backend module Language English Return to Blog Introducing the Selective Watchdog Backend module

Keep a good performance while storing logs on your Drupal database.

Fri, 2016-09-09 15:20By salva

In the world of Drupal, it's a common and best practice to disable the Dblog module (Database logging) on production sites, in favour of using the Syslog module, which will take care of logging all php errors, notices, or any custom log messages into the Unix system logs, removing the performance burden of writing them to the Drupal database.

There are scenarios in which this approach, while convenient to keep the site running smoothly, is rather problematic when troubleshooting issues that appear only in a given environment and under very specific conditions. For those, unless you can count with some custom logging system built for very specific aspects of a site, you are pretty much blind and unable to find the source of a bug. 

We've recently had this problem in one of our sites, where several external systems were involved in the feature that we were trying to debug. Given that those systems couldn't be reached from a development environment, we needed a minimum amount of information to be kept on the Drupal database, so that it was easier to navigate and see the details than it is to sail through the syslog. For that, Pascal Morin wrote a new module called Selective Watchdog Backend (selectlog).

So what's it?

The concept behind the Selective Watchdog Backend is quite simple: instead of sending all logs to the syslog, give developers some flexibility to choose what can be also sent to the Drupal database. That way, you ensure that everything is sent to the syslog as usual, but for very specific sections of your site, you still have a meaningful set of logs of what you might consider more important at any given point. The great thing of the module, is that it doesn't affect any other watchdog modules you may be using. It's just an addition on top of them.

Let's see a couple examples, of what could be common use cases:

Scenario 1: You have a complex integration with a 3rd party API, and all the site users make constant use of it. However, it's not very stable, and you need to assist your client by providing them with exact details of the points at which the API is failing to return the expected results. Of course you've already added watchdog entries for these cases when you wrote the module, because you're a smart developer, but now you need these entries to be surfaced on the Drupal site. With the selectlog module enabled, all you'd have to would be editing your settings.php file and add these lines:

$conf['selectlog'] = array( 'dblog' => array(
  'your_api_integration_module' => '*',

That would log every watchdog entry of your custom module to the database, making it available under admin/reports/dblog.

Scenario 2: Some of your views are breaking on production and you don't manage to find the problem (this is less likely to happen, but it'll do for the sake of the explaining the module usage). To troubleshoot this, you want to store the watchdog entries from the views module in the database, but just those of a certain severity. To do so:

$conf['selectlog'] = array( 'dblog' => array(
  'views' => array(

And that's it. Pretty neat and convenient. Hopefully we'll be promoting this sandbox to a full project soon. In the meantime, take our word that it works wonderfully. If you think it's going to be an useful feature on your site, I recommend checking out the details on the project page or the comprehensive file included with the module. Enjoy your logs!


BlogViewport module ready for Drupal 8 BlogSpinning up a CentOS server for Drupal FAQHow do I find Drupal messages with the syslog module enabled? BlogDoing more with Drush sql-sanitize
Categories: Elsewhere

Kodamera Screencast: The Coffee module

Fri, 09/09/2016 - 16:08

Time to check out one of our favourite contrib modules for Drupal - The Coffee module. With a keyboard shortcut it displays a quicksearch moodal window that lets you navigate around in Drupal very quick and easy.

Simliar modules are EazyLaunch and Cobalt, but they are only available for Drupal 7 (so far).

Read more
Categories: Elsewhere

PreviousNext: We could add default content to Drupal core, but what would that mean?

Fri, 09/09/2016 - 05:07

There has been some movement of late around adding some default content to the standard profile.

This was originally reignited by Roy Scholten in his getting something in the box post.

As author and co-maintainer of the default content module for Drupal 8, I wanted to share my thoughts on the potential of adding it to Drupal core.

Categories: Elsewhere

Drupal core announcements: User Guide 8.x-2.0 released!

Fri, 09/09/2016 - 00:51

At long last, the copy editing of the User Guide is done! (If you've been a member of this group for a while, you should know what I'm talking about; if not, go browse the archives at for the last 1.5 years or so). I'd like to thank everyone who helped with editing tasks, and especially Jojy Alphonso (jojyja), who did the vast majority of the copy editing. THANK YOU!

So, the guide is in very good shape, and I just made an official release of version 8.x-2.0, corresponding to Drupal Core 8.2.x (which is supposed to be released soon). It should be live on soon, in HTML format, for your reading pleasure (not sure exactly when, since the reduced Drupal Association staff is pretty busy, but we're working on it). I'll post a link in a comment here when that happens.

Meanwhile, you can go to the User Guide project page and download the release, which contains all of the source files (which are written in AsciiDoc markup language), as well as PDF, ePub, and Mobi ebook versions (those are in the "ebooks" folder/directory of the archive you get when you download the project).


Also... The next step will be to translate the User Guide into other languages. The enthusiastic and experienced Catalan and Hungarian language teams will be starting on that shortly, and refining the process so that hopefully the other language teams can get started soon as well. If you want to help translate the Guide, you should start by joining the translation team on for your language. Thanks!

Categories: Elsewhere

Lullabot: Syntax is Syntax? Lullabot's Non-Drupal Development Work

Thu, 08/09/2016 - 22:00
Did you know that Lullabot does a significant amount of non-Drupal work? Matt and Mike sit down with several Lullabots who are working on non-Drupal projects including Node, Swift, and React. We talk pros and cons of working in various languages, how they compare to our PHP world, and lots more.
Categories: Elsewhere

DrupalCon News: Wining and Dining in Dublin

Thu, 08/09/2016 - 20:45

Dublin is a great place to eat out.

You probably won’t be surprised to learn that Dublin has a pretty good selection of bars and restaurants and selecting just a few is a difficult task. This is most certainly not a comprehensive list of venues, but here is a selection of our favourites.

Let us begin with that most important institution: the full Irish breakfast!

Categories: Elsewhere

Annertech: How to Get the Most out of DrupalCon Dublin

Thu, 08/09/2016 - 13:34
How to Get the Most out of DrupalCon Dublin

DrupalCon is big. It's got hundreds of sessions. A similar amount of BoFs. Approximately 2,000 attendees. Social events left, right, and centre. It's not hard to get confused, miss things that you promised not to, and leave thinking "damn, I could have done that better". At Annertech, we're Ireland's most seasoned DrupalCon attendees. Here's our guide to making the most of it.

Categories: Elsewhere

Drop Guard: Meet us in Dublin at booth #105!

Thu, 08/09/2016 - 12:00

Only 20 days are left until we head to Dublin to join the DrupalCon 2016! It’s the first time that we, the Drupal agency team from Bright Solutions (which is the "birthplace" of Drop Guard), arrive at a Con only with our Drop Guard team, so we can focus on our most famous contribution to the Community: our update management service tool “Drop Guard”.

Yes, we’d be happy to show people the great values which Drop Guard provides - but most of all we look forward to personal and honest conversations to progress in our work and as part of the Community!


Drupal Drupal Planet Drupalcon
Categories: Elsewhere

Flocon de toile | Freelance Drupal: Introduction to Drupal 8 module : Permissions by field

Thu, 08/09/2016 - 07:51
The powerful access control system provided by Drupal 8 and permissions can prove to be a decisive criterion for choosing Drupal. This system is the basis of modules as Organic Group or Domain access, which respectively implement groups within the same site and implement a virtual multi-site architecture. The Permissions by field module allows us to control access to contents of a Drupal site in several generic methods, relying on the power of Entity Reference and the Drupal Field API, and to be able to delegate complex management access rights to content publishers according to their needs. Discover this module and the different possible use cases.
Categories: Elsewhere

Drupal Blog: Drupal 8.2.0-rc1 is available for testing

Thu, 08/09/2016 - 00:07

The first release candidate for the upcoming Drupal 8.2.0 release is now available for testing. With Drupal 8, we made major changes in our release process, adopting semantic versioning and scheduled releases. This allows us to make significant improvements to Drupal 8 in a timely fashion while still providing backwards compatibility. Drupal 8.2.0 is the second such update, expected to be released October 5.

Download Drupal-8.2.0-rc1

8.2.x includes many REST improvements; new experimental modules for content moderation, block placement, a sidebar to configure site elements in place, and end date support; and many other features and improvements. You can read a detailed list of improvements in the announcements of beta1, beta2, and beta3.

What does this mean to me? For Drupal 8 site owners

The final bugfix release of 8.1.x has been released. 8.1.x will receive no further releases following 8.2.0, and sites should prepare to update from 8.1.x to 8.2.x in order to continue getting bug and security fixes. Use update.php to update your 8.1.x sites to the 8.2.x series, just as you would to update from (e.g.) 8.1.4 to 8.1.5. You can use this release candidate to test the update. (Always back up your data before updating sites, and do not test updates in production.)

For module and theme authors

Drupal 8.2.x is backwards-compatible with 8.1.x. However, it does include internal API changes and API changes to experimental modules, so some minor updates may be required. Review the change records for 8.2.x, and test modules and themes with the release candidate now.

For translators

Some text changes were made since Drupal 8.1.0. automatically offers these new and modified strings for translation. Strings are frozen with the release candidate, so translators can now update translations.

For core developers

All outstanding issues filed against 8.1.x are automatically migrated to 8.2.x now. Future bug reports should be targeted against the 8.2.x branch. 8.3.x will remain open for new development during the 8.2.x release candidate phase. For more information, see the beta and release candidate phase announcement.

Your bug reports help make Drupal better!

Release candidates are a chance to identify bugs for the upcoming release, so help us by searching the issue queue for any bugs you find, and filing a new issue if your bug has not been reported yet.

Categories: Elsewhere

Xeno Media: Drupal HTML Formatter Module

Wed, 07/09/2016 - 21:32

We used the Acquia Lightning distribution in developing this site.  Lightning, takes full advantage of the awesomeness of Panels and Panelizer to display content defaults, and override on a per node basis.  We used Panelizer to set up displays for the full node displays, and the Teaser node displays.

This brought up a problem where I wanted to set up the title of the node using an H1 on the full display, but an H2 on the teaser.  We thought of overriding two templates to do this, but that didn't seem like a sustainable solution as we quickly realized there were other places we needed similar functionality, like choosing different html elements, and adding classes to fields of various sorts.

We had this functionality in Drupal 7 thanks to the Title module, and it's "Wrapped and Linked" widget.  In D7, the main purpose of the Title module was to turn the title into a field so it could be translated.  Since translation was moved into core in D8, there hasn't been a lot of movement on porting Title to D8, and that module was not an option.

After a quick discussion between Albert and I, he quickly got to work and started to work on the Drupal HTML Formatter module.  It is a simple module that lets you add HTML tags to fields that are strings, timestamps, datetime, referenced and entities.  You can add any HTML/HTML5 tag, add classes, and you can also set if the content is linked to content which is almost always required on entity reference fields.

To use, install as you normally do and enable the HTML Formatter module.  If your site is a Panels based display, one that uses Panelizer or Page Manager, and your Block, and select Html field formatter from the Formatter dropdown.  Then add your HTML Tag, and if needed, add the Class Name, and check the Link to Content checkbox and Save.

Not using Panels?  Well have no fear as the HTML Formatter also works on the normal Manage display tab of entities.  Select Html field formatter from the Format dropdown.  Then click on the settings cog to expand the options and you will see the same three options.

We developed this as way of giving back to the Drupal community, as I can imagine that there are others who have run into this need.  Let us know what you think.  You can find us on Twitter at @alb3rtski, @thejimbirch, and @xenophiles.

Categories: Elsewhere

Third & Grove: The Death of Drupal Commerce as an Ecommerce Solution

Wed, 07/09/2016 - 20:57
The Death of Drupal Commerce as an Ecommerce Solution justin Wed, 09/07/2016 - 14:57
Categories: Elsewhere

Chromatic: Drupal Code Standards: Documentation

Wed, 07/09/2016 - 17:56

This is the fourth post in a series about coding standards. In this post we’ll talk about why good, standardized documentation is crucial to your project, and review Drupal coding standards regarding documentation and comments.

Other posts in this series:

  1. Drupal Code Standards: What Are They?
  2. Drupal Code Standards: How Do We Implement Them?
  3. Drupal Code Standards: Formatting
  4. Drupal Code Standards: Documentation
  5. Drupal Code Standards: The t() function
  6. Drupal Code Standards: Object Oriented Coding & Drupal 8
  7. Drupal Code Standards: Twig in Drupal 8
Why is documentation important?

Documentation tells us what our code does. How it’s set up, what variables it uses, what it returns. It tells us what to expect from our code.

But I know what my code does!

Sure you do, right now, you just wrote it. But how about 2 months or 10 projects from now? What about someone else? The key is to make your code maintainable by everyone. Of course, ideally, you’re writing code that’s easy to comprehend because you did everything in a perfectly logical and straightforward way. But comment it thoroughly, just in case. You might also do something clever to solve a tricky problem, but to the next person, it might look like a mistake. Documentation can clear this up.

But my code is so good, it’s self-documenting!

Of course it is. But even to the best programmer, documentation is still quicker and easier to read than code. Documentation is especially helpful for beginner programmers - say someone who’s just starting with Drupal and PHP is looking through your code to see if it does what they need - if you can spell it out for them, you’ll help them figure out what they need a lot faster. Thanks to Drupal’s documentation standards, we have a few ways to document your code that are designed to be quick and easy for the developer writing the code, and the developers reading and modifying it. That said, try to avoid repetetive inline comments - you don't need to comment on every single line of code, especially if it's very clear what it's doing. Comment on functions, large blocks of code, tricky things, things that may change - think about what might be unclear to the next person to look at it.

Doc Blocks

One of the most important parts of documentation in Drupal is doc blocks - these are specially formatted blocks of information that go both at the top of each PHP file and before each function.

File Doc Blocks

A file doc block goes at the top of a file to give you an overview of what the file contains. These go at the top of every PHP file, and while it is still in the process of being adopted as an official standard, there should be one blank line between the opening tag and the doc block. Here’s an example from the Backup and Migrate module:

<?php /** * @file * Create (manually or scheduled) and restore backups of your Drupal MySQL * database with an option to exclude table data (e.g. cache_*). */

It’s short and simple and explains what to expect in this module file. Each function will be documented separately, so this doesn’t need to be extensive. On the next line after the file tag, we have a description. The @file doc block may also commonly include @author and @version.

/** * @file * Provides hook implementations for the chromatic_blog module. * * @author Chris Free * * @version 1.0 */

In something like a template file, you’ll see more detail in the @file doc block, because the rest of the file may not have as much documentation. The @file doc block may often spell out available variables.

Here’s an example from the Bartik theme:

/** * @file * Bartik's theme implementation to provide an HTML container for comments. * * Available variables: * - $content: The array of content-related elements for the node. Use * render($content) to print them all, or * print a subset such as render($content['comment_form']). * - $classes: String of classes that can be used to style contextually through * CSS. It can be manipulated through the variable $classes_array from * preprocess functions. The default value has the following: * - comment-wrapper: The current template type, i.e., "theming hook". * - $title_prefix (array): An array containing additional output populated by * modules, intended to be displayed in front of the main title tag that * appears in the template. * - $title_suffix (array): An array containing additional output populated by * modules, intended to be displayed after the main title tag that appears in * the template. * * The following variables are provided for contextual information. * - $node: Node object the comments are attached to. * The constants below the variables show the possible values and should be * used for comparison. * - $display_mode * - COMMENT_MODE_FLAT * - COMMENT_MODE_THREADED * * Other variables: * - $classes_array: Array of html class attribute values. It is flattened * into a string within the variable $classes. * * @see template_preprocess_comment_wrapper() */ Function Doc Blocks

A function doc block goes just before every function in every PHP file. No exceptions. Even if it’s a one-line function, it gets a doc block. Now, coder will let you get away with only putting the one-line summary of your function, this is all that’s technically required. For some functions, this may be appropriate. But if your function has any parameters or return values, you should absolutely be documenting them. Yes, it’s more work upfront, but it’s vital work that saves time in the future.

Here we’ll look at a function from the Backup and Migrate module.

This passes coder, it’s got a one-line summary of the function:

/** * Restore from a file in the given destination. */

But this is better:

/** * Restore from a file in the given destination. * * @param string $destination_id * The machine-readable path of the backup destination. * @param object|string $file * The file object, or its name. * @param object|array $settings * A settings object, or array to create a settings object. * * @return object|bool * Returns the file, or FALSE if the restore had any errors. */

Does this take a little more time? Absolutely. But I guarantee you will have a better understanding of the code if you write out documentation that’s as detailed as possible. Now we know what is passed to the function, what each variable is, and what the function returns. Good documentation can also aid in debugging - if the documentation doesn’t match what’s happening in the code, you know something is wrong, and you’ve got a starting point for fixing it.


There are a variety of tags you can use in your doc blocks to indicate what this documentation is about, and they’re expected to go in a certain order, as follows:

Each type of tag should be separated by a blank line. The most-used tags in function doc blocks are probably @param and @return.

Here’s an example of how the Countries module uses some of the other tags:

/** * Generate a country form. * * @ingroup forms * * @see countries_admin_form_validate() * @see countries_admin_form_submit() */

Groups and topics are tags that come from Doxygen, on which these standards are based, and it helps to group generated documentation from the API module. From

@defgroup, @addtogroup, @ingroup, @{, @}: Groups and topics

The @defgroup tag is used to define a "group" (in Doxygen terms), which the API module displays as a Topic page. A @defgroup tag needs to be in its own docblock (not inside a file description docblock, function docblock, class docblock, etc.). A group defined by @defgroup has an identifier (starting with a letter, and composed of numbers, letters, underscores, periods, and hyphens), a title, a summary, and documentation. In addition, individual "items" (files, functions, classes, and other things that are documented with docblocks in the API module) can be designated as being "in" the group. The API module makes a page for each group/topic, and on the page, it lists all of the items that are part of the group.

Here’s an example of @defgroup from Drupal 8 core - groups are used more often when you have a large amount of code, like core does. You’ll also see an example of @code and @endcode used here - this tells the API Module to format that text as code.

/** * @defgroup php_wrappers PHP wrapper functions * @{ * Functions that are wrappers or custom implementations of PHP functions. * * Certain PHP functions should not be used in Drupal. Instead, Drupal's * replacement functions should be used. * * For example, for improved or more secure UTF8-handling, or RFC-compliant * handling of URLs in Drupal. * * For ease of use and memorizing, all these wrapper functions use the same name * as the original PHP function, but prefixed with "drupal_". Beware, however, * that not all wrapper functions support the same arguments as the original * functions. * * You should always use these wrapper functions in your code. * * Wrong: * @code * $my_substring = substr($original_string, 0, 5); * @endcode * * Correct: * @code * $my_substring = Unicode::substr($original_string, 0, 5); * @endcode * * @} */

And in another function block, we’ll see:

@ingroup php_wrappers

Which tells us that this function is part of the php_wrappers group. It’s a handy way to organize your code once you get the hang of it!

The @deprecated tag is useful if you don’t want to delete a function - someone could have custom code that relies on it.

/** * Wrapper for country_load(). * * @deprecated * Use country_load($iso2) instead. */ Lists

You can create lists in your doc blocks that will be interpreted by the API module as unordered lists. They can also make it easier to read. Start the line with a hyphen to indicate a list item. Here is an example from the CKEditor module:

/** * Implementation of hook_requirements(). * * This hook will issue warnings if: * - The CKEditor source files are not found. * - The CKEditor source files are out of date. * - Quick upload and/or the built-in file browser are used and $cookie_domain is not set. */ Implements hook_xyz().

If you are implementing a hook - for example, hook_menu, all you have to put in the function doc block is:

/** * Implements hook_menu(). */

In fact, if you put more than this, coder will give you a warning such as:

8 | WARNING | Format should be "* Implements hook_foo().", "* Implements | | hook_foo_BAR_ID_bar() for xyz_bar().",, "* Implements | | hook_foo_BAR_ID_bar() for xyz-bar.html.twig.", or "* Implements | | hook_foo_BAR_ID_bar() for xyz-bar.tpl.php.".

You also do not need to duplicate the documentation for the function, such as the parameters. If you do, you’ll get a warning such as:

11 | WARNING | Hook implementations should not duplicate @param documentation

If it’s really important that you document something that has changed in your implementation, never skimp on documentation. However, you can always put the documentation inside the function if you want to keep coder happy about the docblock.

API Module

Why are these doc blocks so important, and why do they have to be formatted so exactly? The API Module parses the information in doc blocks into documentation, so it’s especially important to make sure the format is correct. Any documentation that strays from this format will be human-readable, but won’t be properly parsed. The documentation found at is all generated this way.

Inline Comments

Inline comments are important, because this is what you’ll use to explain your code throughout your files. Drupal generally uses the C++-style \\ notation, though C-style comments (\* *\) are allowed, but discouraged within functions. Inline comments shouldn’t follow a statement - this means they must get their own line. It’s usually understood that a comment precedes the line it’s commenting on, but you can always make this clearer by saying something like "The following line does XYZ."

Remember from our previous post on formatting that inline comments must always end in a full stop, and must never be longer than 80 characters. Here’s an example from a contrib module:


'iso2' => array( '12', // Numerical '', // Empty '$s', // Special char 'au', // Duplicate 'd', // Single property 'ddd', // Too long ),


'iso3' => array( // Numerical. '123', // Special char. '$ss', // Duplicate. 'aus', // Single char. 'd', // Double char. 'dc', // Too long. 'xaaa', ),

Right, but discouraged:

'numcode' => array( '1001', /* Too big. */ '-1', /* Too small. */ '-12', /* Too small. */ '-123', /* Too small. */ '$23', /* Special char. */ '23#', /* Special char. */ '048', /* Duplicate. */ '4', /* Duplicate. */ '04', /* Duplicate. */ ), Content Style Guide has a style guide for content on the site, and it’s encouraged to use this guide for anything you write inside of Drupal code. Much of it is the style of various industry-related terms, along with Drupal specific terms. It’s worth giving it an overview. The clearer our content, the better we can communicate with each other and with new Drupal users!

We’ve covered why documentation is essential, how to write file and function doc blocks for the API module in your Drupal code, and inline comments. As detailed as this may seem, it’s still only an overview - the page has even more detail! But this guide will get your started and give you a reference point. Now go forth and document!

In our next post on coding standards, we’ll take a detailed dive into just one essential Drupal function - the t() function. Learn when and when not to use it in both Drupal 7 and Drupal 8!

Hero Image Attribution: dangerismycat CC

Categories: Elsewhere

Stanford Web Services Blog: Git: Find the First Tag Containing a Specified Keyword

Wed, 07/09/2016 - 17:00

Today's post is a quick tutorial how to use "git grep" and "git tag" to find the earliest tag that contains a particular line of code.

TL;DR: use:

git grep <regexp> $(git rev-list --all)


git tag --contains=<commit hash>

Categories: Elsewhere

Amazee Labs: The Amazee Labs sessions track record for DrupalCon Dublin

Wed, 07/09/2016 - 13:08
The Amazee Labs sessions track record for DrupalCon Dublin

It’s a track record! For the upcoming DrupalCon in Dublin, 13 tracks will feature talks for an audience of thousands of people coming together for Drupal. We are proud to be represented in 6 of those tracks.

Josef Dabernig Wed, 09/07/2016 - 13:08

Curious about the latest and greatest in decoupled web architectures and how they integrate with Drupal? No compromises – React, Relay and GraphQL on Drupal 8 by Sebastian Siemssen (fubhy), Campbell Vertesi and Moshe Weitzman in the Horizons track is mainly targeted at experienced developers. Sebastian, Campbell and Moshe share their experience with setting up a Drupal website architecture based on these latest technologies.

It’s almost 10 years since Amazee has started reaching for the stars. Check out A tale about building businesses and sleeping on sofas by Dania Gerhardt in the Business track. As the CEO of our Cape Town office, founder & partner she is happy to share her very own startup and business story. Attend her session to find out about building five companies in nine years on three continents.

The way we build sites and implement layouts has changed massively over time. Remember Contemplate, Context or the Panels modules? The session How to create content layouts in Drupal 8 by Josef Dabernig (dasjo) and Inky Talbot (Inky3d) in the Site Building track features the current best practices that Amazee Labs has developed during the last 3 years; since we started to work witn Drupal 8.

Scaling high-performance websites around the globe is one challenge that our DevOps team enjoys tackling. To CDN and beyond! Speed up websites beyond the US and Europe by Bastian Widmer (dasrecht) in the Performance and Scaling track features a good mix of best practices and lessons learned on setting up CDN's with Drupal, hosting in mainland China and other fun optimizations that the team has done.

Automation and watertight processes are really what you want when it comes to ensuring the security of your web applications. Drupal Security: There is a Mini-DrupalGeddon every week and how to survive it is a joint session by Michael Schmid (schnitzel) from the team and Manuel Pistner (manuelBS) from DropGuard in the Drupal Showcase track. Join these two experts in Drupal hosting and security automation to find out about the Drupal security patch release process and how we integrate it into our CI/CD workflows.

What makes us effective, how do we accomplish tasks? My talk Let me help you help me - Selfish empowerment of others in the Being Human track is all about trial and error with leadership both in the Drupal community and at work. I’m looking forward sharing my experience with delegating tasks and supporting others on their career paths.

Interested? We look forward to seeing you September 26-30 at DrupalCon Dublin. Find us there in one of our sessions or at our booth, but also remember - all sessions will be recorded and put up on the Drupal Association YoutTube channel.

Categories: Elsewhere

PreviousNext: Custom views filters with Search API and Simple Hierarchical Select

Wed, 07/09/2016 - 11:04

A recent project involved the use of the Simple Hierarchical Select module to input category data for a particular content type. Simple Hierarchical Select provides a clean way of browsing hierarchical vocabularies to easily add taxonomy terms to nodes.

An initially tricky user interface problem to utilise this module with Search API and Views exposed filters was solved using a couple of Drupal 8 plugins and a bit of smart thinking!

Categories: Elsewhere Higher Ed Drupal: Drupal In Computer Science

Wed, 07/09/2016 - 03:46

School has just started for many of your children. It may be starting for you too!

I start tomorrow: as an instructor at the University of Wisconsin-Green Bay. My mind is all full of anxiety as I try to guess the level of knowledge of the large (25 plus a waiting list) class. I'm also excited to bring Drupal into the classroom.

At myDropWizard, we supply support and maintenance for several world-class universities, so I know Drupal is no stranger to the world of "higher-ed". There are also Higher Ed sessions at Drupalcon and most DrupalCamps!

Higher-Ed Chooses Drupal for many reasons:Free "As In Beer"

Cost is always an issue in education. If you can get a free solution that works as well as anything costing thousands of dollars or more, it's a win!


At its core as the world's most powerful content-management system, Drupal is multi-user. Multiple users can update parts of the website simultaneously. More important to larger institutions like higher-ed - they can have varying permission levels. This ganularity is common within Drupal, so most modules and development takes this into account.


Thousands of (again free) modules that add functionality. Other platforms pride themselves on paid plug-ins. In the Drupal world, we believe modules that are usable by many should be used by many. We tend to make them free!

Free "As In Speech"

Institutions can use it however and for whatever reasons they want. They can tune it, replicate it, create distributions of their own - whatever they need to get the job done on time and under budget!

Categories: Elsewhere

Chapter Three: How to create custom Drush commands

Wed, 07/09/2016 - 00:20

It is very easy to create your own custom Drush commands. In this blog post I will show two examples for Drupal 7 and Drupal 8.

Creating custom Drush commands could be very useful when you need to import data into Drupal or export data from Drupal. You would have to create a separate bash script where you would execute your custom command and add the bash script to your crontab.

Drupal 8 example

Drupal 8 module structure:

drush_example/ - -

Categories: Elsewhere OG8 development mindset

Tue, 06/09/2016 - 23:00

As OG8 is steadily being built, I have noticed a certain pattern - or a mindset - we’ve been following which I think is worth sharing.

OG8 is the third time I’ve written OG for Drupal. The first OG7 version was a head jump into the Entity goodness that Drupal 7 brought along with Entity API. The second version was taking a small step back away from the Entity fiesta, but took two steps forward into the field API.

I think that as a developer I have matured since then. Edge cases are no longer my concern. I mean, I’m making sure that edge cases can be done and the API will cater to it, but I won’t go too far and implement them. It’s not that in OG7 we tried to tackle all of the edge cases, but in OG8 it’s even less.

In fact, although we write a lot of new code as part of the porting, as the way we write modules for Drupal 8 has changed considerably, writing OG8 feels like… Well, it feels like I’m mostly deleting files.

Removing lines of code is so much better than adding Myths Debunked

It’s not too rare to hear rants about OG. Often they are not backed by actual data, or even refer to older versions.

Continue reading…

Categories: Elsewhere