The largest underground “movement” in the Drupal community is the desire for a shift in goals, which has been labeled Smallcore. This movement has been rapidly growing among Drupal developers, who instinctively understand the need for and advantages of such an approach, but up until to now there has not been any concrete and constructive communication to the rest of the world about why we feel this approach has merit.

This article is meant to provide an overview of what we, as developers, mean when we bandy about the #smallcore tag, which unfortunately has been misconstrued as a desire to just rip out as much code as possible without any thought about our users. This is actually not the case at all, as #smallcore is intended as a way for us to better serve our end users.

Introducing the Drupal teddy bear

Out of the box experience is important, and a user interface is the sum of the assumptions that get made about how the product will be used. Assumptions are incredibly powerful things — they are the difference between a bad product and one that people actually want to use.

So let us assume for the moment that out of the box Drupal comes as a pretty basic teddy bear. This teddy bear has all the essential elements that make it a teddy bear, and it can further be customized by dyeing it a different color and dressing it up in different costumes.

The main components of any stuffed animal are the stuffing, which is loosely analogous to the modules used, and the fur, which is like the theme layer. You can further add additional pieces of clothing, which I relate to features and or other pluggable modules that can be added after the installation.

We also have the ability to automate the assembly of all of these components for mass production, using the Drupal installer which accepts all the required components and uses an install profile as a “sewing pattern” to stitch everything together correctly.

Furthermore we have been moving towards solving the packaging problem through projects such as Drush Make and the upcoming install profile packaging on drupal.org so that we are even able to ship you everything you need to build your own customized bear out of the box.

Where it goes wrong

This methodology of building sites and applications based on Drupal has served us very well up to now, but we have started reaching the limits of this approach. One of the major selling points for a large majority of developers in the Drupal community has been that Drupal will allow you to build nearly anything, or to relate this to the visual metaphor of stuffed animals, any kind of stuffed animal that you can think of.

The pain points that are starting to become apparent is that as we are building more products that differ from the assumptions that Drupal makes about how it will be used, we are dramatically increasing the amount of work and negatively affecting the usability and stability of any such products that we build. A large portion of time spent building something like Managing News or Open Atrium is spent undoing the assumptions that Drupal has baked into core directly.

To put a finer point on this, the more Drupal becomes a better teddy bear (which is what the D7UX project was attempting), the less useful it becomes for all the other use cases that Drupal is currently being used to solve. Because Drupal core is trying to please both of these audiences at the same time, it means that changes for the end users who just want a better teddy bear are being sacrificed for people who need to be able to build different stuffed animals with it and vice versa.

It should also be noted that this is affecting not just people who are building distributions, but also people who are building any relatively complex site. Instead of having your install profile be instructions for assembling your stuffed animal, it becomes a far more complex system for dissassembling and modifying an already pre-assembled teddy bear.

What smallcore is all about

The crux of #smallcore is the need to re-think our production line by manufacturing and shipping the minimum amount of stuffing and fabric that is needed to create all the stuffed animals we might want to make separately, and moving the assumptions that we are currently making about how Drupal will be used out of the box to the install profile, where it belongs.

By re-thinking and refactoring how we build Drupal the CMS (the teddy bear in this case), we gain the freedom to make assumptions about how end users will use it, which in turn means we will be able to put together a much higher quality product than we would have before without limiting the flexibility that developers cherish in Drupal. We will finally have the flexibility to choose a single WYSIWYG editor to use in the CMS, and stick to and use an image handling mechanism that makes sense for our product.

Other products based on the Drupal framework will also gain the freedom necessary to implement the assumptions they need to make, without fighting the way that Drupal already works. As a result of building the Drupal CMS in the same way as other applications of the Drupal framework are built, we will also finally work out how to make building our own applications more easily, which will result in a much more sane and flexible API for developers using the framework.

Smallcore is not about changing what the Drupal project is building. Our primary goal is still to build a kick ass CMS, but with smallcore we will be changing how we build it. At it’s heart it is about building a better teddy bear and making it easier to build any other stuffed animal you can think of.