Planet Drupal

Subscribe to flux Planet Drupal - aggregated feeds in category Planet Drupal
Mis à jour : il y a 8 min 57 sec

FFW Agency: Great Examples Of Distributed Content Management In Product Companies

ven, 20/05/2016 - 19:24
Great Examples Of Distributed Content Management In Product Companies erik.wagner Fri, 05/20/2016 - 17:24

Welcome to the fifth post in my series on Distributed Content Management.  In previous posts I’ve defined the concept and provided some great examples of Distributed Content Management use cases in higher education, the pharmaceutical industry and media and entertainment companies.  In today’s post I’ll wrap up my industry-specific use cases by investigating ways in which product companies can use Distributed Content Management to improve their approach to everything from internationalization of their websites to managing community contributions. 

Setting The Scene

Product websites, whether for physical or virtual products, must ultimately influence their visitors.  For direct-to-consumer products, the goal may be a direct conversion - to get the visitor to buy/download the product.  Business-to-business products often have a more complex buyer’s journey, starting with something as seemingly minimal as driving the visitor to contact the company for more information.  Within the digital sphere, companies whose products are extensible platforms or systems may be seeking not only end-users, but developers or contributors to expand on the value of their initial offerings.  In all of these scenarios, the content presented to the user must be keenly adapted to the task at hand and, with products especially, must co-exist with information available from external sources.  Carefully planning their approach to Distributed Content Management - to the point of expanding what they may consider content - is a key tool for a product company’s success.

Use Case 1: A Multi-System Approach to Product Experience Management

Many web platforms strive to be all-in-one solutions for a product’s online presence; however, savvy product companies recognize that they can build a superior web experience by integrating multiple systems and relying on their core strengths.  A common example of this for product companies is around enterprise e-commerce systems (such as Demandware, Magento, or BigCommerce).  All of these solutions provide some level of content management and layout control; however, larger organizations that make heavy use of Distributed Content Management staples such as content re-use and custom publishing workflows may find the out-of-the-box tools duplicative or not sophisticated enough for their processes. Luckily, these systems allow organizations to interact with them programmatically through APIs and many provide pre-built connectors to popular content management systems such as Drupal and WordPress.  By integrating e-commerce tools with powerful content management systems, product companies can have the best of both worlds for both their internal processes and customers’ experience.

Use Case 2: Internationalization of Product Websites

Entry-level internationalization may be achieved with a single website and automated text translation; however, as a product company’s reach expands so may the sophistication of their internationalization strategy - and that can impact their needs for Distributed Content Management.  A simple example of this may be the transition between automatic translation technology (such as Google Translate, Lingotek Inside or’s Website Translator) and content management provided by native-speaking editors.  Native-language content production, with its cultural nuances and idiomatic expressions, can provide a far superior experience to a website’s visitors but introduces a number of elements to a company’s Distributed Content Management strategy. For example, how will translated content fit within the company’s existing publishing workflow?  How will different language teams coordinate around new pages and content?  Taking this further, companies that produce physical products often have unique product lines in different geographical regions, a reality that necessitates a decentralized management strategy with close coordination around company-wide content.

Use Case 3: Curating Other People’s Content

More so than ever before, potential customers have easy access to a flood of content about a product before they decide whether or not to use it.  For a company’s digitally-inclined customers, Amazon’s Q&A and reviews, YouTube videos and even social media interactions with a company have become key elements guiding their decision making.  Attentive product companies actively manage these external sources: answering questions on Amazon, providing high-profile bloggers and YouTube producers with review copies of products, etc., but companies interested in further differentiating themselves are beginning to recognize that the content produced on these channels should be part of their Distributed Content Management strategy.  For example, Twitter actively promotes itself as a customer service platform, citing not only its “unparalleled reach,” but the fact that its conversations can be “embedded across other media.” However, many content strategists promote this same approach for curating testimonials.  Curating and embedding tweets in which a user speaks positively about a company’s product is a great example of managing distributed content to increase potential buyers’ social trust in a product.

Use Case 4: Content For Contributors and Existing Customers

Prospective users are not the only audience for product companies.  Physical product companies, especially those making electronics, often provide access to support resources, such as frequently asked questions and downloadable product manuals. Companies that produce digital products may offer software downloads and updates or, in the case of open products, API and developer documentation.  With each of these areas comes important decision around a company’s approach to Distributed Content Management.  Will product support require registration?  If so, what external system integrations are required to share the appropriate content with the user?  Will developers be able to contribute documentation?  If so, what kind of publishing workflows will be in place in for community-contributed content?  While each new audience brings additional considerations around Distributed Content Management, it also increases the opportunities to improve a product’s digital experience and extend its reach.

What’s Next?

Now that we have sufficiently explored industry-specific use cases for Distributed Content Management, I’ll move on to discussing prerequisites for proper planning.  Thoughts or questions?  Reach out in the comments below or tweet them to me at @HankVanZile.

Tagged with Comments
Catégories: Elsewhere

Four Kitchens: Trip Report: DrupalCon 2016 — Five Days in New Orleans

ven, 20/05/2016 - 18:14

A mostly full report on what went down last week in the Big Easy, gonzo journalism -style. …

Catégories: Elsewhere

Texas Creative: First Impressions During a Drupal 8 Website Build

ven, 20/05/2016 - 15:00

