And now, the post you’ve both been waiting for: Drupal!
To recap, my odyssey started in 2008 with WordPress. WordPress was my thrilling introduction to the world of content management systems, and being able to switch graphic themes at the touch of a button was like magic. But I ran into its limitations within a few months, so I built my next site in Joomla. Joomla was much more extensible than WordPress but I found it deeply clunky, and I didn’t like how many of the add-on components were commercial (i.e. not free).
I was a little nervous about trying Drupal. I’d heard it had a steep learning curve, and the themes I browsed at drupal.org seemed pretty lame compared to the ones available for WordPress and Joomla.
But it was also kind of cool! I set up a practice site (using Fantastico Deluxe, the newbie’s best friend), and I was impressed by the unobtrusive AJAX interface and the clean look and feel. Drupal felt as smooth as WordPress but as expandible as Joomla.
What really dropped my jaw, though, was the Permissions page. Unlike Joomla and WordPress, which just have a few standard roles with varying levels of power (“Administrator”, “Editor”, “Author”, etc.), Drupal allows you to create custom roles with exactly the permissions they need.
If this doesn’t seem important to you, consider these two scenarios:
- The user needs to be able to create, publish and edit their own blog posts, but you don’t want them to be able to tinker with anything else on the site. On my Joomla site for a mural and faux finishing business, I had to give a user the “Publisher” role in order for her to publish blog posts without admin approval, even though it gives her way more access than she actually needs.
- The user needs the power to administer other users (add new accounts, delete accounts, etc.), but they are not very technically adept and would get overwhelmed if you gave them access to the entire admin interface.
Unlike WordPress and Joomla, Drupal handles those cases perfectly.
Content Construction Kit
The other thing that initially impressed me about Drupal was the Content Construction Kit module (CCK). The title didn’t initially grab me, but once I understood its purpose I was hooked. Allow me to explain:
In WordPress, you can create a “page” or a “post.” A page is exactly what it sounds like — an example would be an “About this blog” page. A typical post is often a blog entry, which might appear on the front page of the site with other blog posts. Alternatively, if you click on the headline you’ll see the post on its own page. For an example, see the front page of the WordPress site Waiter Rant (http://waiterrant.net/), which has several posts appearing in row, as opposed to an individual post on the same site (http://waiterrant.net/?p=1684). Posts can be easily organized into a blog archive, classified with tags, etc.
In Joomla, on the other hand, everything is an “article.” You can group multiple articles on a single page or display an article as a stand-alone page. You can also put articles inside of modules, which are blocks you can set to appear on different parts of the page, such as the sidebar, footer, etc.
The problem with Joomla articles is that the workflow can get tricky. You can set the category and section of an article, which will dictate where they appear on the site, whether you see a teaser or the entire article, the publication order, etc. But this can be hard to manage, particularly if you want to hand the site off to a client who’d like to maintain it themselves.
None of these problems with Joomla are unsolvable, but they can be a major hurdle, particularly for a non-tech-savvy client. Just last month I was making small talk with someone who runs a non-profit organization; apparently his organization did a big site redesign into Joomla, but they’re having a lot of trouble adding content, and it’s basically no better than the static site that preceded it.
Drupal’s Content Construction Kit, amazingly enough, addresses this problem. It allows you to create a fully-customized content type for all the different kinds of content you’d like to add to the site. For example, you could make a “Press Release” content type, with custom fields for release date, contact information, a downloadable PDF, etc. Then, you’d give your client permissions to create a new press release (but not every other kind of content), so they’d see a link when they log in that says “Create new press release” which would then walk them through a tailored form for adding a press release.
A further advantage of breaking the press release data into separate fields (instead of just lumping it all into the press release body) is that your client will be less likely to wreck the consistency of the site’s look and feel. For example, if they put the release date, contact name and number, etc., straight into the body of the press release, it may not look the same from one release to the next. But if they enter that data into individual fields, you (the site designer) can set it up so each field is styled consistently every time.
I used CCK to great effect on an internal site for the Warwick Historical Society. Volunteers in this small Massachusetts town are working on cataloging the strange and varied contents of their drafty historical society building, and I created a custom form for them using CCK which makes it easy even for minimally-trained users to enter the name of the item, select the approximate date from a drop-down menu, assign it to one or more categories, write a brief description, and upload a photo (which is automatically resized). The best part is that it will be easy to migrate the data from Drupal into any other database, since everything has been separately stored in its own field.
Apparently Joomla and WordPress have third-party tools similar to CCK (see Joomla extensions for content construction and Pods CMS for WordPress), but compared to CCK they seem like a real hack. Every Drupal site worth its salt uses CCK, and in Drupal 7 (coming out later in 2010) CCK will be fully integrated into Drupal core.
So far I’ve only scratched the surface of what distinguishes Drupal from WordPress and Joomla. But I think I’ve begun to demonstrate why Drupal is soaring in popularity and giving even commercial content management systems a run for their money. For more on this, I recommend reading Drupal creator Dries Buytaert’s 2009 retrospective and also Drupal’s relative growth in job listings.
To be fair, I’ll summarize Drupal’s pros and cons.
- Fervently open source, meaning that virtually every third-party module is free of charge
- Very easy for clients to add content to the site, once you’ve handed it over to them
- Fine-grained permissions and the ability to add custom roles
- Good multi-lingual support (more on this later)
- Search-engine friendly URLs
- It’s teh awesome!
- Available themes aren’t as good as for WordPress or Joomla (although this is changing fast)
- No built-in WYSIWYG tools, and the third-party modules can be tricky to configure
- Astonishingly enough, no native image handling. This feature is coming in Drupal 7, though.
Although I am quite enamored with the Drupal community, I’m not going to say that it’s better than the Joomla or WordPress communities since I haven’t plunged as deeply into those. I will argue, however, that hosting all themes and modules on Drupal.org instead of on disparate sites has the benefit of pulling the Drupal community closer and making it easier to find answers to issues.
Incidentally, one problem with all three systems is that they are written in PHP and use MySQL, which is not an ideal security combination. Drupal can be made to work with PostgreSQL, which is somewhat less vulnerable to injection attacks than MySQL, but it’s not the default. I’d feel more comfortable if Drupal were written in Python, and I’m a little curious to try Plone as it matures, but I sleep fairly soundly as long as I keep up with security releases and database backups.
Anyway, I haven’t come close to singing all of Drupal’s praises yet. In future rants I’ll rhapsodize about the Views module, multi-lingual support, easy search engine optimization, and more.