Apr 05 2018
Apr 05

Last year one of the big topics for the Drupal Global Training Days (GTD) Working Group was sorting out what exactly we can do to help with organizing these events. To that end, we sent out a survey to learn more about the kinds of events that people doing GTD events run, or have offered in the past, and how the community can help. We got 33 responses to the survey and 9 of those fine folks also hopped on a phone call with us (myself (add1sun), Mauricio (dinarcon), or Marina (paych)) to talk about the survey answers in more depth. While it's been a little while since we conducted the survey and interviews, we figure this is really interesting and useful information to share with the community.

The first section of this post covers the questions we asked and the results on the survey. The second section dives into our takeaways from the interviews we conducted after the survey.

Survey Results

What is your motivation for organizing GTD?

Far and away the most common motivation for running GTD events is to grow the local Drupal community, with over 90% selecting this as at least one reason. The second biggest motivation (39%) was to promote a company or organization, which was then followed up equally at 24% with finding new hires or new clients.

Is your company sponsoring your time to prepare and present the training?

For this question, about 60% of respondents have their company cover their time. There was also a mixed bag of people who are their own business or who freelance, where counting company versus personal time is a blurrier line, as well as people who straddle both, doing some of the work on the clock and the rest on their own time. 21% of those surveyed stated that they are not supported by a company for GTD events.

In which country (and city) have you organized a GTD?

Our list from the survey covered 36 events in 18 different countries, plus an online course with attendees from all over the world.

  • Argentina
  • Australia
  • Bolivia
  • Brazil
  • Cameroon
  • Canada
  • China
  • Costa Rica
  • France
  • India (5)
  • Italy
  • Japan
  • Mexico (3)
  • Moldova
  • Romania
  • Russia
  • Slovakia
  • South Africa
  • United States (11)

In which languages have you organized GTD?

23 (64%) of events are being offered in English. There were 12 languages other than English in the list, with Spanish taking the number 2 slot with 6 events, which lines up with the number of events in Spanish-speaking countries.

Given the wide range of countries, it is a little surprising that there is definitely a concentration of events that are offered in English.

What materials do you use to present the training?

This was split almost evenly between those that use materials they created themselves and those that use a combination of existing materials and their own.

What topics have you covered in the trainings you have presented?

113 responses (with multiple select) indicated almost everyone covers more than 1 topic, and the vast majority of those topics are introductions to Drupal and getting started. Of the topics presented:

  • 94% cover What is Drupal?
  • 85% do Site Building
  • 70% cover the Drupal Community
  • 51% do Theming
  • 42% do module development.

From the results to this question it is clear that most GTD events do not stick with just one broad topic.

What format do you usually follow?

The most popular format (76%) is to have the instructor do a live demonstration and have the students follow along. Next in line is to only give presentations, and the least popular was to have the instructor do a live demo but not have the students work on the project. There were also a couple of people who use recorded videos and then offer Q&A and support to the students as they work through them.

How long does the training last?

  • 36% give full day workshop
  • 24% give half-day workshops
  • 30% do a mix of the 2 formats.

How many people attend your event on average?

Event size was interesting. Over 50% of events had 11-20 attendees. Smaller groups, from 1-10 came in second around 27%, and only 21% of events had more than 20 attendees.

Choose the statement that fits you most with regards to venue cost

Just over a third of respondents have given events at different free venues, while 21% have access to a permanent free venue to use. 30% have used both free and paid venues. Only 1 person has a permanent paid venue they use for GTD.

What type of venues do you use?

Most events use either a company office or a university/educational facility, with conference spaces and co-working/community spaces making up much of the rest. There were also a range of locations from coffee shops to libraries included.

What is the attendee capacity of your venue?

Compared to the class sizes mentioned above, there is certainly space for bigger groups overall, with 60% of venues capable of accepting over 20 attendees.

If you organize GTD in a paid venue, how much does it cost on average? (Use local currency)

For those who do pay for venues, the costs are all over the place, which makes sense given the huge range of locations (both world location and venue type) for these events. The most expensive came in around $400 USD or ~325 EUR.

Which of the following does your venue provide?

Most venues (88%) provide a good internet connection, and a projector with screen. 21% of the venues provide computers to use. Others noted extras they get with their venues include things like parking, snacks, and coffee.

Interview Results

We also spoke to 9 people from 5 countries to dig into what they're doing and how the community and GTD Working Group can help. While everyone has different struggles and needs, there are a few common themes that come through.

Organizing and Marketing