It’s Official!  We have finished setting up the necessary infrastructure and processes for building client sites in Drupal 8 moving forward.  A lot of that work was done during our first Drupal 8 website build, which is nearing completion.  What follows is a brief glance of my first impressions and future aspirations about Drupal 8 development.

The Project

As website builds worked their way through the pipeline in the first part of 2016, I was on the lookout for the right one to be our first D8 site.  The project I chose is a portal for this company’s contractors to log their daily activity out in the field.  The portal also generates various reports from the activity for our client to use.  This project is unique in a couple of different ways that makes it the clear choice for our first foray into Drupal 8:

Read More
Catégories: Elsewhere

Cheppers blog: Knowledge base for DrupalCamp organizers

ven, 20/05/2016 - 10:05

This year, at DrupalCon New Orleans I was lucky to attend the best community summit I’ve ever been to, with a bunch of great people who were really interested in topics how to grow the Drupal community. As a result of the discussions we had, we decided to start a knowledge base for Drupal event organizers to collect and share tips and tricks. Keep reading to find out more information about the initiative.

Catégories: Elsewhere

Jeff Geerling's Blog: Drupal VM 3 is here!

jeu, 19/05/2016 - 23:33

Drupal VM 3.0.0 "The Light Sailer" was just released, and you can grab it from the Drupal VM website now. We spent a lot of time during DrupalCon New Orleans sprinting on Drupal VM, fixing bugs, and updating ALL THE THINGS to make sure this release solves a lot of pain points for individuals and teams who need a great local development environment.

Let's get right into why this is the best release of Drupal VM EVER!

The fastest and most modern environment

Drupal VM now defaults to Ubuntu 16.04 (which was just released in late April), running MySQL 5.7 and PHP 7. This means you're getting the fastest, most reliable, and most modern development environment for your Drupal 8 projects.

Catégories: Elsewhere

DrupalEasy: DrupalEasy Podcast 177: New Orleans Day 3

jeu, 19/05/2016 - 23:02

Direct .mp3 file download.

Hosts Ryan Price, Mike Anello, Kelley Curry and Anna Kalata are joined by guests Jason Pamental, David Hwang and sometimes co-host Steve Edwards for a DrupalCon New Orleans wrap-up. We also reinvigorate our meetership with David Snopek of our sponsor and hear about the Drupal 6 funeral parade.

Check in to for more episodes from DrupalCon New Orleans 2016.

Follow us on Twitter Intro Music

Jaywalkers Second Line Jazz Band from the Drupal 6 Mourning Party Parade




Subscribe to our podcast on iTunesGoogle Play or Miro. Listen to our podcast on Stitcher.

If you'd like to leave us a voicemail, call 321-396-2340. Please keep in mind that we might play your voicemail during one of our future podcasts. Feel free to call in with suggestions, rants, questions, or corrections. If you'd rather just send us an email, please use our contact page.

Catégories: Elsewhere

Lullabot: DrupalCon New Orleans Wrap–up

jeu, 19/05/2016 - 22:00
Matt & Mike talk with a gaggle of Lullabots about their experiences at DrupalCon New Orleans.
Catégories: Elsewhere

Palantir: Top 5 Takeaways from DrupalCon New Orleans

jeu, 19/05/2016 - 21:36

DrupalCon New Orleans was last week, and it kept us quite busy! Even though we all thoroughly enjoyed the conference and socializing that came with it, now that we've had a few days to reflect, our memories are even fonder. With that, we share our top 5 takeaways from DrupalCon.

5) Drupal 8 is coming into its own

It's no secret that the long development cycle of Drupal 8 created uncertainty for some organizations and agencies alike. But that's all a distant memory now. We saw a significant uptick on the adoption of and migration to Drupal 8 at this year's DrupalCon, and we couldn't be happier. Better still, our hard work on Drupal 8 – in working with Drupal 8 for our clients, contributing to core, as well as helping bring Workbench to Drupal 8 – means we're well suited to take on your Drupal 8 project or provide expert advice on whether or not it's time to migrate based on your organizational goals. Interested in learning more? Let's talk.

4) The sessions and keynotes

Regardless of your area of expertise, this DrupalCon provided a wide range of incredible sessions and daily keynotes; some technical, some about strategy, some about making the workplace better, and everything between. Both Engineer Kelsey Bentham and Account Manager Allison Manley enjoyed Easy Accessibility in Drupal 8. Our Director of Professional Services Ken Rickard enjoyed Jeff Eaton's Recoupling: Bridging Design and Structured Content session and what Dries shared about the Content Workflow initiative. Our Director of Operations Colleen Carroll loved Leaving Drupal by David Hwang (it has a happy ending, promise). Whereas Senior Engineer Andrea Soper stuck to conversations in the hall and hallways where she appreciated the hard work getting the Contrib modules updated for Drupal 8, and that there were frank discussions about work/life balance and the health of team members in both the community and workplace. The list could go on, of course, so let's continue it. Which sessions or keynotes did you enjoy most? Let us know in the comments, or on Twitter @palantir.

3) Workbench!

This indispensable module is ready for Drupal 8 right now, with its component modules closely behind. We talked with a lot of folks about Workbench, and the excitement at DrupalCon was clear. In fact, if you're a user of Workbench in Drupal 7, or are Workbench-curious, we're hosting a free webinar next week as a intro to Workbench in Drupal 8. Sign up right here, and spread the word!

Want to learn more about Workbench for Drupal 8? We're hosting a free webinar on May 24th at 1:00pm CDT, and would love for you to join us. 2) The overall positivity

