Off-the-shelf software packages are rarely a perfect fit for your requirements; this means you have to make some changes. Given a choice between a configurable package and a customisable one, which is preferable?

As ever it depends on your specific situation but I favour a configurable core with customisable extensions.

Some definitions might help:

  • Configurable software has settings and switches that enable specific behaviour for various features. For example the Options or Preferences dialogs in browsers and email programs. In larger software packages there's usually an administration component not generally visible to end users. The point here is that you are making choices from options already built into the package rather than reprogramming.
  • Customisable software allows you to change the programming directly and write specific sections of code that produce exactly the results you require.

Why is Configurable better?

The short answer is that you don't have to maintain it. This is especially important for commercial packages where the customisation has to be done by the vendor (or some other certified provider).

What I think you should avoid at (nearly) all costs is having a separate code base from the general user community. Software packages evolve over time, with regular minor updates and less frequent major updates. If you have code customisations then any updates may either (a) break your custom code, or (b) require that you re-write it to suit changes in the core. Neither of these is a Good Thing (unless you're a software house, in which case go wild).

When is Customisable good?

The 'stick to the common code base' rule mostly applies to the core elements of a package.

Some systems, especially open source ones, provide extension mechanisms that allow developers outside the core team to write their own add-ons that use defined interfaces to the core. This interface approach means that the core package can change internally without requiring any changes to (properly written) extensions.

You still don't get to ignore the update problems - interfaces also evolve, so a major version change may still mess up your custom code, but it's less of a problem.

For instance...

Joomla is a good example; it provides

  • a core code base which you generally don't touch
  • an administration interface for configuration
  • an extension mechanism so that you (and lots of other people) can add functions (and an active community of extension writers)
  • a template mechanism to control visual attributes
  • an override mechanism to isolate changes to the core code so that they are not overwritten by software updates (although they may still break).

It's rare to get this level of control in the commercial world, but you should expect to configure things like custom fields, security levels and report layouts without having to resort to code customisations.


Joomla extensions directory

Joomla developer documentation