There was a wide variety of needs around organizing and marketing GTD events. This included things like matching up people who like to teach with people who can organize and market the event (many times people don't really want to both!), and there was definitely a repeated request for marketing materials and guidelines for groups to help promote their events. There were also some interesting ideas like creating badges for trainers and attendees, as well as having better ways for GTD organizers and trainers to share information, either through online knowledge bases or in-person events, like GTD-focused activities at DrupalCons.


Not surprisingly curriculum and course materials came up for a lot of people. As we saw from the survey results, a lot of people create their own materials, often through need, not because they necessarily want to. There was a common thread of requests for workshop agendas, slides, and all kinds of training materials, centrally located so that people could more easily build a workshop without investing a lot of curriculum time. A number of people also pointed out that not having materials in the local language was a problem, and is time-consuming work to translate existing materials.


The last main theme that we saw was about the technical and venue needs. This ranged from funding for space to hold GTDs, having a standard way to get students set up with a local environment, and having a regular way to collect feedback on events, and be able to share that information.

While the GTD Working Group certainly can't tackle all of these things, this gives a good starting point for the biggest pain points that the community can address to accelerate GTDs and the adoption of Drupal. If there are particular topics or initiatives in here that you would like to help with, please reach out to the working group to get connected with others and see what resources are available to help.

Jul 14 2015
Jul 14

Drupalize.Me Tutorial

Object-oriented programming (OOP) is way of organizing your code to be more efficient, and it takes advantage of some really nice features in modern versions of PHP. One of the basic concepts of OOP is, not surprisingly, an object. Directly related to working with objects is understanding PHP classes. Drupal 8 is taking big steps to move to an OOP architecture, and so you will get very familiar with both of these as you start to jump into Drupal 8 development.

This tutorial, based on the video Create a Basic PHP Class, will explain what a class is, show you how to set up a class, and look at a PHP object. By the end of this tutorial, you will be able to create a class, an object, add a property to your object, and set the value of the property inside the class.

Before you get started you should be familiar with PHP development generally, and be comfortable with concepts like variables, functions, and arrays. You can take a look at our PHP for Beginners video tutorials if you need to get up to speed. You'll also need to have a computer running PHP with a web server if you want to see the file in action. You can use the built-in PHP server (video tutorial) or you can set up an AMP stack (Apache, MySQL, PHP). Use whichever you prefer. You can grab the base project files for the OOP series to use, or just create your own.

Classes, Objects, and Properties

Before we create a class and then instantiate an object from it, let's do a quick review of what those are. You can think of a class as a template for making objects. Objects are bundles of information and actions you can take with that information. An object can have properties, which are various characteristics, like a name, or a color. They look very much like a variable. It can also have methods, which are standard functions for things the object can do. When you define a class for something, you set up a template that contains all of the standard properties and methods. You then instantiate an object from that class, and fill in the details for this particular object.

Here is a more concrete example, which we'll be using in this tutorial. Let's say that you are working on a starbase and you are responsible for keeping track of all the ships there. They are all generically "ships" but they each have different characteristics, or properties, which distinguish them from each other. To keep things consistent and organized, we'll create a spreadsheet for all the information we need to track, listing all the properties we will need to fill in. This is our class; our template. When a new ship arrives, we open our template and instantiate a new ship document, which is our object. We will fill in all the details specific to this ship: name, weight, weaponry, etc.

Now you could do similar things with procedural PHP using arrays, variables, and functions for sure. Using classes and objects though introduces more rigor to the data and how it gets used, which makes it more consistent and reusable code. If you think of an array as the equivalent to an object, you can define keys and vlaues in the array, much like properties, which can accomplish the same goal. The problem with arrays though is that anyone could put in whatever key they wanted there. This is more like a spreadsheet template that just has blank spaces you need to fill in. I could decide I wanted to define one ship's color, but skip that for another ship and instead write down it's length in centimeters. Objects let us define the template more clearly, and gives us the tools to enforce it.


Once you have a your PHP ready to go, we're going to create a new file and start adding our PHP to it. In your project create a new PHP file. The example project we are working with lets us create different space ships and then have them battle each other. We're going to use a class to create ship objects and be able to define the properties of each ship. To go along with the example project files, I'm going to call my new PHP file play.php, but you can call it what you like.

1. Creating a class is as simple as typing the class keyword and giving it a name, along with some curly braces, which will contain the default property list for all ships. I'll name my class Ship.

class Ship {
  // Object properties will go here.

2. To create an actual ship object, we need to instantiate the class. You do this by creating a new variable and then using the `new` keyword with our class name.

$myShip = new Ship();

3. So far we don't have any properties defined for our ship, so let's add a property to our class. Within the class' curly braces, add the `public` keyword followed by a name property.

class Ship {
  public $name;

4. Now we can add this property information to the new ship object we've created. We're going to add to the existing object by using the "arrow" (`->`) operator.

$myShip->name = 'Jedi Starship';

If you keep reloading this PHP file in your browser, you're not going to see anything at all, but you now have an object with a property that you can access. Let's print out our ship name to the browser.

5. We can use a simple echo or print statement with our object property. Just like a variable that has been defined, we print it out the same way.

print('Ship Name: ' . $myShip->name);

6. Go to the file in your browser and reload the page. You should see the text displaying your ship name.

Our final code for defining the class, creating a ship object, adding a name property, and then printing it to the screen is:

// Define our class.
class Ship {
  // Define the properties.
  public $name;

// Instantiate a new Ship object.
$myShip = new Ship();
// Define the name property for this Ship object.
$myShip->name = 'Jedi Starship';

// Print the ship name to the page.
print('Ship Name: ' . $myShip->name);

You can download the completed play.php file below. Note that the file has .txt appended to it, so you will need to remove that before it will work in your browser.


In this brief tutorial we've explained the OOP concepts of classes and objects. To put it into practice, we created a new file, made our class, and then instantiated a ship object with a name property. There is a lot more to classes and objects than this very simple introduction. We've just looked at the very basic concepts here, and you'll want to also explore the world of methods, public versus private, and many more features. That belongs in another tutorial though. If you'd like to dive into these right away, you can check out the rest of our Introduction to Object-oriented PHP video series.

May 04 2015
May 04

Drupal 8

In March of this year Drupalize.Me, along with Lullabot, made a donation to become an anchor sponsor for the Drupal 8 Accelerate Fund. We're happy to be a key part of getting this fund kicked off, and the community has been rallying to fill the fund on Crowdrise. In an effort to inspire more donations to the cause we're joining the fundraising team with some fun things that we hope inspire you to contribute as well. If you support Drupal 8 with $50 or more, through our Crowdrise page, we have some good stuff for you. (Keep in mind that all of this is based on donations to the Drupal 8 Accelerate Fund, and we do not receive any of this money ourselves.) We're going to give away one annual Drupalize.Me membership, and we'll be creating some free video lessons.

One Free Annual Membership

To win a free annual membership to Drupalize.Me, all you have to do is donate $50 towards the Drupal 8 Accelerate Fund from our Crowdrise page. We'll automatically put your name in the running for the free membership. We're going to draw the winner on June 5, 2015.

Choose Our Videos

For those who are even more generous with a $100 donation, in addition to getting a chance to win the membership, you will be able to select a video tutorial for us to create and publish for free. We have a list of single-video tutorials below which you can select from. Once you make your donation, we'll get in touch with you, through the email you used on Crowdrise, to choose your video. We'll add that video to our production pipeline and make it available for free. We'll even add your name to the video page, and explain that you generously sponsored the tutorial while also supporting Drupal 8. That's a whole lot of win for $100!

Here are the topics we have to choose from. We'll update the list with taken topics as they go. If you have an idea for a short video topic that you'd like to see, drop us a line and we'll let you know if it's suitable to be added to the list.

  • Reset your user id 1 password with Drush
  • Put fields of a node in a sidebar using just Views
  • Put a carousel on your home page
  • Post to twitter from your site
  • Add proximity search with Geofield
  • Display custom block content in search results (Tojio)
  • Automatically send a confirmation email with Entity Registration
  • Display related content on your nodes (e.g. "More Like This"...)
  • Map locations based on a user's location with Leaflet
  • Use LightBox with Drupal Commerce
  • Create SSH keys (e.g. for use with Git)
  • Install and use the Drupal 8 / Symfony2 bridge plugin in PhpStorm
  • Theme individual fields in node templates
  • Installation and configuration of a module (Note that this applies to most projects on Drupal.org, but we will only create one video tutorial of up to 15 minutes long, so if it is a complex module, or there are many modules in a project, we will only cover what is reasonable in 15 minutes.)

As a community we need to help push Drupal 8 over the finish line. If you have been thinking about donating, this is the time to do it and get even more bang for your buck. Go donate now!

Feb 10 2015
Feb 10

Drupal 8
Over the years of Drupal 8 development we've heard a lot of talk about "Panels in core" or "Blocks everywhere" or "Layout all the things!" and even SCOTCH(?). What does it all mean? Is Panels actually in core? Well, no, but there are some cool improvements in Drupal 8. I decided to follow the breadcrumb trail to figure out what this initiative was really about and how it ended up, now that Drupal 8 is in beta. Join me for a little bit of a trip back through the life of the Blocks and Layouts Everywhere (SCOTCH) Initiative.

Blocks and Layouts Everywhere (SCOTCH) Initiative

In March 2012 Dries announced a new Drupal 8 initiative, called the Layout initiative. A team of core people had taken a look at the Web Services and Context Core initiative (WSCCI, or Whiskey) and decided to narrow the scope of that project to make it more attainable. Part of what was descoped in WSCCI became the new Layout initiative. Since Layout was a subsection of the larger WSCCI (Whiskey) initiative, it got the nickname SCOTCH—scotch being a sub-category of whiskey.

When the initiative was announced the project lead, Kris Vanderwater, wrote up a post about all the work they were shouldering. The core idea is to "provide a standardized mechanism of output, and new tools for placing content on a page." It is addressing the underlying problem that contributed tools like Panels, Context, and Display Suite have been trying to solve in various ways. The idea is to take the best ideas from those solutions and create a unified, core way of handling it. You can see the basic roadmap and some of the progress in the Blocks/Layouts Everywhere Meta issue.

The end goal basically boils down to two main pieces: turn all page output into blocks (using the new plugin system), and add a new layout system that will allow site builders to control their pages. Pretty awesome, huh? Also, a lot of work.

Plugins and Blocks

The first step on the path was to get the new core plugin system settled in, so the new, fancy blocks could make use of it. You can read all the details about plugins in a few articles Joe has written on the topic (Drupal 8 Plugins Explained and Unravelling the Drupal 8 Plugin System).

In addition to the base plugin system, there was a push to make sure plugins could be contextually aware. The idea was to make the new blocks smarter than in Drupal 7, so that we could solve the flexibility problems inherent in the old system. In order to decouple the code that figures out where, and under what circumstances, a block is supposed to show up, new conditional and contextual plugin systems were added to Drupal 8. Both of these systems were largely driven by blocks needing these features, but these new plugin systems can be used anywhere in Drupal now.

With plugins in core, the next step was to get all of the existing Drupal blocks switched over to the new system. Using the plugin system turned the old, pokey core blocks into flexible super-blocks. This allows us to to do cool things like have multiple instances of a block. This was a huge amount of work by a lot of people. It took about a year to get the "blocks as plugins" foundation in place.

With the architectural foundation set, to achieve the fully flexible page components goal, a number of tickets were created to start converting other elements into blocks—things like the site title and logo, menus, and page elements such as title, tabs, messages, etc. The site and menu work was completed in 2014, and the page elements are still a work in progress. Then there are the forms and various page callbacks to tackle. We have a lot of "hard-coded" page elements in Drupal 7, and tracking them all down and turning them into blocks is a long process.

New Layout System

Getting our page elements into a flexible and robust block system was the first major goal of this initiative. The second phase was to get a new layout system in place that would give site builders better control over these blocks. The bulk of this work involved decoupling layouts from themes (that is, in code) and creating a system that could be managed through the UI instead. For the first step, a new module, Layout, was created for Drupal core, which required themes to declare their layouts in this new way. This got committed to core on October 15, 2012 and a new meta issue, [meta] Unified Blocks and Layouts (SCOTCH+WSCCI+Spark+Field UI), was opened to track the next steps needed to accomplish the ultimate goal, and to bring together all of the pieces and projects working in the blocks and layouts space.

Layout Module Removed

Work continued to barrel ahead with both the blocks and layouts work. In 2013 the reality of the Drupal development cycle began to assert itself though. The feature completion phase ended on February 18, 2013, meaning no more big features going in. We needed to move Drupal 8 into the clean-up phase to start nailing down the APIs and rein in the scope. July 1 was set as the API freeze date, where this clean-up phase would end.

As July approached there was a lot of chatter about the state of the Layouts portion of the SCOTCH initiative. The big discussion point revolved around the fact that the new Layout module wasn't actually being used anywhere in core yet, and the API freeze was approaching fast. There simply wasn't time to get the implementation in place, and the UI work for layouts was still a long row to hoe. An issue was opened to remove Layout from core. On August 31, 2013 the Layout module commit was reverted, removing it from core. It made little sense to ship Drupal 8 with unused code.

What Now?

We may not have layouts, but we do have a much improved block system in Drupal 8, and many more elements that are in blocks, making them easier to work with. We also have some pretty kicking underlying context and conditions APIs. To see more of what we do have coming in Drupal 8 from this work, check out Kyle's article and video The Block System is Finally Useful in Drupal 8, and Joe's article and video A Look Inside Drupal 8's Block Plugin API.

The Layout module wasn't discarded when it was removed from core. You can find it and use it in its contributed project form for D7 and D8. (The 7.x version is part of the Spark distribution, the 8.x version is what was in core and removed.) You can bet that people are still working very hard on this concept in the core issue queues. We've moved the issues to target Drupal 9, and the work will keep on chugging away.

The fact that we didn't end up with a new layout system in core may seem like a failure to some, but honestly the scope of these changes was incredibly massive. The amount of work that has gotten in, and the improvements we will see in Drupal 8 are HUGE. I, for one, am incredibly thankful for the work that has been poured into this project, and I have a lot of excitement for what we'll see in Drupal 8. If you'd like to keep up to speed on what is going on with this work, you should check out the Blocks and Layouts Everywhere (SCOTCH) Initiative groups page.

Dec 30 2014
Dec 30

All this excited talk of Drupal 8 has a lot of people dreaming of the day they get to start working with it. Some people get to build new sites from scratch all the time, but a lot of Drupal work out there is maintaining and upgrading existing sites. How will the Drupal 8 upgrade path work, and will it be as shiny as Drupal 8 itself? Well, upgrades will be radically different in Drupal 8, and I'd say it has all the shiny you could possibly want.

What Is This Migrate You Speak Of?

The classic Drupal upgrade method, good ole update.php, will no longer be used for major upgrades (e.g. 7.x to 8.x). That handy little script is only going to work on minor version updates for Drupal 8 (e.g. moving from 8.0.0 to 8.1.0). In place of that script, we now have the Migrate module in Drupal core. Instead of "updating" the site, you will now "migrate" to the next major version. Now, that could sound scary if you've never migrated a Drupal site before, but trust me, this is a great innovation for core.

More and more sites, ours included, have moved beyond the old update.php script. When we upgraded our site from Drupal 6 to 7, we wanted to change a lot of things at the same time. We wanted to take advantage of Drupal 7's new features and apply things we had learned since we built the original site. It made a lot more sense for us to build a new Drupal 7 site the way we wanted it, and then just move our content and users to their new home. We used Migrate module to do this, and more and more people have been using this tactic for big upgrades. (You can learn more about the contributed Migrate module in our Importing Data with Migrate and Drupal 7 series.)

Now, with Migrate moved into Drupal 8, this growing best practice is baked into core. You can use the new core Migrate API to not just upgrade your Drupal 6 or 7 sites to Drupal 8, but you can also use it to create your own migrations from other sources. You could, say, write a migration to move a Wordpress site to Drupal. Or you could even build a new Drupal site, and then fill it up with data from a spreadsheet. The Migrate API gives us a lot more flexibility when working with data we want to pull into our new site.

What's the Current Status?

As with all things Drupal 8, not everything about Migrate in core is complete yet. The Migrate API is in core, as the Migrate module. Additionally there is a Migrate Drupal module, which has the mappings you'll need to upgrade your site to Drupal 8. Currently most things are in place for a Drupal 6 to 8 migration, and the community is looking for people to help by testing it out and seeing where things still need to be tweaked. There is also ongoing work on the Drupal 7 migration as well, but it isn't in core yet. The current plan is to release Drupal 8.0.0 with the Drupal 6 to 8 migration ready to go, and then the Drupal 7 migration will be released with Drupal 8.1.0 or 8.2.0.

Why are we starting with Drupal 6 migrations instead of Drupal 7? Well, it has to do with community support for old versions. When Drupal 8 is released, Drupal 7 will still be supported until Drupal 9 comes out. Drupal 6, on the other hand, is going to lose support (i.e. security updates) three months after Drupal 8 is released. This means that creating a path for folks to move off of Drupal 6 as quickly as possible is a more pressing issue than Drupal 7.

Learn More

There are a lot of resources popping up on the web for Drupal 8 migrations. You can get the basic picture in the Drupal.org handbook pages for Upgrading from Drupal 6 or 7 to Drupal 8. There is actually a lot more useful information right now in the Introduction to migrate D6 to D8 subpage.

To get your feet wet, start playing around, and help with testing, here are a few good resources to get you started:

  • The IMP (Import API in Drupal 8) group has instructions, and some videos on their Getting ready to help out with Migrate in Core page.
  • Metal Toad series of Migrate posts, covering both the current core Drupal 6 upgrade, and how to write your own Drupal 7 migration.
  • Melissa Anderson's (eliza411) Drupal 6 to 8 Upgrade Challenge series, where she goes through a thorough step-by-step process for testing a Drupal 6 upgrade. (This is a new series that has just gotten started, and it looks to be a great walkthrough of the entire process.)
  • Code Drop has a video (with no sound) that shows you what the Drupal 6 to 8 upgrade process actually looks like.

And, last but not least, if you'd like to get more involved with this effort, you should join the IMP group.

Dec 16 2014
Dec 16

YouTube is a great service for storing and managing your videos. While this is handy, many people want to be able to display their videos within their own website as well. You can easily copy the embed code from YouTube and paste that into your content body field, but that only works properly if you have your text formats set up correctly, and you may not want to open that up to just anyone. You also have no way of keeping track of the videos from within your site. This is where the Media, Media Internet Sources (part of the Media package), and Media: YouTube modules can help give you a nice, seamless way to integrate YouTube videos into your site, and give really nice control over how those videos look, along with some built-in media management tools.

This tutorial, based on the free Embed YouTube Videos video from the Working with Media Module in Drupal 7 series, expects a basic understanding of the 1.x Media module. We're using 1.x because that is the current stable release, and version 2 is still in an alpha state. We're starting off with the assumption that you have a Drupal 7 site up and running, with the Media and Media: YouTube modules already downloaded and ready to go. At the end of this tutorial you will have a new video content type created, with a YouTube field that lets you paste in a YouTube video URL or embed code. We'll be diving into Media's file display settings to also make sure the embedded video displays we way we want in different contexts.

The key to making all of this work is the Media Internet Sources module, provided as part of the Media package. Without getting into lots of details, this module provides a standard mechanism for handling stream wrappers, which means you can ingest a lot of different internet services. This is a base module that you use combined with specific provider modules, which extend Media Internet Sources for use with a particular service. You can see a list of the various providers you can use on the Modules that Extend the Media Module page, under the Provider Projects section. We're focused on YouTube videos here, but you can use this same base to integrate many different services into your site.


So let's get started! We're going to enable the modules we need, and then build out the content type. Once that's in place, we'll grab a video URL and make our first video node. To clean things up, we'll dive into Media file display settings and make sure the video displays just the way we like it.

Create the Video Content Type

  1. In the Administrative menu, go to Modules (admin/modules).
  2. Enable the Media, Media Internet Sources, and Media: YouTube modules (located under the Media section).
  3. In the Administrative menu, go to Structure > Content types (admin/structure/types), and click on the "Add content type" link.
  4. Type Video in the Name field, and leave all other defaults. Click the "Save and add fields" button.
  5. Add a new field called YouTube video with the following settings:
    Field name Value Label YouTube video Field Type File Widget Media file selector
  6. Click "Save" and then accept the defaults for the Field Settings screen, and click "Save field settings." Note that we are not going to actually upload any files to this field since we're using an embed, so the upload settings can be ignored.
  7. Complete the Video field settings using the following values, leaving any others at their defaults:
    Field name Value Label YouTube video Required Checked Allowed remote media types Video Allowed URI schemes youtube:// (YouTube videos)
  8. Click the "Save settings" button.

Create a Video Node
Now that we have a content type, go ahead and create a new video node as you normally would, entering whatever text you want for the Title and Body fields. When you come to the YouTube video field:

  1. Go to YouTube.com, find a video you like, and copy either the URL or the embed code from underneath the video player, under the "Share" tab. (You can also just grab the URL from your browser's address bar.)
    YouTube video links
  2. Back on your node creation form, click the "Select media" button. This will pop open a media selector.
  3. Click on the "Web" tab, and paste your YouTube video information into the URL or Embed code field. Click "Submit."
  4. Save the node.

Fix the Video Field Display
You'll see that our video is not actually showing up as a video player, but as a link instead, so we need to go tweak the field display.

  1. In the Administrative menu, go to Structure > Content types (admin/structure/types), and click on the "manage display" link for the Video content type.
  2. Update the settings for the YouTube video field as follows:
    Field name Value Label hidden Format Rendered file
  3. Click "Save" and close the overlay. Our video is now displaying as a playable video player.

Modify the Media File Display
The content type is now working as expected, and displaying my video properly, but if you go back and edit this node, you'll notice that we have the same large player displaying on the edit form, and this is actually covering up some important functions, like being able to remove the video from the field. We'll finish this up by fixing that, and getting to understand how you can manipulate the video file display from within your own site. Much like content types, Media field types have different view modes. On a content type, these are things like Default, Full node, or Teaser. On a field type, you have Default, Preview, Large, etc. We need to fix the Preview view mode that is being shown on the node edit screen, as right now it is just falling back to the Default mode that the node is using.

One important thing to note is that the "file display" is what we are looking for here, not "manage display." The file display digs into the file itself, while manage display for the file types lets us control meta information about the file.

  1. In the Administrative menu, go to Configuration (admin/config) and click the "File types" link (admin/config/media/file-types), in the Media section.
  2. Click "manage file display" for the Video file type.
  3. Click the "Preview" sub-tab to get to the settings for the Preview mode.
  4. Check the YouTube Preview Image option in the Enabled displays field, which will open up a Display settings section at the bottom of the page.
  5. Select square_thumbnail for the Image style field, and click "Save settings."

Now if you go back and edit the video node you created earlier, you'll see that the YouTube video field is showing a nice, tame square thumbnail instead of the big video player. If you wanted to change the settings for the video display on the node, you can always go into the Video file display settings and configure the Default, or other file view modes, to the size you prefer.


In this short tutorial you've built a new video content type that lets you easily embed YouTube videos, using the Media, Media Internet Sources, and Media: YouTube modules. The advantage of using Media for this is that in addition to a handy field for embedding your video, you also get the media management tools to keep track of and reuse these videos on your site, in addition to having nice, fine-grained control over the output. Media gives you display options for different kinds of files, in different contexts, or view modes, including embedded YouTube videos through the File Display settings. Hopefully this introduction not only showed you how to use embedded videos very quickly and easily, but also gave a look at different ways you can use and customize the Media package for your next project.

Nov 04 2014
Nov 04

You may have heard some news about the fact that a new theme has been added to Drupal, named Classy. But what kind of theme is it exactly? Is it a pretty new look for Drupal 8? Well, no. You will still see Bartik as the default theme on your Drupal 8 site, so why another theme? Classy is a new base theme in core, which Bartik and Seven will then use as their bases. The idea here is to provide more flexibility to themers when it comes to choosing default CSS classes.

If you download Drupal 8 beta 2, you will indeed see the new Classy folder in the core themes directory. If you open it up though, all you get is an info.yml file. No templates, nothing else. What's the point of that? Well, Classy's info.yml file is just one part in a big change. We're only half way through the story. Let me step back a minute and give a little history for how we got to this place.

The Consensus Banana

At DrupalCon Austin there was a discussion about a big conflict in the Drupal theming world: Drupal's default CSS classes. For a detailed explanation of what decisions came out of that discussion, you can read the [meta] Results of Drupalcon Austin's Consensus Banana issue. In summary, they identified two main camps of attitude about Drupal core classes, and came up with a plan to accommodate both camps. The two camps are, roughly:

  • "I love Drupal default classes because it gives me lots of stuff to work with right off the bat, making my job easier."
  • "I hate Drupal default classes because they are messy and unnecessary, and they add extra work for me to clean it all up the way I want it."

The way they decided to solve this problem is to make Drupal core classes very clean and minimal going forward, while providing a core base theme that provides more default classes out of the box, if you want them. Classy is the new base theme which is going to provide this.

By the way, what's this have to do with a banana? Well, during the discussion a banana was used as a pointer stick to ask for agreement on points. It became the symbol of getting the group to come to a consensus.

Phase One

In order to implement this change, there are a number of technical things that need to happen. The community decided on a two-phase approach. The first phase requires that all of the class definitions get moved out of the preprocessors and into the template files so that it isn't "baked into" the core code. It moves the classes up into a theme's template files instead. If you look in the core template files (e.g. core/modules/node/templates or core/modules/system/templates) right now, you will notice lines like this at the top of the template code (under the comment which lists the available variables):

set classes = [
    'node--type-' ~ node.bundle|clean_class,
    node.isPromoted() ? 'node--promoted',
    node.isSticky() ? 'node--sticky',
    not node.isPublished() ? 'node--unpublished',
    view_mode ? 'node--view-mode-' ~ view_mode|clean_class,

Not all of the templates have these yet, but the idea is to get them all moved over in phase one. The list of remaining tasks is actually pretty small right now. You can see the full task list and how to help with it in the [meta] Consensus Banana Phase 1, move CSS classes from preprocess to twig templates issue.

Phase Two

So that's great, but where does Classy come in? Well, in phase two of the project, all of those template files are going to get moved into Classy. Classy will be the base theme that provides the most commonly needed default classes. This is why the minimum Classy theme that you see in beta 2 was added. Bartik and Seven will use Classy as their base theme, thereby inheriting Classy's classes. Then those themes can each add and override what they need to be the special snowflakes that they are. You can check out the phase two process in the [meta] Consensus Banana Phase 2, transition templates to the Classy theme issue.

Deciding on Classes for Your Theme

Once all of these classes are in Classy, and not in the preprocess functions you, as a themer, can easily decide if you want Drupal default classes. If you want everything to remain nice and clean, like a blank CSS slate, then you simply ignore Classy. If you want all those default classes to give you a boost, you can use Classy as your base theme, and away you go.

Getting from Point A to Point B

This all leads us back to the initial question of why Classy looks weird right now. This is because we are currently at the later stages of phase one work. Most of the classes have been moved in to template files, but there are still quite a few that remain. Classy is slowly going to grow as the community begins moving the templates into the new theme. You can actually already see this in progress if you look at the latest development version of Drupal 8, instead of beta 2. As you can see there is still a lot of work to do, but it is very clear and well organized, so if this kind of flexibility with CSS classes is something that gets you excited, I recommend hopping on the wagon and helping get the transition completed sooner rather than later.

Sep 16 2014
Sep 16
Recently, the biggest piece of news in the Drupal 8 world is that we are finally down to just one beta-blocker. This is really great, but what does it mean exactly? Well, in the big picture it means that we are very close to releasing a beta version of Drupal 8 for everyone to start playing with, and this is a major step towards getting the final release out the door.

What is a Beta?

A beta is a "stable development" version of the code. We are no longer adding lots of new and crazy things, and we've got the important pieces working pretty well. The idea of beta releases is that we have most things stabilized and we need module and theme developers to start working with the beta to ferret out the bugs of everyday use, as we continue to hammer on more bugs. It is important to understand that even though the APIs are considered stable, they can, and most likely will, change as we need to correct bugs in the APIs. Additionally, there are still a lot of known critical and major bugs out there, there is no guarantee you will have a beta-to-beta upgrade path, and the UI can still shift around. That said, we need you to help find bugs to be fixed before we get to the first official release.

When will the First Beta Come Out?

We have been releasing alpha versions of Drupal 8 since May 2013. As this release cycle issue explains, "Alpha releases should be considered unstable and unreliable. They are intended for testing and contributed module development only." It further explains the next step, where we complete and freeze the API, and begin beta releases. We froze our API over a year ago, in July 2013, and we've been working to stabilize the critical APIs. There has been a queue of beta-blocker tickets that lists all of the issues we know of that we consider critical to Drupal 8 and need to be resolved before we release a beta. And now we're down to just one last gnarly issue in that queue. You'll also note that there are queues for "beta deadline" and "beta target" issues. These two queues have issues that would be great to get in before a beta, but won't stop us from moving ahead, so if they don't get in before beta, oh well. You can read more about the different terms in this guide to Drupal 8 release management tags.

When we get this last beta blocker issue resolved, we'll release our (hopefully) last alpha version. When we have an alpha release that goes for at least two weeks with no new beta blockers, then we're ready to roll! At that point, we can get our hands on the new beta1.

When will Drupal 8 Finally Be Released?

Beta is a fair bit away from a full release. We still have a lot of known bugs that need to be fixed, and we can't release until at least all of the critical issues are closed. How long that will take is anyone's guess. At this point most of the community is hoping for it to come out in the first quarter of 2015 (fingers crossed!). If you want to keep up on the latest status and work done for Drupal 8, you should keep an eye on the Drupal Core Updates group. I know that we certainly are. For the Drupalize.Me team getting to a beta means we have a mostly stable version to really start nailing down our curriculum and video planning, but unfortunately so many things can, and will, change both in the APIs and in the UI, that we'd be getting ahead of ourselves to start recording too much video right now. That said we are continuing to produce more preparatory material, like Symfony2 and Twig tutorials, and we're tightening up our Drupal 8 material so we'll hit the ground running once things stop moving around so much. We're also sharing what we learn about Drupal 8 as we go, so check out our Drupal 8 resources page often, as we update this with new content several times a month.
Jul 29 2014
Jul 29
One of the neat new things in Drupal 8 is something called the Tour module. It is built on the Joyride jQuery plugin, which provides a clickable tour of HTML elements on your website. It gives you a way to walk a new user through your site or a particular interface with text instructions and next buttons. If you're not sure what this all means or looks like, have a look at the video below to see it in action in Drupal 8.

I was drawn to investigating the Tour module because I love ways of helping people through documentation. The Drupal core help system is an old system, and there have been many discussions and attempts to update it in the past. Tour certainly doesn't replace the help pages at this point, but it is an interesting new tool. So what exactly is going on with it in Drupal 8? Will we have a fancy new tours all over a default installation? Well, no. As it stands right now, there is only one tour in Drupal 8, which is for the Views building interface. It was submitted as a proof of concept with the Views module in core. So what's the deal?

Let's start by understanding what we have in core right now, and then I'll discuss some of the next steps that need more work. We currently have the Tour module in Drupal core, and that provides us with the Joyride plugin and a Drupal API with which to use it. We also have that one sample tour in the Views module. At this point you need to write your own module to add more tours to core. That's it for right now—in core. However, there are two contributed modules in development that integrate with the Tour module: Tour UI and Tour Builder. The Tour UI provides a basic user interface for Tour module ,and Tour Builder extends that further to let you use the interface to create a new tour, export that as code, and share it with others. Both of these modules are not up-to-date with the latest version of core, but once Drupal 8 settles down, and these modules get updated, these should be great tools to help usage of Tour.

[embedded content]

There are quite a few tickets for some additional features to be added to Tour, like multi-page tours, adding role-based access to the tips, and a new tip notification system. There are also a lot of tickets for different kinds of tours that need to be written and submitted as a patch for core. You can find all of the ongoing work in the core issue queue, tagged with Tour. When it comes to actually creating tours though, our delay is based on a community documentation problem, not really a technical one. You can read the long meta issue that discusses many aspects of using Tour in core if you want the full backstory. At the end of the day, a lot of work has been done to document the general idea, but for each of the tours to be created there still seems to ongoing discussion about the best use of them. Here's what I've found so far in my own journey to understand the next steps.

There are a number of guidelines for when and how to write tours, but for many people the purpose and correct implementation of the tours is still not quite clear. There are three pieces to grok to create core tours right now:

  1. UI Patterns for Tours: this page describes the use cases and general principles for how tours should be used.
  2. Tour Text Standards: this page gets into the actual text of the tours and the things you should keep in mind while writing them.
  3. Tour API in Drupal 8: this is the required documentation to actually write the code to create a patch for Drupal core.

I dare say that once people can agree on the correct usage of the Tour module, and start writing them out, that getting developers to help turn them into code will be a pretty straight-forward process. Again, this isn't a technical problem really. We need to be clear about why we introduced Tour into core, and how we expect people to use it so folks can dive in to actually using it. It would be a sad thing to have the API in core, but not much implementation to actually help the end users that it was intended for.

Dec 26 2013
Dec 26

Drupal 8 is coming in 2014. There is a lot of work to do and a lot to learn. We've decided to dedicate a minimum of five hours per week towards Drupal 8 for each person on the Drupalize.Me team. We are now a hefty group of eight people, and everyone will be diving in for a total of 40 hours per week dedicated to Drupal 8. (At least until Drupal 8 launches, and hopefully even beyond that.) Everyone is picking their own projects and ways to get involved. We just started dedicating this time in December, and folks have been spending time sorting out where things are and where to jump in. We're excited about what the new year will bring once we really get rollling. So far, we've been testing the waters with the Core Mentoring Office Hours, some Drupal Ladder work, and just installing and learning where Drupal 8 is right now. We're also lining up training initiatives, UX work, and documentation.
We'll be sharing our work through blog posts, not just about the work itself, but also the process of contributing; how different people are approaching contributing and the experiences they have in the process. A large part of most people's hesitation with contributing is just the unknown of how it all really works in the day to day. Some people on our team have been contributors for years, others haven't had the time or opportunity before, and one is pretty much brand-spanking new to Drupal itself, much less contributing. We also have quite a range of backgrounds and skills, which includes people in marketing, design, development, front-end, and teaching. We're a very mixed group, much like the Drupal community itself.
We recognize that we're fortunate to be able to dedicate this time during our work hours, but even small amounts of time can be put to use to help make Drupal 8 rock mightily for everyone. There are a lot of things going on, and many people have been chugging away to bring Drupal 8 this far for us. As a community, we need to step up and help it across the finish line, and in the process we'll be ready to make the best use of it when it's finally released to the world. I think it's in every Drupal business' best interest to dedicate at least some of their staff's time to Drupal 8. Even if this means giving one person four hours a week or eight hours a month. It all adds up and only brings benefits to your team. A great place to start is to just have people install Drupal 8 and take a look around. Or even better, let them take part in Core Mentoring Office Hours if they coincide with work time. We'll see you there!

Oct 30 2013
Oct 30

This week we continue to re-publish lessons from the Pantheon Academy, with Jon Peck. In these free lessons we'll be taking a look at working with Git and MultiDev, the Pantheon cloud-based development environment for teams working on projects together. We'll also take a look at dealing with error codes, and setting up SSL fro your server. We're going to wrap up our current list with a checklist for taking your site live.

Keep your eyes open in the future for more lessons in the Pantheon Academy series. Starting next week, we are diving back into the world of Using Drupal, continuing on with Chapter 4: Media Management. In addition to the Using Drupal series, which uses a development version of Media Module 2, we will also be starting a parallel series using Media Module 1.

Oct 03 2013
Oct 03

When is Drupal 8 coming out? What's going to change in the new version? How do I keep track of it, and most importantly, how am I going to learn what I need to know? These are the questions we're going to answer in a Drupal Association webinar on October 22. Joe Shindelar is going to give an update on where things are with Drupal 8, covering a raft of new features and changes that you'll want to know about. He's going to look at it from different perspectives — as a site-builder, themer, and module developer. After giving a overview on the neat new stuff you'll see, he'll also list some great resources for how to learn more, and start sharpening your Drupal 8 skills. You'll also get some tips for how to jump on the Drupal 8 train, and keep up with it, so when the final release gets out there, you will be an expert ready to take advantage of it.

This FREE online webinar is hosted by the Drupal Association, and you can join us on October 22, 2013 from 11am - 12pm EDT [UTC -4] (find your local time). You'll need to sign up, so get on it!

Aug 29 2013
Aug 29

There has been a lot of talk in the Drupal community recently about Gittip. Gittip is a way to donate money to people who are doing good work. The part that really makes Gittip different from other donation or crowd-funding plans is that it is set up to provide regular, weekly payments. One-time gifts are great, but a steady source of income is what a lot of people really need, especially folks who are mostly unemployed and working essentially for free on projects you care about. A few weeks back we had Alex Pott on the podcast (Episode 23: Alex Pott and Working on Drupal Core) to talk about his work, and the fact that he has been self-funding himself to be able to focus on Drupal core. We think this is a really, really important conversation in the Drupal community, and definitely recommend you listen to the podcast for more insight.

In addition to talking about this issue though, Drupalize.Me also wants to take a stand and get involved. To that end, we've set up our own Gittip account, and have started donating to Drupal people we appreciate. We've set a weekly budget that we can use, and the team decides together who will get our bucket of money. We're going to regularly assess our weekly budget and increase it as we can. Right now we are donating to Drupal folks, but that doesn't mean that we can't, or won't, look at other open source projects and people who we admire. We're currently the second "top giver" for the Drupal project, after MaxCDN, but we do hope that more companies will follow our lead, and we certainly invite others to knock us from our perch.

You'll be happy to know that Alex did indeed reach his goal ($475 per week) so that he can continue to work full-time on Drupal 8. It's so great to see the community pay it forward, and support the people who are dedicating so much of their time for us.

Jul 04 2013
Jul 04

Last week I was in Dublin for Drupal Dev Days. While my main activity was conducting a Community Tools workshop on the Friday of the camp, I was there the whole week, while an intrepid team of people have been meeting up at the venue in the final sprint to the Drupal code freeze, which was on Monday, July 1st! (Holy cow!) One of the groups who has been plowing ahead at full steam is the Multilingual team. I even got to help out with some wording in one of the issues someone was working on. While I was chatting about multilingual with a number of people, it occurred to me that I haven't really taken a look at the work that has been done. So, as my next installment in our blog series exploring Drupal 8, that seems like a great place for me to poke about. (Note that this series is about Drupal 8, which is still very much a work in progress. Things are likely to continue to change, and we are just looking at snapshots of the work throughout this series.)

One of the great things about this initiative is that its leader, Gábor Hojtsy, has been super organized and communicative. He even has a website all about the Multilingual Initiative, where you can see what the goals are, what the progress has been, and how you can jump in and help out. When I decided to start exploring the current state of things, in addition to the below video of me kicking the tires a bit, I went to that site to get a pulse of things. In a series of blog posts, Gábor covers some of the main things going on:

  • Language is first in the installation process
  • Importing the language is automated for you
  • More core modules (fewer contrib will be needed)
  • English is now entirely optional
  • More flexible language detection and selection options
  • "Special" languages for the fuzzy areas (Core comes with "Not applicable" and "Not specified" now, and you can add more)

If you've ever had to deal with a non-English or multilingual site, this is a pretty sweet list of improvements. So, here is my video tinkering around with things a bit, even though I don't know exactly what I'm doing.

You should give this a spin as well, and if you are interested in the translations part of this work, you should read the Drupal 8 alpha releases are out - what does this mean for translators? post that explains why we can't really start translating quite yet, and the work we still need to do to get there.

Jul 03 2013
Jul 03

Many moons ago, back in 2008, several Lullabots wrote the first edition of Using Drupal, published by O'Reilly Media. In 2012, myself and Angie Byron, with the help of Bruno DeBondt, updated Using Drupal with a second edition for Drupal 7. This year we're happy to announce the video version of Using Drupal. As an original author on the book I'm stoked to be able to marry together my work on the book with my work on Drupal training videos.

The original idea behind creating the book, was to provide step-by-step instructions for working with Drupal core and contributed modules to build useful sites. The whole process of selecting modules, understanding the trade-offs, and then building your site, is fundamental to any path you will take when working with Drupal, whether you are a site-builder, themer, or developer. Taking these tutorials and turning them into video format broadens the experience, and makes the information even more accessible to people, by letting them actually see the site being built as we go. The series will cover fundamentals like "what are the major building blocks of Drupal?" and how to get Drupal installed, then take on nine different case studies to solve real-world Drupal sites. We will start off with Drupal core, hop quickly to working with Fields and Views, and then dive into fun stuff with commerce, multilingual, event calendars, product reviews, media management, and more — all using core or contributed Drupal modules, with no coding required.

The Using Drupal video lessons will be delivered as a series of series. Each chapter in the book will get its own individual series. All told we will have 13 series created, based on the book. We will start with the Preface, work through each of the nine chapters, and also include Appendices A, B, and D (Appendix C is just a list of modules and themes used in the book, so wouldn't make for a very exciting video).

Today we're starting out with the Preface section of the book, the free "About the Using Drupal Series", to give an overview of how the series will work, the prerequisites you'll need, and how you can line up the book with the video lessons. We also walk through the steps to work with the source code that we provide to go along with the chapters. We'll be releasing new lessons every Wednesday for the next few months as we work our way through the book. Grab a copy of Using Drupal, 2nd Edition and follow along with us as we go!

About the Using Drupal Series (Preface)

Follow along next week, when we head into Chapter 1: Drupal Overview to give a quick history of web development and content management systems, and go over the major building blocks of Drupal.

Jun 11 2013
Jun 11

During the week June 24th a mass of Drupal folks will converge on Dublin, Ireland for Drupal Dev Days. This year, in addition to the three days of DrupalCamp that is happening (June 28-30), there is also a week of sprints leading up to the camp, and to the Drupal 8 code freeze deadline. This is it. If it's going to be in Drupal 8, it needs to happen before the end of June. Once we get beyond code freeze, our focus will shift to polishing what's there, fixing bugs, and cleaning up performance. (For more info about this, you can read all about the Drupal 8 release cycle.)

While the name of event could lead you to believe this is only for developers, this will be a crowd of people from all skills and experience. The camp itself will have sessions for a range of interests and levels, and the sprints will need people to cover a wide range of work to get things done in time. There will be a lot of opportunities to learn, as well as dig in and get your hands dirty, working on real problems to be solved. If you ever wanted to experience the Drupal community in its glory, Drupal Dev Days proves to be one of the best events this year to feel that energy and make a difference.

We're proud to support this event as a sponsor, and as presenters. In the spirit of helping Drupal core, and helping new folks be part of that experience, we are once again offering the free Community Tools workshop, on Friday, June 28th. Addison Berry will be leading this workshop, along with a host of volunteers, to show you how the community communicates, and get you set up with the tools you need to get up to speed. You'll also be able to listen to Juampy work his magic in a session or two (the final session selection isn't done quite yet) and catch Sally Young sprinting hard. If you see us around, please come up and introduce yourself. We'll also have a handful of sparkly Drupal superhero stickers to show the world how much you rock, so we hope to see you soon in Dublin!

Jun 06 2013
Jun 06

We're happy to announce a new program to sponsor user groups around the world: Meetup Memberships. We're giving user groups FREE access to the entire Drupalize.Me library on days that you have meetups or camps planned. It's like having a Drupalize.Me instructor show up at your event, anywhere, anytime! Here's how it works:

  • We create a login for your group to be used on event days.
  • Whenever you have a publicly posted event, you notify us with the date of your upcoming event (we need a week's notice).
  • We'll activate the membership for the full day of the event.

You will have full, free access to all of the content on Drupalize.Me for the day, and you can use it however you like. If you want to "present" on something, like Drush, Views, Entities, or whatever, you can set up a projector and play videos from the site. (Yes, you will need a reliable Internet connection to stream our videos.) You get to share expert information, and there is no need for you to prepare the material or examples yourself. You can do this in classic presentation style, or you can also use the videos for group learning, as a study group. Play a video (or set of videos) and then use them, pausing and replaying, to help each other work through a project together.

This is a new program for us. To ensure the best possible experience for everyone we have decided to start with a small test group of Meetup Memberships. We're looking forward to expanding the program once we've got the kinks worked out. We'd like to test the program with a range of different groups (some big, some small, some established, some new). Please apply for a Meetup membership today by simply telling us a bit about your group. The application form will remain open during our trial period. You can apply as soon as you're ready. We look forward to sponsoring your group through our collection of Drupal training videos!

May 17 2013
May 17

On the eve of DrupalCon Portland, we're happy to be able to get another free community video out, Installing and Using Dreditor. What's more exciting though, is that this video is part of our Community Tools workshop, and in an effort to spread Drupal community involvement further than where we can show up to run this free workshop, we're putting all of our materials and notes online for everyone to use freely, with the Community Tools curriculum.

A Workshop is Born

The Community Tools workshop was born out our experience with the Drupal Ladder and the Core Mentoring program. The idea was to gather up the essential tools that people need to understand in order to fully engage with the community, and feel confident contributing back to it. We don't just talk about the tools or processes, but we actually walk through them; have people install software they need, make sure it works properly, and use it in a community context. We've given the Community Tools workshop at several DrupalCons and camps now, and we've been working hard to refine it so that it works well for multiple circumstances. The most successful use is as part of a larger sprint event, where people can get up to speed on tools, and then immediately go actively use them to contribute, so that is what the initial draft of the curriculum is focused on.

Sharing What We've Learned

We've learned a lot by teaching this workshop so many times, and we'd love to travel everywhere to provide it, but, well, that's just not realistic. We want to make it possible for others to present it in their local groups, regional events, or wherever it would be a help to onboard new contributors. We have a fair amount of the material available in video form as well, so that people can watch and learn on their own, or in any size group. We've created a new guide, the Drupal Community Tools and Core Mentoring guide to group all of the videos together in one easy-to-find place (and it includes the new Dreditor video too). They are also referenced throughout the curriculum itself. Not everyone is brave enough to stand up and teach, or even if they are, they'd like to see someone explain the topic first. We hope that by sharing the slides, videos, links, experiences, and tips, we can get more people running their own Community Tools workshops around the globe, and warmly welcome more people into the Drupal community.

Learn more at DrupalCon

The curriculum is in a draft state right now, but we have plans to improve the organization, and content, over the coming months. Ideally we want to truly open-source this by providing a good way for people to contribute back their own improvements to it. I'll be talking about this more at DrupalCon Portland, as well as running the workshop again on Friday's Get Involved with Core sprint. If you have ideas around this, I'd love to chat with you about it, either in Portland, or online. If you'd like to volunteer to help out with the workshop or the sprint (either in Portland, or sometime in the future), you should definitely come to the Running Coaches Wanted! session at Portland to get a great overview of how all of this works, and what things will be happening all next week to help people learn new tools, get involved, and become mentors and trainers themselves. (Note that the sessions are all going to be recorded and posted online fairly quickly, so even if you can't make it to Portland, you should check the session out online.)

Jan 16 2013
Jan 16

Today we've got two FREE videos for your viewing enjoyment, one about a killer community tool, and the other about a handy module to help you out when working with Drupal databases. In Using IRC (Internet Relay Chat) we look at one of the most over-looked, but most useful community tools available, IRC. IRC is a way to chat online, in real-time with other people, and it is used heavily by the Drupal community. We'll sort out what IRC is, how to get connected, and walk you through some of the basics to get you started.

Our second lesson, Using Schema Module, introduces you to a great way to get information about your database, and a nice, quick way to get Drupal to write some code for you, when it comes to creating your module's install file.

We hope you enjoy these videos, and we'll have some cool new stuff next week, walking you through working with lightboxes in Drupal.

Jan 09 2013
Jan 09

This week we are finally finishing up our Coding for Views series with the last two lessons, which lagged a bit for us. We're happy to round things out by providing another example of writing a Views handler which creates a Views area handler, and with a look at theming Views. In addition to wrapping up that series, we also have a free video that looks at working with secondary menus. While this lesson is using Drupal 6, the concepts and processes used are exactly the same in Drupal 7, and is still applicable there. The lesson looks at how to take a menu with child items, and turn those children into a separate, but contextually related menu, in relation to the parent menu items. We also open up our theme, and look at how to move the secondary menu around, and manipulate the HTML that is being output, so that we can make the menu look the way we expect. The main difference between Drupal 6 and 7 with this lesson, is that the theme code to print the secondary menu looks different, but functions in the same way.

Next week, we'll be taking a look at some more community tools and processes to help people accelerate their Drupal experience. We're also hammering away at some cool new series on topics like Entity API, Git, and SASS. To see what we have in the hopper, to add to our list, and vote on topics, check out our Suggestion Box.

Jan 02 2013
Jan 02

Happy New Year! We're kicking off 2013 with some FREE videos to get people up and running with our Drupal community tools. There are a lot of aspects of the Drupal community that many people take for granted. Even something as "simple" as figuring our what community websites are out there, and how to use them, is often overlooked when talking to people new to Drupal. So, if you want to really dive into this Drupal thing in 2013, here is a gentle orientation to help get you started. We've added three new videos to our free Community category that walk you through the various community websites, how to get an account, and what you can do with it, from customizing your dashboard, to editing and creating new documentation on Drupal.org. We also take a look at how to use the main search on Drupal.org so you can start finding the things you're looking for.

We hope you find these videos helpful, and we plan to keep creating more community videos over the coming months. Let us know if there is something in particular about our community that is mysterious to you, and we'll add it to our list.

Nov 28 2012
Nov 28

Today's release day is a mixture of free videos! We have two new videos to add to our Command Line Basics Series, covering Bash aliases and working with MySQL. In addition to those lessons, we are also releasing a short four-video series about Using the Ooyala module with Drupal. Ooyala is a paid video delivery service, which manages your videos and handles video delivery to your site. If you have an Ooyala account, the Ooyala module will connect the Ooyala service to your Drupal site to display and play your Ooyala videos from within Drupal. The series will explain how to install and configure the Ooyala module, and then show you how to use it with Views and Views Slideshow.

Command Line Basics

Using the Ooyala Module with Drupal 7

Next week, we're excited to introduce a new series on Coding for Drush, which will cover all of the fun things you can do to add Drush commands to your custom modules, and really customize this powerful Drupal tool.

Nov 28 2012
Nov 28

This video looks at the basics of working with MySQL from the command line. We get into the mysql environment and look at databases, tables and fields. We cover creating and deleting databases, creating a user, and querying within a particular database.

Nov 28 2012
Nov 28

This video shows you how to create your own custom shortcuts for various commands. We'll look at some common aliases and see how to add them to our command line environment. This is super handy for commands that you type in all the time and don't want to go through the tedium of typing the whole thing out every time. For example, we show how to automatically go to a particular directory with just one word (e.g. type "clients" and go to the /Users/add1sun/lullabot/clients directory immediately).

Oct 29 2012
Oct 29

Over here at Drupalize.Me we have been working on transcribing and translating our videos for a few months now. We've also had a number of people step up to help us out with them, and we now have translations beginning to appear. So far, we have Chinese, Croatian, Estonian, Persian, and Spanish versions of a few of our videos. While we are always looking for more folks to join our internal subtitle team, we have also opened up our workflow to the public, so that we can share our work with a wider audience, and let anyone who wants to help ramp up more quickly, without any specific commitment to the amount of time you have. We've now started putting our free videos up on our public page on dotSUB, so everyone can find them, and jump in to help transcribing or translating as they have the time and inclination.

Why would you want to help with this effort? Well, we'd like to help as many people as we can with their Drupal learning curve, and by creating transcripts and subtitles we are opening the world of Drupal to so many more people. Our free videos can be used by anyone around the world, and they are a great resource for local user groups to use at meetups, and for organizations to use for training, or for anyone to use as a way to evangelize Drupal. If you'd like to use these videos for your group or organization but your audience are not native English speakers, having subtitles in your language of choice helps considerably with the Drupal barrier. If there is a free Drupalize.Me video you love and want to be able to share with even more people, it is now easier to help with that process.

You can find all of our free videos available for work on our dotSUB page. Once you get a free account on dotSUB, you can immediately pick a video of your choice and get started. Here is a little more information about how things are set up.


Transcribing is the process of creating an English transcript (and captions) for the videos. If you can understand and write English, you can help with these. English transcripts form the base from which our translations are made, and they are a huge assistance to those that have difficulty listening to or watching the videos. You can watch a dotSUB video that explains how to transcribe videos.

When you go to our dotSUB page you can see which videos have already been transcribed and those that still need some help. If the video listing states that it is "Waiting to be transcribed" then no one has started work yet at all. If it states "Transcription in progress" then that means someone else has started the work, but there is still work that needs to be done to make it complete.

To help with transcriptions, just click on the video to go to the full video page, and then click the "Transcribe Video" link on the sidebar. If that link is not available, then the transcript is likely already complete and published, so it can't be edited any longer.


Things work in very much the same way for translations as they do for transcriptions. You can watch a dotSUB video on how to translate videos.

Once a video has been transcribed, it will state "Transcribed" on our dotSUB page, which means that it is now available for translation.

Once people have started to create translations you will see the listing indicate the number of translations, e.g. "3 Translations." When you go to the full video page you will be able to see the languages that have been started and completed in the "Transcribe and Translate" box in the sidebar. Each language will be listed, along with the percentage completed. You can select the language you want to work on in the "Translate into:" dropdown selector. If you do not see the language you wish to work on listed, it likely means that the translation has already been completed and published, so no further edits are permitted.

We're excited about spreading the Drupal knowledge far and wide. If you have some time to spare and want to help out, we want to make it as easy as possible. We think this is a step in the right direction to make Drupal knowledge more accessible to more people, all over the world.

Oct 24 2012
Oct 24
Lullabot logo

Lullabot has trained thousands of Drupal developers & guided the development of some of the largest Drupal websites.

Oct 24 2012
Oct 24

In this lesson we're going to take a look at the Omega theme, cover some basic terminology around it, and discuss the advantages and challenges of using it. Specifically this lesson will cover:

  • Omega features
  • Helper modules
  • Where to find documentation
  • Omega terminology
Oct 23 2012
Oct 23

The Drupalize.Me team loves to attend Drupal events, and we're stoked to be going to BADcamp in Berkeley, California next week, along with a whole group of Lullabots. BADcamp is, by far, the largest free Drupal event, clocking in with over 1500 attendees this year. It remains a free event due to strong sponsorship, and Drupalize.Me is proud to be a Contributing Sponsor this year. In addition to the great fun to be had (Pirate costume party!), and the tons of sessions (over 90), there are a number of sprints, topical summits, training days, and a job fair.

We're particularly excited about the two days of free training being offered as well, as we'll be giving our Community Tools workshop in a new full-day format (we are repeating the same workshop on both days). Previously we have done this workshop in a half-day to get people bootstrapped as quickly as possible, covering the basics of using IRC, the Drupal issue queue, getting a local development site, and touching the tip of the iceberg with Git. With the nice open schedule of a full day at BADcamp though, we can really dive into more detail and cover more tools, including Drush in the mix, and spending time to really get people more familiar with Git.

After two days of training fun, you'll be seeing Lullabots all over the place during the camp. Both Joe and I have sessions, in addition to many other Lullabots:

  • "Views. Huh! What is it good for?" by Joe Shindelar
  • "The Drupal Ladder" by Addison Berry, with Karyn Cassion
  • "Flexible Image Galleries with File Entities" by Nate Haug
  • "Introduction to Module Development" by Matt Kleve
  • and also "Node Access for Common Folks With Uncommon Problems" by Matt Kleve
  • "Do More with LESS" by Sean Lange
  • "Drupal Talk with Crell and Eaton" with Jeff Eaton and Larry Garfield
  • "Going Mobile" by Sally Young and Blake Hall
  • "Building Communities using Organic Groups" by Andrew Berry

You can also get a peek at how the Drupalize.Me mobile apps were developed by attending Sumit Kataria's session, "In-depth : Creating Native Mobile Apps with Drupal as Base."

This is going to be a blast! If you are going to be attending BADcamp as well, make sure you find us out and about, or swing by our booth, so we can meet you, say "hi," and get a sparkly, limited-edition BADcamp pony sticker. See you in California soon!

Sep 19 2012
Sep 19

To get things started, in this lesson we'll create a new module, and use hook_views_api() to let Views know we want to use its API.

Sep 12 2012
Sep 12

This lesson gives an overall summary of the entire Coding for Views series. We explain the basic knowledge that each chapter will cover and what you can expect to learn from watching this entire series.

Sep 06 2012
Sep 06

It has been a few months since we started our site upgrade, and I wanted to give an update on our progress. We are a small team of three, who manage the site and create most of the videos, so needless to say we've gotten a bit waylaid on our schedule. We've also had quite a bit of fun distraction with our Lullabot company retreat (which was sooo fun!) and DrupalCon Munich (which was amazing). So, while we're not as far as we wanted to be, we have gotten a good chunk of work started, and we're through Phases 1 and 2!

Site prototype, architecture, and basic migration

We were very fortunate to have some of Karen Stevenson's time at the start of the project to get our initial upgrade migration started, as she has worked on a number of large Drupal migrations. She started things off by creating a very simple Drupal 6 to 7 upgrade with only our essential modules — basically anything that had a major impact on our content types, like fields and the like. She ported the minimum needed in our custom modules, recreated the content types in Drupal 7 in Features, and used Migrate module to map our old content to the new content types. She also mapped other site essentials like users and taxonomy. She even wrote up an installation script so everyone who needs to work on the new Drupal 7 site can clone the repository, create a database, and do a fresh install of the new Drupal 7 site with all of the content types in place. Then we just need to have a local copy of the Drupal 6 site, wire it up in our settings.php file, and run the migration from the UI that Migrate provides. It is pretty amazing how much she got done for us.

Some people may ask why bother with Migrate module to just move the content from one Drupal site to another. As we work on the upgrade, we really want to make sure the migration is keeping up with us, so we are setting our development site up with Continuous Integration (CI). This means that the development site will automatically get completely rebuilt on a regular basis using a fresh copy of our live database, and run through the entire migration process. As we change things on the site, we'll be able to see if there is a failure in the migration process so we can fix it right then and there. No one likes to be surprised by a migration failure on launch day! We'll have more information on how we're setting up our dev site shortly.

Design refresh

We have quite a lot of work done with our design refresh. We aren't going to radically change the way the site looks or functions, but we do want to address a few pain points. We are through almost all of our wireframing, and the visual design mocks are over halfway there. Having the wireframes ready to go has clarified a number of architectural decisions we needed to make, and is certainly going to make it much easier for us to build out the site, without having to backtrack all the time with new ideas. Since we have our major visual elements in the design mocks, we're also in a really good place to begin theming the site as we build. Now we just need to decide whether to use a base theme or not, and if so, which one. ;-)

Module audit

In a module audit we look at all of the existing modules, contributed and custom, to assess what the upgrade plan is for each. We created a big spreadsheet with two tabs on it for our audit. One tab has the contributed modules on it, and the other is our custom code. Several of us have gone through the lists and made notes about whether we still need that module, what possible upgrade paths exist, etc. We've now winnowed the list down to the things we still need, and we've ended up with a nice, small list of modules that we will actually need to upgrade ourselves.

For contributed modules, we started with a list of 125 modules and we managed to eliminate 80 of them. Whoa! Well, part of that is because we will not be using Ubercart in the new site, and that eliminated a lot right there. There are also some modules we don't need because core handles more things for us, a bunch of modules that we really just don't use so we should get rid of them anyway, and of course, there are NEW modules we'll be adding in Drupal 7. So that number is a little misleading.

For custom code, we have 48 modules (!), but 17 of those are features, so that makes a little more sense. In our audit we managed to get rid of 23 custom modules, again due to some simply being unused, or finding features we want in contributed modules instead.

After our audit (but before we've really gotten into the nitty-gritty of building ;-)), we know the modules we'll need for almost all of our features, we don't need to upgrade any contributed modules we currently use, and we have 25 custom modules to attend to (8 of which are features). Not a bad start at all really.

Next Phase: Build! (and maintain)

Now that we're back and settled from DrupalCon, we're gearing up to dive back in and get cracking on building out the new site. We have a nice starter site with our main data in place, so now we need to recreate things like our views (which don't migrate), and construct (or re-construct) all of the other goodies we have on the site. You know, simple things, like membership payment and management....

To keep things moving along, we're going to do the upgrade work in a pseudo-agile process, where we will work (sprint) for two weeks, and then do a site demo to show each other our work and keep a check on where we are. The first of these new sprints started this week, and we are mostly focused on getting our dev site and CI set up, along with rebuilding our views and features. It should be fun to see our progress and share it with the rest of the Lullabot team every other week. Hopefully the short iterations will keep us focused and energized, even the midst of everything else we're trying to get done.

While we're having fun banging on the new site, we also need to maintain the existing site, and keep up with bugs there. We've set up a different development cycle for the Drupal 6 site, where we have four week "sprints" instead, and we will release tweaks and bug fixes only once a month.

So, we're still here, cranking away, and now that we're truly back in the saddle, you should see some more regular updates on our progress. Stay tuned!

Sep 05 2012
Sep 05
Lullabot logo

Lullabot has trained thousands of Drupal developers & guided the development of some of the largest Drupal websites.

Sep 05 2012
Sep 05

In this video we will walk through the process of testing existing patches in the Drupal.org issue queue. We will read an issue, download and apply the patch with Git, and then test it to see if it works. This video follows the instructions on the Test patches lesson on learndrupal.org.

The lines that I have in my .bash_profile (shown at the end of this video) to add the Git branch to my command line prompt is:

function parse_git_branch {
git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/'
export PS1="\h:\W \u\$(parse_git_branch)\$ "

I'm using a Mac, so your mileage may vary on other systems.

Aug 28 2012
Aug 28

DrupalCon Munich 2012 was a blast! The whole Drupalize.Me team (myself, Joe, and Kyle) went over to Germany and soaked up the Drupal goodness. I had a very busy con, and want to share some of the great things that came out of it. (I'll try to be brief, but wow there was a lot of good stuff just in my little corner of the con!)

My week started off by being part of Bryan Hirsch's Drupal Ladder presentation, as part of the new steering committee we've set up. In addition to spreading the word and continuing to push the Ladder project forward, it spawned a number of really good conversations about how to get people bootstrapped into helping out with Drupal core. As the new lead for the lessons and ladders, I have a number of tasks on radar. First and foremost, we need to get our existing lessons completed and reviewed. In addition to the main ladder we already have on the site though, we also want to create ladders for each component of Drupal 8, and the initiatives that people are pushing to complete. To that end, I attended several core conversation sessions, and talked with folks about how to best put together these somewhat nebulous ladders. In a late night of chatting and beers, we got Gábor Hojtsy to create an outline for a Multilingual initiative ladder, based on the way that he has been getting volunteers up to speed on his work. We still need to fill this out, but it is a great start to getting a prototype initiative ladder created so we can test it out and get more people rolling. I. Am. Stoked. (If you want to help fill these lessons out, please feel free to dig in by getting an account and posting a comment on a lesson in the ladder.)

On day two of the conference I shifted focus a little and spent time talking about local community, both in the form of meetups and camps. For me, local and regional events are the prime place to really flatten your learning curve, and sorting out how to get more of them happening, successfully, is an important piece of Drupal education. I was on a panel called "To Beer Or Not To Beer? Making meetups work," along with Brock Boland, Karyn Cassio, and Paul Johnson, where there were lots of great ideas from the other panelists, and from the audience. I also attended the Plan and run a Drupal Camp while having fun, empowering others, sharing knowledge, and getting enough sleep* session, and the related BoF right afterwards. That focused on a project underway creating a camp "kit," that would not only provide an easy to set up camp version of Drupal's Conference Organizing Distribution (COD), but also branded promotional material, best practices documentation, and eventually a system that can be added to COD to actually have the camp team organize within the site itself, and a timeline with reminders to keep you on schedule for a successful event. Neat stuff!

On the last day of sessions there was a Birds of a Feather (BoF) called "Drupal Training: Good, Bad & Ugly" where we packed the room, and largely talked about what training resources are missing in the community (biggest hit there was assessments and quizzes), and how we might better share the resources we have. That played right into my "The State of Drupal Community Education" presentation, which was the last session of the con. I ran through my results from trying to sort out what free, community resources we have for learning, and supporting teachers. I generated more questions than answers, and we uncovered some other resources. I'm really hoping that conversation will continue in the Curriculum and Training group on groups.drupal.org. Once I get some time, I'd love to rework the group home page to make things clearer and encourage conversation for working together as teachers and trainers, but please feel free to check out the post we've added (thanks Sharon!) with a quick list of current resources out there and give feedback on others we may have missed.

My week wrapped up with what is arguably my favorite part: the Get Involved with Core sprint. To help out the core mentoring team, Drupalize.Me provided a free workshop on the morning of the sprint to get people eased into the community. Things were pulled together at the last minute but we ran with it (huge thanks to Jess (xjm) and Neil Kent!) and we managed to make a workshop of it. Joe, myself, and Cathy Theys walked about 50 people through the steps of getting started (using the issue queue, IRC, local web server, git, and an installation of Drupal 8), very similar to what I did with Kyle at CapitalCamp last month in Washington, DC. The best part for this workshop though, was that once people got set up with all of their tools there was a room of almost 200 people around them working on core issues that they could dive right into. As a matter of fact, two of the people that were in our workshop worked on an issue that afternoon that was then committed to core live on stage at the sprint by Dries himself. That was pretty amazing! I'm super excited for us to do this workshop again at BADcamp, and we're looking at other camps and cons to show up at as well (let us know if you're interested in us coming to your event to lead a community tools workshop). With our experience in two different scenarios, and more time to plan the logistics, I just can't wait to keep it going. It is one of the most fun workshops I've ever done, and it feels so great to see people really getting their mojo going with Drupal tools and the community.

Of course, in addition to great sessions and hard work, there was just the great time to see friends I hadn't seen in a while, spend the beautiful summer evenings in the beer garden, and re-connect with the wonderful energy of the people in this community. This really was a great DrupalCon, and I'd like to thank everyone involved for making it rock so hard. I feel inspired and excited, and am raring to go on a number of initiatives in the Drupal education space. If you want to know more about any of the things I've covered here, please ask, as I could probably go on for hours about any one of these cool things. I also hope to see you at the next DrupalCamp or DrupalCon to talk face to face, and direct our energy together into making Drupal even better than it already is.

Aug 15 2012
Aug 15

This lesson covers all the updates/differences in the latest 2.x version versus other Drupal 7 releases. The new 2.x version of Display Suite is still in active development at the time that this video was published, but we want to make sure you know the changes that are coming when the new version is finally released. This video is very important to view if you are using Display Suite version 2 for the first time and have watched other videos in this series. It covers UI changes/updates as well as feature differences.

Aug 15 2012
Aug 15

In this lesson we cover how all over the configurations we have learned using Display Suite are able to be exported to code. This video shows how to do this using CTool but can also be done with Features as well.

Aug 08 2012
Aug 08

In this lesson we cover another "extra" of Display Suite, Views Displays. This basically allows you to take over a view template file and use Display Suite to layout your views.

Aug 08 2012
Aug 08

In this lesson we cover several extra options provided by the included "Extras" module with display suite. We will show how turning on the Contextual Links extra makes it easier to edit a layout when viewing an entity that is using it. We also look at the Page Title extra that allows you to hide/show the title for a particular layout. Finally we discuss a very powerful feature that allows you to have an option of an end user to select between different view modes.

Aug 08 2012
Aug 08
Lullabot logo

Lullabot has trained thousands of Drupal developers & guided the development of some of the largest Drupal websites.

Aug 06 2012
Aug 06

The Drupalize.Me team is excited to be going to Germany in just two weeks, for DrupalCon Munich. DrupalCon is always an amazing event with thousands of Drupalers sharing ideas, having fun, and helping to make Drupal even better, both as software and as a community. For our part, we will be involved in several sessions, as well as doing everything we can to make the sprint day successful by providing free training on community tools. What is a "sprint day" you ask? Well let me explain what's going on and why we're so excited.

DrupalCons have always traditionally had an open space on the last day of the conference for sprinting. Everyone in the community comes together and simply works on tasks to make Drupal better, everything from coding for Drupal core, to writing better documentation, to helping out your favorite module or theme. It is a wonderful way to get plugged in to the community and make an immediate contribution. So many people are available to help guide you and bounce great ideas around. The biggest problem that often happens though, is that there are a lot of people working on lots of different things, and it can be very overwhelming for someone who is new to either the community as a whole, or even just new to the concept of a sprint. Another problem we often see that leads to lower attendance in the first place is that many people don't feel that they have the knowledge or tools to contribute. Everyone can contribute, whether you know how to code or not. Figuring out what you can contribute though is often daunting enough that most people stay away, instead of peeking in the door and seeing all the great fun going on that they could be a part of.

Recently the core mentoring team has been working hard to create better organization around working on core to make the on ramp that much smoother for new people, and give people better direction for how they can help. At the same time there is a new initiative called the Drupal Ladder that has been focusing very narrowly on creating step-by-step guides for people who want to contribute. Our team has been involved with both of these efforts in a number of ways. At CapitalCamp a few weeks ago we wanted to add our help in a new way. We created a new, free, half-day workshop to teach people our community's tools. (You can see the outline and resource links from the workshop.) We wanted to have a very relaxed and guided place for people to not just get exposed to the tools we use and how, but to also provide hands-on help and make sure people really felt comfortable. We had a huge turnout at the camp — more than we anticipated — and it was a blast! It was such a success that we're excited to provide the same training in Munich for the DrupalCon sprint. We're still working out the details of the when/where, but we will definitely update you here on our blog, as well as get the word out at DrupalCon. If you will be in Munich, we hope to see you on sprint day, and we'll be there to help you feel welcome and confident as you jump into the wonderful world of contributing to open source.

Oh! We also have some extra fancy, special, limited-edition sparkly pony stickers, just for DrupalCon Munich. We only printed 1000 of them, and they'll only be available at DrupalCon. Once they're gone, that's it. So, make sure you track down Addi, Kyle, or Joe during the conference to get 'em while you can!


About Drupal Sun

Drupal Sun is an Evolving Web project. It allows you to:

  • Do full-text search on all the articles in Drupal Planet (thanks to Apache Solr)
  • Facet based on tags, author, or feed
  • Flip through articles quickly (with j/k or arrow keys) to find what you're interested in
  • View the entire article text inline, or in the context of the site where it was created

See the blog post at Evolving Web

Evolving Web