We'll admit that this is pretty hand-wavey, but if you were there you'd feel it, too. There was a lot of positivity about Drupal this year, proven by those who work on Drupal as a platform, organizations who use Drupal, and even those who are considering Drupal. Virtually everyone we spoke to agreed, and, in fact, some shared such thoughts in our Best of DrupalCon podcast by Account Manager Allison Manley. Don't believe us? Give it a listen!

iTunes | RSS Feed | Download 1) The community

We've said it before, and we'll say it again: as far as Drupal has come as a top choice for countless organizations, it's the community that makes it all possible. DrupalCon truly is a place to learn, share, and, of course, socialize with some of the best and brightest people working in Drupal, and beyond. Thank you for the great times, and even greater conversations.

See you next year!

Missed us at DrupalCon, but want to chat about your project? Let's schedule a time to talk.

Dries image by Susan Coates - Attribution-ShareAlike 2.0 Generic (CC BY-SA 2.0) on Flickr

Catégories: Elsewhere

Acquia Developer Center Blog: Migrate to Drupal 8: A How-To Scan

jeu, 19/05/2016 - 21:31

Can we all agree that it's too early for any kind of definitive guide to Drupal 8 migration?

I think we can, so I won't pretend to wrap up the topic with a neat bow on top.

Whether your starting point is D6 or D7, it's still an adventure to move a site to D8.

It's getting better all the time, of course: hackathon by hackathon. Which means that it's not too soon to get something started to help us all focus on this inevitable task.

Tags: acquia drupal planet
Catégories: Elsewhere

DrupalEasy: DrupalEasy Podcast: New Orleans Day 2

jeu, 19/05/2016 - 19:35

Direct .mp3 file download.

Hosts Ryan Price, Mike Anello, Kelley Curry and Anna Kalata are joined by guests Suzanne Dergacheva (of Evolving Web) Dave Hall (of the newly anointed Drupal 8 Workflow Initiative) and Steve Edwards to discuss Day 2 of DrupalCon. Ryan also breaks into interviews with Symfony's creator, Fabien Potencier, and the local New Orleans Drupal community representative, Eric Schmidt. Finally we hear some fun non-Drupal things each panelist did in the week.

Check in later this week for more episodes from DrupalCon New Orleans 2016.

Follow us on Twitter Intro Music

Glory Glory Code of Conduct from #Prenote

By Adam Juran, Campbell Vertesi and Jeremy "JAM" Macguire


Subscribe to our podcast on iTunesGoogle Play or Miro. Listen to our podcast on Stitcher.

If you'd like to leave us a voicemail, call 321-396-2340. Please keep in mind that we might play your voicemail during one of our future podcasts. Feel free to call in with suggestions, rants, questions, or corrections. If you'd rather just send us an email, please use our contact page.

Catégories: Elsewhere

ImageX Media: Managing the Creative Process

jeu, 19/05/2016 - 18:48

Inherent in the design process is the debate between subjective and objective quality. Can a design be called objectively “good” and, if so, what is it that makes it good? Or is the quality of a design entirely in the subjective eye of the beholder? However, implicit in this debate is the assumption that design is a single thing that can be viewed as a whole, rather than different elements that each play a role in the overall user experience. 

Catégories: Elsewhere Automatically sanitize your database on development environments

jeu, 19/05/2016 - 17:01

You’re developing your site on and you love the fact that you get exact copies of your production site for every Git branch that you push.

But now that you think about it, you realize that all those copies used by your development team to implement new features or fixes contain production data (like user emails, user passwords…). And that all the people working on the project will have access to that sensitive data.

So you come up with the idea to write a custom script to automatically sanitize the production data every time you copy the production site or synchronize your development environments. Next you think of a way to automatically run that script. Possibly a custom Jenkins job that you will maintain yourself. But, of course, you will need to update this Jenkins job for every new project you work on. Plus, you will have to figure out the permissions for this script to give proper access to your site.

But wait, what if I told you that all this hassle can be handled in a simple deployment hook that provides?

Catégories: Elsewhere

Pronovix: Brightcove Video Connect for Drupal 8 - Part 2: Installation & Configuration

jeu, 19/05/2016 - 17:00

Part 2 in a 4-part blog series covering the various aspects of the new Brightcove Video Connect module for Drupal 8. This second part details the Installation & Configuration steps required to get the module up and running properly.

Catégories: Elsewhere

BlackMesh: The DrupalCon NOLA Aftermath

jeu, 19/05/2016 - 16:19


Last week, I attended my fourth North America DrupalCon with the BlackMesh team. I can honestly say that DrupalCon New Orleans has been the best con to date!

If you are unfamiliar with DrupalCon, it is the biggest annual Drupal community event in the world, which brings together developers, designers, strategists, and more to meet, learn, and give back to the community. BlackMesh has been attending DrupalCon since 2008, and throughout the past several years we’ve attended some incredible gatherings.


So, what made DrupalCon NOLA 2016 so great for BlackMesh?

Because it was in New Orleans?

Not exactly, but that was a huge perk! The sun was out, the food was good, and the music was loud.


Quality trumps Quantity

The Drupal Association and community have done a great job reaching out to new people and getting them involved in this conference. Because there was a greater variety of sessions and summits at this year’s DrupalCon, we talked with more than just developers – we met government agency representatives, business executives, and entrepreneurs who were highly interested in our managed services and kept our team busy … unique needs mean quality leads!

