Feeds

Why simplicity starts with design

Four top tips

The Power of One eBook: Top reasons to choose HP BladeSystem

I was talking with a fellow IT professional recently who was saying that you should "program simply" but "design with complexity". I do understand the point that he was trying to make - that is, during the design stage take into account the problems in your domain so that these have been worked out as much as possible before the coding starts.

In many ways this is sound advice as otherwise a solution may be proposed that is inappropriate, inefficient or impossible to implement. However, if this is taken to the extreme, then the design may take on the importance of the final deliverable in the minds of the designers. It may also become complex enough to be worthless!

Last time time I argued to "Keep it Simple Stupid", or KISS, with regard to software implementation. However, it is not just the software that needs to maintain its simplicity - it is also the design. That is not to say the design will be simplistic but rather that it should be as simple as it can be in order to fulfill its requirements.

This in itself sounds straight forward, but consider what I have said here: that the design should be "as simple as it can be in order to fulfill its requirements" - that is a slightly odd phrase. What I am trying to get at is that the design should be no more complex than is needed to help to understand how the software will need to be constructed.

This differs from the requirements of the software itself. Remember, a design is an abstraction of the software that will be written - it is not the software itself. At the end of the day, it should not be as complex as that software - it's a simplified representation of it.

Clear models in any Java-oriented design process, modeling is a key element. An overly complex model may actually be less useful than a simple model anyway. Why? Because a complex model, with a large number of classes, objects, relationships and use cases may actually obscure the meaning originally intended. Worse, the density of elements in the model may actually mean that developers get "model overload" and switch off.

If this happens, then the formal model may be forgotten and developers will work from their own interpretation of the requirements. This may result in the production of an implicit design, which is no more than a set of mental models.

So, how can simplicity in design be achieved? Here are some practices that I believe can help:

Don't try to test designs

As I have said above, a design is an abstraction of the software to be implemented. As such it is not possible to test a design to check its completeness, its suitability or to validate its functionality. So we should not attempt to do so. If we need to validate part of a design then prototypes can be built. If we need to explore some complex concept then a proof-of-concept implementation can be created. We should not pretend that a design is something that can ever be as all encompassing or complete as the resulting software. Instead the test should be: "Is it fit for purpose?" If it passes this test, then it has met its goals.

Use the simplest tools

Tools are another area in modeling that people get hung up on. Some modeling tools tend to promote the creation of large complex models - this may be to do with the modelers creating models for their own sake. However, the use of a dedicated, and isolated modeling tool tends to help promote this. Personally I am a big fan of tools such as Omondo - the Eclipse plug-in that can create models from Java source code and source code from Java models. I like such tools because they are lightweight, do not get in the way of the modeling process and tend to restrict the creation of very large, and potentially meaningless, models.

Use Patterns gently

Design patterns are good things, yes? Not always. Due to their very nature, if a design includes a number of interacting design patterns the end result may become, at best, complex and, at worse, opaque and potentially useless. However, I sometimes wonder whether some designers try and show how clever they are by producing complex designs that encompass numerous design patterns. As Scott Ambler has said: "Use design patterns gently!"

Design with others

Of course most designers do not start out with the aim of producing overly complex designs and models. Actually achieving simplicity in design is a much harder thing to succeed at, than to strive for. One way to keep things simple is by designing with others. In my experience this tends to help to things stay focussed, to ensure that the designs remain meaningful and that they are as clear as possible given the application. It is essentially the design equivalent of XP's LINK pair programming.

Summary

In conclusion, it is important to note that I am not advocating simple design, but rather the goal should be to aim for the simplest design that fulfils its purpose. Thus we should aim for simplicity in design just as we should in actual implementation.®

Boost IT visibility and business value

More from The Register

next story
Apple fanbois SCREAM as update BRICKS their Macbook Airs
Ragegasm spills over as firmware upgrade kills machines
HIDDEN packet sniffer spy tech in MILLIONS of iPhones, iPads – expert
Don't panic though – Apple's backdoor is not wide open to all, guru tells us
Mozilla fixes CRITICAL security holes in Firefox, urges v31 upgrade
Misc memory hazards 'could be exploited' - and guess what, one's a Javascript vuln
NO MORE ALL CAPS and other pleasures of Visual Studio 14
Unpicking a packed preview that breaks down ASP.NET
Captain Kirk sets phaser to SLAUGHTER after trying new Facebook app
William Shatner less-than-impressed by Zuck's celebrity-only app
Cheer up, Nokia fans. It can start making mobes again in 18 months
The real winner of the Nokia sale is *drumroll* ... Nokia
EU dons gloves, pokes Google's deals with Android mobe makers
El Reg cops a squint at investigatory letters
Chrome browser has been DRAINING PC batteries for YEARS
Google is only now fixing ancient, energy-sapping bug
prev story

Whitepapers

Top three mobile application threats
Prevent sensitive data leakage over insecure channels or stolen mobile devices.
Implementing global e-invoicing with guaranteed legal certainty
Explaining the role local tax compliance plays in successful supply chain management and e-business and how leading global brands are addressing this.
Top 8 considerations to enable and simplify mobility
In this whitepaper learn how to successfully add mobile capabilities simply and cost effectively.
Application security programs and practises
Follow a few strategies and your organization can gain the full benefits of open source and the cloud without compromising the security of your applications.
The Essential Guide to IT Transformation
ServiceNow discusses three IT transformations that can help CIO's automate IT services to transform IT and the enterprise.