The Drupal Learning Curve: a configurators view
The learning curve, from early 2007, describes a learning curve that probably fit coders pretty well. For me as a non-coder, it fitted pretty bad. It puts, for example, upgrading, patching and (security) monitoring as first thing above the 'I suck' threshold – something that took me quite some time to learn, by which time I at least felt like I way past the sucking threshold.
I would like to propose a complementing learning curve, aimed at Drupal configuration. It builds on experiences from a quite large number of configuration-focussed Drupal courses and countless guides, screencasts, IRC-discussions and comments/answers in various Drupal groups.
I am pretty confident that this learning curve will provide a pretty good pathway for anyone wanting to learn how to use and configure Drupal, like I did. I am also certain that it contains things that could be disputed, omits things that should be included, and in general could be a lot better. Feel free to add your comments, contributions or objections.
Edit: I now added some images to illustrate the ninja skills for the different levels. (See each image for credit details.)
Learning curve overview Level 1: Drupal core + basic fields Level 2: Intermediate fields + basic Views Level 3: Intermediate Views + complex single-purpose modules Level 4: The outside world Level 5: Module combinations + basic Rules + basic Panels/Page Manager Level 6: Access configuration + complex Rules and Panels/Page manager Level 7: The secret ninja domain
Level 1: Drupal core + basic fields
This level is crucial for understanding what Drupal is all about. It contains the bread and butter of Drupal handling, but not much of the cool stuff that makes you really inspired.
- Node creation. You know how to create, edit and handle basic node settings. You know what is meant by teasers and full nodes. You even know what the heck a node is.
- Users, roles and permissions. You know how to create and edit users. You know how to create roles and assign them to users. You know how to assign permissions to roles.
- Changing some basic site settings. You know how to change front page, site name, settings for account registrations, turning off the posted-by lines for nodes, and some other basic settings on the site. You're generally starting to learn your way around in the administration menu, and have probably added a few shortcuts (assuming you're using Drupal 7).
- Taxonomies. You know what is meant by vocabularies, and know how to use free tagging and categories sorted in tree structures. If you're using Drupal 7, parts of how to configure the taxonomy settings are probably still shrouded in darkness.
- Blocks. You know how to control where blocks are displayed, even when using multiple themes. You can use block visibility settings based on roles and, assuming you're using Drupal 7, node types.
- Menus. You are comfortable with adding nodes in menus and know how to make arbitrary links into menu items. You have a feeling of how the menu places primary and secondary links works in a theme (or main and secondary menu in Drupal 7).
- Modifying node type (default) settings. You know how to set default behaviour on node types for things like published state, comments and revisioning (and menu settings, if you use Drupal 7).
- Extending node types with simple fields, and installing modules. You can add simple fields like text, numbers, select lists, links and email addresses to nodes, to extend the information they store. You also know how to change basic field display settings. Handling fields probably includes installing your first module – CCK if you use Drupal 6, field modules in Drupal 7. You know that contrib modules should be placed in sites/all/modules.
'I suck' threshold
Level 2 – Intermediate fields + basic Views
This level introduces some of the coolness in Drupal, but it is not yet clear how awesome these things really are. It contains information architecture in the form of node references and simple views. (Sorry, you cannot really pass the 'I suck' threshold without starting to use Views.) There are also more familiarity with node handling, including images and modules like Automatic Nodetitles and Scheduler.
- Node references. You know how to use node references (or relations in D7) to create an information architecture based on your node types (even if it admittedly gets screwed up sometimes).
- Image handling. You know how to add images as fields to nodes, and know how to create new image styles (or ImageCache presets in Drupal 6).
- Simple node lists in Views. You have built simple node lists using the Views module, and can handle basic fields, filter and sorting settings. You might even have tried out exposed filters. You have probably tried creating both page and block displays.
- Non-complex node extensions. You have tried some modules extending node functionality in a single way, such as Automatic Nodetitles, Scheduler or Node Reference URL Widget.
Level 3 – Intermediate Views + complex single-purpose modules
At this level one becomes pretty good at configuring Drupal's most popular module; Views. Important parts of leveraging Drupal's power comes from understanding this module, but there are also some other important parts of Drupal to know before it is time to really fly – not least how to assess modules you stumble upon.
- Views: relationships and arguments. You have used relationships to tie in more data than your base object provides in Views. You have used arguments to be able to display related information on node (or user) pages. You have a basic feeling for default argument fallbacks.
- Views: modify fields. You've found the options for creating links and rewriting the fields in Views. You know how grouping works and can, for example, group a node list by the month of creation.
- Views: Attachments and feeds. You have tried all the display types provided in Views itself, and know for example how to create RSS feeds.
- Views extensions. You have tried some Views extensions, like Views Attach, Views Bulk Operations, Semantic Views, Views Slideshow or DraggableViews – even if you don't know all of them by heart.
- Views integrating modules. You have used modules like Flag, Nodequeue or voting modules and know how to get information from them into Views.
- Simple access conditions. You have had cases where Drupal core's access control wasn't enough, and have tried modules like Content Access, TAC Lite and Organic Groups.
- Feeling for some common modules. You know how to search for modules when faced with functionality Drupal core can't provide, and can pretty often decide which module to use without installing every single one. You are starting to recognise modules that turn up over and over again on your searches, and have probably a list of favourite modules saved away in a text document.
- Localizing. If you're not a native English speaker, you have learnt how to install your own language and complmement interface translation when needed. (But this is not multi-langage sites!)
Level 4 - The outside world
At level four, the configurator can work with Drupal on a meta level. This does not only incorporate finding and applying patterns in Drupal configuration, but also to discover and to some extent get involved in things happening in the Drupal community. It is at this level that installing Drupal starts being a routine task (which in itself is worth a blog post or two).
- Installing and updating. You have routines for installing Drupal sites, possibly automated ones. You have performed module updates and most likely also Drupal core updates.
- Issue queues. You know how to look for bug reports and patches. You know how to report and describe new bugs, and have done this at least once.
- Translation contributions. If you're non English speaker, you have contributed some translations at localize.drupal.org.
- Support. When searching the web for answers to your questions, you have found yourself writing answers to other Drupalists' questions.
- Features. You may have tried out the Features module and exported some of your configuration, and even if you far from always make use of it you appreciate when modules are Features exportable.
- Documentation. You have started to take documentation of configuration seriously, since some of your previous configuration has made others (or more likely, you) nunplussed.
'I kick ass' threshold
Level 5 – Module combinations + basic Rules + basic Panels/Page Manager
At this level the Drupal configurator starts combining even quite complex modules to create powerful functionality. The modules Rules and Panels/Page manager are introduced. Note: Coders don't always reach this level, since learning and applying this kind of Drupal configuration requires as much efforts as coding your own solutions. Non-coders have no choice but to configure. At this point the configurator know all the standard modules pretty well, but there are some features and functions of the more complex modules she hasn't explored.
- Simple Rules use cases. You know how to create triggered rules, rule sets, and how to use rules sets with Views Bulk Operations.
- Simple Panels use cases. You know how to use Panels/Page manager to override node and user pages. You know how to create page variants and have created at least one mini panel. The Views display type content pane becomes common in your configuration.
- Complex views. You feel comfortable using arguments and relationships in Views, even in combination. You use Views (or Page manager) to add menu tabs.
- Module combinations. You combine your standard modules to achieve complex functionality, rather than go looking for modules tailored for this functionality only: managing CCK fields with DraggableViews, limiting CCK reference fields with Views, using Flag for widely diverse purposes, and so on.
- Performance. You start thinking about how to configure Drupal to minimise performance hits. You have probably used Cache Actions. You know in your bones that you're doing something wrong every time you enter PHP code in configuration.
Level 6 – Access configuration + complex Rules and Panels/Page manager
This is about as far as you get as configurator. At this point the configurator can juggle information on the site and make her modules do things that coders find challenging to accomplish. A configurator at this level is both very wide in her module selection, and very picky. Modules that don't cooperate well with the standard tools are almost always discarded, even if they provide 90 percent of the required functionality.
- Complex Rules. You know ho to use Rules Scheduler and can create chained rule sets when necessary.
- Complex access conditions. You can combine modules like Rules + Content Access, Rules + TAC, and node references + ACL to create complex access rules.
- Complex Panels/pages. You feel comfortable building up multiple contexts in Page manager to manage variants, Views arguments, access rules and visibility rules. You have tried using Views as a context, not only as content. You have probably used Panels Everywhere sometime and also glanced at the Butler discussion group.
- Focus on architecture. Before starting to build any site, you think through the site architecture and make sure that it fits any information juggling you need to do. You include caching and performance in your considerations.
- Identifying missing glue code. You can identify where a small CTools plugin, Rules action or other minor addition in the module framework will solve your problems in an efficient way. Surprisingly often you find this provided as a patch somewhere.
'I am mythical' threshold
Level 7 – The secret ninja domain
This is a secret level that no-one has lived to tell about. At this point the configurator can do strange and wonderful things, and have no trouble bridge the gap between configuration and things like coding, hosting issues, theming and deployment. When you have mastered this level, you are ready to do things I would call impossible. Please give me a call.
- Config exports. Every configuration you make is exported and version controlled.
- Multilanguage sites. You can create sites that truly are multilingual, even separating countries and languages, and they always work as intended.
- Pitfall spotting. When reading a site specification, you can spot all the hidden pitfalls that look like easy functionality but actually take 100 hours to accomplish. You probably know how to solve the problems as well. You can estimate how much time it will take to build the rest of the site within five percent error.