It was wonderful to meet so many new people, and in a way – I am quoting a friend of mine – it was like “summer camp.” It was great to see so many old friends!


Drupal & Government

This year entailed an entire summit devoted to Drupaling for government; our president, Eric Mandel, and our CTO, Jason Ford, attended the event, which consisted of a very insightful panel discussion regarding Drupal development and hosting for city, state, and federal governments.

I unfortunately could not attend, but talking with Eric and Jason afterward I could hear their excitement as they shared with me their summit experience. They had some phenomenal conversations with fellow attendees; government employees and contractors spoke openly about what works best for them, which Eric and Jason said was very beneficial and insightful. The summit also offered a new focus on security, especially in regard to recognizing that rather than being a hindrance to agencies, it needs to be part of the solution. Finally, Larry Gillick, Deputy Director of Digital Strategy, Department of the Interior, gave a fantastic presentation about the DOI PaaS and its success – the guys found this truly informative and motivating.

Party Time

My personal favorite highlight of the week was the BlackMesh Happy Hour event at The Jaxson. It is located at the Jackson Brewery with a fantastic view of the Mississippi River. With flashing Mardi Gras beads, cold beverages on tap, and incredibly fun people, it was truly a BlackMesh party, New Orleans style!

Thank you to everyone who came out – you can see all of the photos of the event here!


Brand Recognition

It was amazing to have a significant number of attendees – particularly first time attendees – approach us because they’ve heard about the good work BlackMesh does in the Drupal community. We even spotted people wearing BlackMesh shirts from previous DrupalCons (our super soft t-shirts have seem to be a big hit every year). What a great feeling!

Brand awareness is more than just creating word-of-mouth buzz, it is seeing someone at the airport wearing a BlackMesh t-shirt. :-)


Looking Forward

DrupalCon is one of our best events of the year. With all the inspiring sessions, late (but fun) nights out, and productive discussions, it’s no wonder why we at BlackMesh are already looking forward to the next conference … get ready, Dublin!

DrupalDrupalCon New Orleans
Catégories: Elsewhere

Matt Glaman: Drupal Commerce and Migrate status

jeu, 19/05/2016 - 15:55
First Steps

Plans were made back in December 2015 to put effort into the ability to support Migrate with Drupal Commerce to speed up adoption of Drupal Commerce 2.0. Commerce Migrate for Drupal 8 will provide migrations from Drupal Commerce 1.x, Ubercart for D6, and Ubercart for D7. Ideally, this module will also support other vendors, such as Magento and WooCommerce.

Before official work began on the 8.x branch, we had a contributor start with an Ubercart 6 port! Contributor  created a sandbox fork and commenced on the Drupal 8 work. The code as mentioned earlier has been working for creativepragmatic to continue development for their Drupal 6 to Drupal 8 site migration.

Midwest Drupal Camp

 kicked off the official start of the Commerce Migrate 8.x branch. This was the merger of creativepragmatic's work. I sprinted on creating a database test fixture for Commerce Migrate's tests. I chose the Commerce Kickstart 2 demonstration store as our test base! So that means all tests are proving we can migrate a Commerce Kickstart 2 demo site to Drupal Commerce 2.x. Work was somewhat slow and stopped short, as 8.1.x was pending to be released and saw a change to how Migrate worked: "." We left MidCamp, however, with the database test fixture and initial tests and migration components.

DrupalCon New Orleans

Work on Commerce Migrate remained on pause until DrupalCon New Orleans. By this time Drupal 8.1.1 was released and the Migrate module was slightly more mature. Our focus during the conference was to push forward the Commerce 1.x to Commerce 2.x migration path since there is a method to test it.

During DrupalCon, a few conference goers approach the booth with questions about Ubercart D6 to Commerce 2.x sites. As mentioned previously, creativepragmatic wrote the initial code. Until there is a sanitized sample dataset, we cannot fully work on the Ubercart migrations or guarantee them. (If you have data you would like to contribute, please contact me!)

Headway was made, however, on the Commerce 1.x migration front. Tests have updated to the kernel test format, a change in Migrate. These tests are now passing on billing profile, line item, and product (variations in 2.x) and product type entities. A process plugin to handle migrating Commerce Price fields from 1.x to 2.x was added and is running on product and line item values. Other fields do not yet to have a supported migration.

What is next?

The next steps are to provide a process plugin to migrate Addressfield field data to the field provided by Address. We also must create process plugins for each of the reference fields provided by Commerce 1.x: product, profile, and line item. With these items completed, orders will be able to be completely migrated.

The largest task will be the migration of Commerce 1.x product displays to Commerce 2.x product entities. This requires finding nodes that have a product reference field.

While migrating from an existing site and data might not quite work, yet, you can start using Migrate to import data. See the Commerce Demo module I am working on: It provides an example of importing a CSV that you might receive from an ERP/PIM and creates Drupal Commerce products, variations, and attributes.

Also, check out creativepragmatic's original work, which has some documentation on initial migration gotchas:

Catégories: Elsewhere

Blair Wadman: Create a Drupal 8 module using the Drupal Console

jeu, 19/05/2016 - 11:00

Developing custom modules in Drupal 8 is a daunting prospect for many. Whether you're still learning Drupal 7 module development or are more experienced, Drupal 8 represents a significant shift in the underlying architecture and the way modules are constructed.  

