CODEgrunt blog

When starting on a new project one of the choices to be made is whether to start from scratch or to go with an existing platform. Starting from scratch means more flexibility but this comes at the expense of requiring more development time. These days I will almost always try to find an existing solution that can be extended so that the client's budget can be spent on customization instead of on re-inventing the wheel. For content management, the recursively named CMS Made Simple is one such option.

When working with a CMS I feel that the single most important criteria is the difficulty of integrating a client's design within the CMS's framework. Many CMS systems fail this requirement right from the get go by either embedding layout into difficult to work with PHP functions (commonly seen with legacy table based layouts) or using a confusingly laid out and / or poorly documented MVC approach (which leads to head scratching situations of having no idea where the layout is coming from).

Note: this is not a knock against the MCV paradigm, just some unnecessarily convoluted implementations of it

The most common workflow is to start with a pure HTML / CSS mockup and then integrate that into the CMS. This means that at the very least any potential CMS application needs to provide:

true template support

Layout needs to be removed as much as possible from program logic for both flexibility and ease of updates.

an approach to page rendering that is not utterly arcane or inflexible

If the flow from template to rendered output is confusing, it will be both time consuming and difficult to make changes. If inflexible, the client will have to conform to what the CMS wants instead of what they want.

readable object oriented code

If the codebase is a legacy one (especially with embedded layout), it will be harder to maintain, more difficult to learn and more prone to code rot issues (bugs, security problems, etc.).

While not the solution for all cases, CMS Made Simple is one of the most straight forward solutions I have come across. To start with, it nails my requirements for true template support and a straight forward rendering pipeline. Template support is handled via the competent 3rd party library Smarty. Smarty is well documented and by using its built in "{debug}" command, it is for the most part trivial to reverse engineer what is available to the template at rendering time. Smarty also covers all common escaping and conditional layout flow without having to resort to inline PHP.

Within CMS Made Simple, Smarty's built in functionality is extended via a "custom tag" mechanism. Custom tags are a way of creating special use logic which can then be referenced within templates without having to rely on gross and kludgy inline PHP or hacking in new functions to the codebase itself. An example would be a custom tag I created for a client which sets up an array of PDF filenames pulled from an arbitrary directory on the web host based on the page alias of the current CMS document. This mechanism is very handy as it allows for quick and re-usable extension of site functionality without having to delve too far into codebase's internals or modifying core files.

The rendering flow in CMS Made Simple is also reasonably obvious and flat:

template -> page

At the top level you have templates and style sheets. Each template can have one or more style sheets associated with it and can via Smarty tags can also include sub-templates and / or other dynamic content. Templates will normally include one or more "{content}" placeholders which represent editable sections of layout under the user's control (there are other placeholders that provide similar functions for images and other content types). Once a template has been setup and associated with any desired CSS files, the next step is to create a "page".

A page represents an accessible spot on your website, most commonly a page containing content ("About us" or "Our Homepage"). Each page will have a spot in the global menu hierarchy and will have a template associated with it. The template dictates what the editing process looks like - you might have multiple content sections for example or your template may call in an external module (a web calendar for example). It is fairly simple for the designer to create a relatively safe environment for the client to be able to edit content without completely messing up unrelated layout. Since the stacking of the layout generation is relatively flat, it is also quick to get from mockup to finished page and easy to track down the source of any problems encountered.

For the basic requirement of creating a website which a client can update themselves relatively safely, CMS Made Simple does exactly what its name claims. So far I have yet to find a comparable codebase that is as easy to work with. For more advanced functionality however the situation is a bit murkier.

How CMS Made Simple deals with anything outside of the core functionality is via modules. If you want to do anything beyond basic content management (static pages) or posting date based articles (news), you will need to use a 3rd party module. For example, the stock system provides a permissions based account system designed around content control which is not intended for public facing functions like adding comments to articles. If you want to setup a blog with CMS Made Simple, you will need to use 3rd party modules to implement everything beyond the basic date based article listing.

On the plus side, there are a wide range of modules available from the platform ranging from "front end users" (unprivileged accounts which can be used for allow comments on articles) to an event calendar to image galleries. On the negative side, this means that some functions that one might consider central to a CMS are not part of the core codebase. The most significant fallout from this design decision is that the modules are not guaranteed to work with future updates and also vary in quality and integration. Personally I see this offloading of maintenance to module developers a significant limitation of CMS Made Simple which reduces its viability for use with community centric websites.

It should also be noted that CMS Made Simple has fairly light server requirements. Unlike huge sprawling systems like Movable Type, CMS Made Simple should function fine on the majority of LAMP web hosts.

Alternatives to CMS Made Simple

I have looked around a fair bit and there are surprisingly few current codebases out there which meet my primary requirement of straight forward templates. One possible alternative is Concrete5. Concrete5's approach to design is to use an inline AJAX heavy editor which allows the user to modify content by browsing the site the same way any regular web user would. It does have a reasonably flexible template system though the granularity is definitely increased and some may find it overly convoluted to get from mockup to usable template. On the plus side it is less dependent on modules for what is arguably core functionality these days. On the negative side, the inline editing scheme can be complex at times and may simply be too time consuming to use in some environments.

While not a content management system, for e-commerce focussed sites Prestashop does include rudimentary CMS function which may be enough to suffice if the majority of your site is dedicated to store functionality. It also uses Smarty as its template engine and is comparatively easy to theme. The codebase is current, actively updated and in general well written and easy to follow.

In Conclusion

I have spent about 30 hours working with CMS Made Simple and so far have been able to solve any issues I have come across. It will not be ideal for all situations but for simpler cases where a client needs to manage content on an informational website it is definitely worth a look.

topics: CMS Made Simple, content management system, PHP