Scalability, Extensibility or Maintainability

I’m currently trying to make my way back to Holland right now after being snowed in yesterday in East England and having to deal with flight cancellations from Norwich and London.  During this time, I’ve been thinking about a project I’m currently involved in and how due to a very high level functional spec and a technical spec that really lacked a solid architectural plan, it is becoming more complex and in my opinion is starting to mould into a solution that could potentially be difficult to support.

The functional spec for this project was based on some very high level use cases and although the spec is what the project team use as a functionality reference, the use cases provided where very general and contribute to the lack of process detail in the functional spec.  Because of this, the technical spec lacks any kind of detail, there are very little Class diagrams to show the component objects, no sequence diagrams to illustrate object interaction and just a general lack of visual notation to illustrate and explain how the solution was to be implemented.  That said, the high level proposed architecture was very good and has lended well to the system at its current point in development (but hey, I’m a little biased on this front).

So back to my travel situtation.  I managed to get myself onto an overnight ferry from Harwich in the South East of England to the Hook of Holland in the Netherlands (the Hoek van Holland as it’s known to the locals).  I’m currently killing time waiting for departure and thoughts wonder over to the important aspects of systems design and the creation of a solid and sufficiently detailed solution document.  Further to this, I got thinking about what is THE most important design consideration (apart from the obvious delivery) to take into account in terms of a solutions Scalability (how a proposed solution scales up and out), Extensibility (how easy it is to extend / develop further) and Maintainability (how easy it becomes to support the system and maintain the code in a finished product).

Personally I think Maintainability is the most important.  Why?, because if the architecture is designed and the code is written with maintainability in mind, the resulting solution should not only be easier to maintain and support, but is clean of the tweaks and hacks that creep into projects as bugs are fixed and change requests are satisfied (new code which falls outside of the original vision and design).

If it is a clean system in terms of  code, then it should be an easy job to extend its functionality and scale that functionality.  Surely.  Anyone, with opposing views, please do comment, I’d love to hear alternative takes on this.

… Time to board 😉


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s