Catégories: Elsewhere

Larry Garfield: HTML Application or Network Application?

jeu, 19/05/2016 - 08:45

There has been much discussion in the last few years of "web apps". Most of the discussion centers around whether "web apps" that do not degrade gracefully, use progressive enhancement, have bookmarkable pages, use semantic tags, and so forth are "Doing It Wrong(tm)", or if JavaScript is sufficiently prevalent that a JavaScript-dependent site/app is reasonable.

What I fear is all too often missing from these discussions is that there isn't one type of "web app". Just because two "things" use HTTP doesn't mean they're conceptually even remotely the same thing.

read more

Catégories: Elsewhere blog: The Complexity

jeu, 19/05/2016 - 04:06

At DrupalCon New Orleans, during both Dries's keynote and at the State of Drupal Core Conversation, question of whether/when to move to Github came up again.

Interestingly, I was already deep into researching ways we could reduce the cost of our collaboration tools while bringing in new contributors. This post is meant to serve as a little history of how we got to where we are and to provide information about how we might choose to go forward.

It's complex

To say is complex is an understatement. There are few systems with more integration points than and its related sites and services.

The ecosystem is complex with lots of services that share integrations like login (Bakery single sign on) and cross-site code/themes.

It all starts with the code

The slogan "come for the code stay for the community" is accurate. The community would not exist without the unifying effort of collaborating to create the code. The growth of the community is primarily because of the utility the code provides and the (relative) ease of creating a wide range of websites and applications using Drupal core combined with contributed modules and themes that allow that framework to be extended. was an extension of the development of Drupal for a very long time. Up until Drupal 6, was always upgraded the day of the release of a new version. When Drupal was smaller with a more limited scope, this made a lot of sense. With the release of Drupal 6 and the surge in usage of Drupal, more and more contributors started working on the infrastructure and creating new sites and services to speed the collaborative work of the community.

One of the biggest transitions during the Drupal 6 lifecycle and community surge was The Great Git Migration. Much of the complexity of and the related sites and services was created during this time period. Understanding that timeline will help in understanding just how much work went into and Drupal at that time.

The Great Git Migration

In the Great Git Migration, all of the history of Drupal code was migrated to Git from CVS. The timeline for migrating to git was about what you would expect. Community conversation took time, getting volunteers to start the process took time, finally, there was a phase were dedicated (paid) resources were contracted to finish the work.

Our repos are vast

We have over 35,000 projects that total over 50 GB on disk.

All of the Git repos on are associated with Projects.(e.g. modules, themes, distributions, etc.)

We have issues

At the end of 2015, there were nearly 900,000 issues on Drupal core alone has over 74,000 issues—over 14,000 of those issues are open. Open issues is not an indicator of code quality, but it is an indicator of how many people have contributed to a project. In general, the more issues a project has, the more challenging it is for maintainers to continuously triage those bug reports, feature requests, plans, tasks and support requests.

The issue queues are part project management, part bug tracking. As such, they are organic and messy and have lots of rules that have been documented over years of community development. We have 23 pages of documentation dedicated to explaining how to use the issue queues. There is additional documentation dedicated to how to properly fill out an issue for core, for, and for numerous other contributed projects.

Issues are integrated into collaboration on

Those issues belong to projects and are connected to the Git repos through hooks that show a system comment when an issue is related by node ID (issue number) to a commit in Git.

Issues can have patches uploaded to them that are the primary means of suggesting a change to code hosted on The patch-based workflow has extensive documentation, but it is not a simple task for a novice user to jump in and start contributing.

Most Git hosting solutions (Github, Gitlab, Bitbucket, etc.) either have some version of an issue or at least integrate with an issue tracking system (Jira, Pivotal Tracker, etc.) and provide pull request functionality (a.k.a. merge requests).

Having the same name is where the similarities and consistencies stop. Issues on have status, priority, category, component, tagging and more that are unique to Drupal project workflow. It would be a significant exercise to remap all of those categorizations to a new system.


If the projects are what you can browse and find, and the issues are how you collaborate and change the code, the next most important service for Drupal is likely the packaging system.

Packaging is based on project maintainers creating a release of the code by associating a branch of the Git repository with the release. Every 5 minutes, our automation infrastructure checks for new releases and will package those releases into a downloadable file to represent the project.

Few developers actually access this directly from the project page anymore. They are much more likely to use Git, Drush, Console or Composer to automate that part of the workflow. Drush, and to some extent Composer, both use the packaged files when a command is issued. Also, the Drupal feature of just putting the code in the correct directory and it will run—with no compiling—is fundamental to the history of Drupal site building.


Another crucial Drupal service, updates is built into how Drupal core checks on itself to see if it is up to date.

The 1.3 million plus websites that call home to get back XML that is then parsed by that installation's update status module; that updates module has different names depending on the version of Drupal. Each month, about 12 terabytes of traffic to our CDN is requests for updates XML. Considering this is a bunch of text files, this is an amazing number to consider. Some sites call home once a week, some once a day, and some do it every few minutes. (Really people! Be nice to your free updates service. Telling your server to ask for updates daily is plenty frequent enough.)

Tallying the unique site keys that request this information is how we get our usage statistics. While this is probably not the most precise way to measure our usage, it is directionally accurate. There are plenty of development sites in those stats and plenty of production websites that don't call home. It should roughly balance out. To be anymore precise, users of Drupal would have to give up some privacy. We've balanced accuracy with privacy.

Because of our awesome CDN (thanks, Fastly!), we are able to deliver up to date packages and updates information in milliseconds after we update the underlying data.


On May 3rd, we launched the alpha version of our Composer endpoints on If you don't know about Composer, you should read up on it. Composer is package management for PHP. (It's similar to what NPM does for Node.js or RubyGems does for Ruby.)

Core developers have been using Composer for some time as a means to manage the dependencies of PHP libraries that are now included in core.

The Composer endpoints allow any Drupal site developer to use composer install to build out their websites.

The new Composer service will also allow contrib project maintainers to using composer.json files to define the requirements for their modules and themes. The service even translates project release versions into semantic versioning. Semantic versioning was the biggest reason we could not "just" use like other projects in the PHP community.

This is all a huge benefit, but more importantly, we now have deep integration between a best practice approach to PHP dependency management and the code repos that can scale to our community needs.

Testing with DrupalCI

Speaking of needs, DrupalCI ran 67,000 test runs in January 2016. Each test run for Drupal core has 18,511 tests per run. That means over 100,000 assertions (steps) in the unit and functional tests that make sure Drupal's code is stable and that an accepted patch does not create a regression.

At the time of this post, we are using Amazon Web Services cc2.8xlarge EC2 spot instances for our testbots. These bots are powerful. They have 2 processors with 8 hardware cores. AWS claims they can provide 88 EC2 compute units per instance. They are packed with processing power because we have a lot of tests to run. While there are bigger instances, the combination of price and power allows us to keep Drupal core complete test runs right around 30 minutes. We autoscale up to 20 of these instances depending on demand, which keeps queue times low and allows maintainers to get quick feedback about whether a patch works or not.

I truly believe that getting DrupalCI up and stable is what allowed Drupal 8 to get to a full release last fall. Without it, we would have continued to struggle with test times that were well over an hour and a system that required surplus testbots to be manually spun up when a big sprint was happening. That was costly and a huge time waste.

If anyone asks me "what's the most important thing your team did in 2015", I can unequivocally say "unblocking core development to get Drupal 8 released."

Issue credits

The second most important service we built in 2015—but certainly the more visible—is a system for crediting users and organizations that contribute on

Issue credits sprang forth from an idea that Dries proposed around DrupalCon Austin in June of 2014. At the time, his intent was a means of structuring commit messages or using commit notes to provide the credit. Eventually, we shifted the implementation to focus on participation in issues rather than code commits. This made it possible to credit collaboration that did not result in a code change.

I won't get into the specifics; I wrote a A guide to issue credits and the marketplace earlier this year. Issue credits have been extremely successful.

As there name implies, we store the data about credits as a relationship to closed issues. Issue credits touch issues, projects, users, organizations and the marketplace on

Why not just migrate all of this complexity to Github?

Why can't we just move all this to Github?

— said lots of people, often

To be fair, this is a challenging discussion. Angie Byron (webchick) wrote an amazingly concise summary of the Github issue on

That wiki/discussion/bikeshed was heated. The conversation lasted over two years. I started as CTO about 6 months into the conversation. Along with a couple of other themes, the Github move has been a constant background conversation that has defined much of my time leading the team.

How are these services connected?

To truly understand the problem of a migration of this scale, we have to look at how all of the major services are connected.

Each block in this diagram is a service. Each line is a point of integration between the services. Some of these services are on or subsites with thousands of lines of custom code defining the interactions. Other services are not built in Drupal and represent projects in Java (Jenkins) or Python (our Git daemon) with varying degrees of customization and configuration.

As the diagram suggests, it is truly a web of integrations. Pull one or more services out of this ecosystem and you have to either refactor a ton of code or remove a critical component of how the community collaborates and how our users build sites with Drupal.

It's kinda like a great big game of Jenga.

What would a migration to Github require?

Please believe me when I say that if it were "easy" or "simple", we would have made either moved to Github or at least upgraded our Git collaboration with nifty new tools on our own infrastructure.

However, disrupting the development of Drupal 8 would have been devastating to the project. We were correct to collectively backlog this project.

So if we were to try this migration now, what would it take? First, you have to consider the services that Github would effectively replace.

Github replaces:

  • Git repositories
  • Issues
  • Patches (they would become pull requests)
  • Git viewing (and we'd get inline editing for quick fix and onboarding)

That's four (4!) services that we would not have to maintain anymore. Awesome! Cost savings everywhere! Buy a boat!

Wait a second. You have 16 integration points that you need to refactor. Some of them would come with the new system. Issues, pull requests, repos and the viewer would all just work with huge improvements. That leaves us with 12 integration points that would require a ton of discovery and refactoring.

  1. Users - we have 100,000 users that are pretty engaged. (We have over 1 million user accounts—but that number is likely a little inflated by spam accounts.) Do we make them all get Github accounts? Do we integrate Github login to Do we just link the accounts like Symfony does?
  2. Projects - Github is not a project browsing experience. is a canonical repository where the "one true project" lives for packaging and updates. At the very least, we have to integrate our projects with Github. Does that mean we have to keep a Git repo associated to the project that has hooks to pull in changes from Github?
  3. Testing - One of the less complex integration refactors would be getting DrupalCI integrated with pull requests. That effort would still be a months long project.

And DrupalCI would be its own effort to migrate to another testing service because it is tailored to the issue queue workflow and tightly integrated with projects.

Those are just a few of the major integration points.

I have a personal goal to detail every single integration and get that documented somewhere on I don't think that level of documentation will increase the ability for others to contribute to the infrastructure—though that would be a pleasant side effect. I do think it is necessary for us to continue to support and maintain our systems and ensure that all of the tribal knowledge from the team can be passed on.

What would it cost?

I have joked that it would take roughly 1 million dollars (USD) to complete a Github migration. (Cue Dr. Evil.) That is only partially meant in jest.

As anyone who has estimated a large project knows, there is a point of uncertainty that leads project owners to guess at what they are willing to pay for the project.

If we take the four biggest lifts in the Drupal project's history, what do we get?

  1. redesign - There were tens of people involved in the project, hundreds giving feedback. The timeline was about a year from start to implementation.
  2. The Great Git Migration - There were tens of people involved in the project. Far fewer users gave feedback, but the project took about two years from brainstorming to initial commit to the Git repos—with a few months of clean up after.
  3. upgrades to Drupal 7 - The project took about two years with tens of people involved in about 8 months of clean up issues.
  4. Drupal 8 - 5 years of development by over 3,000 contributors.

I don't think than anyone would argue that each of these projects would have been bid at well over $1 million. I would put a migration to Github at somewhere between the complexity of The Great Git Migration and Drupal 8.

In none of these cases did the Drupal Association actually spend $1 million USD in project dollars. However, in all of the projects, there was lengthy discussion followed by substantial volunteer contribution, and then a significant bit of paid work to finish the job. It's a pattern that makes sense and will likely repeat itself over and over.

Would it be worth it?

I'm going to go back to the summary on the Github discussion. There are reasons why both options seem to be the best possible option or the worst possible option.

Would a best practice workflow and toolset be worth the change? Absolutely. Github (or Gitlab) tools are easier for newcomers to learn. Further, because we are using PHP and Javascript libraries that are hosted on Github, we could get contributions from developers and designers that are involved in those projects and do not wish to have account on

The drawbacks are considerable. We cannot afford a full migration right now. Dries put it well at DrupalCon Los Angeles during core conversations. The Drupal Association is not a bag of money. With significant growth of revenue, there is a long term possibility of more paid developer resources, but not in the short term. It is too much to ask volunteers to give up a year of their life to run the project as a community initiative. That leads to burn out and frustration.

We should also consider whether the disruption to the current collaboration workflow will be worth it. I don't think so. Not if that disruption meant stalling the update of contrib projects that are critical to solidifying Drupal 8 adoption. (Though I could argue that much of this upgrade to Drupal 8 work is being performed on Github as some—perhaps many—developers prefer those tools.)

Is there a middle ground?

Drupal spends a lot of time getting to the middle ground. Many of the best innovations in Drupal come from getting to the middle ground—from reaching a general consensus and then allowing someone who has support and time iron out the details.

So for the first step, we should add functionality to projects on that allow maintainers to shift their workflow to Github while still publishing their project on This allows the canonical browsing of projects, the continued support of the security team, and most importantly the continued distribution of Drupal through Composer, release packaging and the updates system.

We have a solid way forward for these integrations as the requirements are narrow enough in scope to accomplish in a 4-6 month timeframe using dedicated resources. We would still need to figure out how to award an issue credit to someone that participated in an issue on Github. We might be able to institute commit credits that could be parsed into issue credits from the participation on Github, but it would not be as inclusive as the current model.

It would be important to phase in this new feature rather than make a wholesale change. Once that integration is in place, we could extend DrupalCI to test pull requests similar to how we currently test patches submitted to an issue.

Stay flexible

We need to be flexible. GitHub has a lot of potential as tool for open source distribution and collaboration—likely for the foreseeable future. However, not every major project is on GitHub. The Linux Kernel uses Git repositories with cli tools and a patch-based workflow that relies heavily on email. It works for them. Wordpress is still on Subversion—even though they've started to accept some pull requests on GitHub. These projects are poised to make the right decision rather than a rash decision.

The sky will not fall if we keep our current model, but we are losing opportunities to grow as a community of contributors. Rather than a wholesale migration, we must understand the value and history of this web of integration points. Targeting our efforts on specific integrations points can achieve our goal of opening our doors to the developers who live and breathe GitHub, without losing the character of our collaboration. And in the long run, this focus on services and integrations can make us more adaptable to the next change in the broader development landscape.

Republished from

Catégories: Elsewhere

Lullabot: Rebuilding POP in D8 - Development Environments

jeu, 19/05/2016 - 00:30

This is the second in a series of articles about building a website for a small non-profit using Drupal 8. These articles assume that the reader is already familiar with Drupal 7 development, and focuses on what is new / different in putting together a Drupal 8 site.

In the last article, I talked about Drupal 8's new block layout tools and how they are going to help us build the POP website without relying on external modules like Context. Having done some basic architectural research, it is now time to dive into real development. The first part of that, of course, is setting up our environments. There are quite a few new considerations in getting even this simple a setup in place for Drupal 8, so lets start digging into them.

My Setup

I wanted a pretty basic setup. I have a local development environment setup on laptop, then I wanted to host the code on github, and be able to push updates to a dev server so that my partner Nicole could see them, make comments, and eventually begin entering new content into the site. This is going to be done using a pretty basic dev/stage/live setup, along with using a QA tool we've built here at Lullabot called Tugboat. We'll be going into the details of workflow and deployment in the next article, but there is actually a bunch of new functionality in Drupal 8 surrounding environment and development settings. So what all do we need to know to get this going? Lets find out!

Local Settings

In past versions of Drupal, devs would often modify settings.php to include a localized version to store environment-specific information like database settings or API keys. This file does not get put into version control, but is instead created by hand in each environment to ensure that settings from one do not transfer to another inadvertently. In Drupal 8 this functionality is baked into core.

At the bottom of your settings.php are three commented out lines:

# if (file_exists(__DIR__ . '/settings.local.php')) { # include __DIR__ . '/settings.local.php'; # }

If you uncomment these lines and place a file named settings.local.php into the same directory as your settings.php, Drupal will automatically see it and include it, along with whatever settings you put in. Drupal core even ships with an example.settings.local.php which you can copy and use as your own. This example file includes several settings pre-configured which can be helpful to know about.


There are several settings related to caching in the example.settings.local.php which are useful to know about. $settings['cache']['bins']['render'] controls what cache backend is used for the render cache, and $settings['cache']['bins']['dynamic_page_cache'] controls what cache backend is used for the page cache. There are commented out lines for both of these which set the cache to cache.backend.null, which is a special cache backend that is equivalent to turning caching off for the specified setting.

The cache.backend.null cache backend is defined in the file, which is by default included in the example.settings.local.php with this line:

$settings['container_yamls'][] = DRUPAL_ROOT . '/sites/';

If you want to disable caching as described above, then you must leave this line uncommented. If you comment it out, you will get a big ugly error the next time you try and run a cache rebuild.

Drush error message when the null caching backend has not been enabled.

The file is actually itself a localized configuration file for a variety of other Drupal 8 settings. We'll circle back to this a bit later in the article.

Other Settings

example.settings.local.php also includes a variety of other settings that can help during development. One such setting is rebuild_access. Drupal 8 includes a file called rebuild.php, which you can access from a web browser in order to rebuild Drupal's caches in situations where the Drupal admin is otherwise inaccessible. Normally you need a special token to access rebuild.php, however by setting $settings['rebuild_access'] = TRUE, you can access rebuild without a token for specific environments (like your laptop.)

Another thing you can do is turn on or off CSS and Javascript preprocessing, or show/hide testing modules and themes. It is worth taking the time to go through this file and see what all is available to you in addition to the usual things you would put in a local settings file like your database information.

Trusted Hosts

One setting you'll want to set that isn't pre-defined in example.settings.local.php is trusted_host_patterns. In earlier versions of Drupal, it was relatively easy for attackers to spoof your HTTP host in order to do things like rewrite the link in password reset emails, or poison the cache so that images and links pointed to a different domain. Drupal offers the trusted_host_patterns setting to allow users to specify exactly what hosts Drupal should respond to requests for. For the site, you would set this up as follows.

$settings['trusted_host_patterns'] = array( '^www\.example\.com$', );

If you want your site to respond to all subdomains of, you would add an entry like so:

$settings['trusted_host_patterns'] = array( '^www\.example\.com$', '^.+\.example\.com$', );

Trusted hosts can be added as needed to this array dependent on your needs. This is also something you'll want to set up on a per-environment basis in a local.settings.php, since each environment will have its own trusted hosts.

Local Service Settings

When Drupal 8 started merging in components from Symfony, we introduced the concept of "services". A service is simply an object that performs a single piece of functionality which is global to your application. For instance, Symfony uses a Mailer service which is used globally to send email. Some other examples of services are Twig (for template management) and Session Handling.

Symfony uses a file called services.yml for managing configuration for services, and just like with our settings.local.php, we can use a file called to manage our localized service configuration. As we saw above, this file is automatically included when we use Drupal 8's default local settings file. If you add this file to your .gitignore, then we can use it for environment-specific configuration just like we do with settings.local.php.

The full scale of configuration that can be managed through services.yml is well outside the scope of this article. The main item of interest from a development standpoint is Twig debugging. When you set debug: true in the twig.config portion of your services configuration file, your HTML output will have a great deal of debugging information added to it. You can see an example of this below:

Drupal page output including Twig debugging information.

Every template hook is outlined in the HTML output, so that you can easily determine where that portion of markup is coming from. This is extremely useful, especially for people who are new to Drupal theming. This does come with a cost in terms of performance, so it should not be turned on in production, but for development it is a vital tool.

Configuration Management

One of the major features of Drupal 8 is its new configuration management system. This allows configuration to be exported from one site and imported on another site with the ease of deploying any other code changes. Drupal provides all installations with a sync directory which is where configuration is exported to and imported from. Be default this directory is located in Drupal's files directory, however this is not the best place for it considering the sensitive data that can be stored in your configuration. Ideally you will want to store it outside of your webroot. For my installation I have setup a directory structure like this:

Sample Drupal 8 directory structure.

The Drupal installation lives inside docroot, util contains build scripts and other tools that are useful for deployments (more on this in the next article) and config/sync is where my configuration files are going to live. To make this work, you must change settings.php as follows:

$config_directories = array( CONFIG_SYNC_DIRECTORY => '../config/sync', );

Note that this will be the same for all sites, so you will want to set it in your main settings.php, not a local.settings.php.

Having done all this, we are now setup for work and ready to setup our development workflow for pushing changes upstream and reviewing changes as they are worked on. That will be the subject of our next article so stay tuned!

Catégories: Elsewhere