Simplicity as the truth

I am opening my blog with a (slightly) bold statement “Only a simple design is a good design“.

In my role of application architect I have seen the designs of many IT applications and I have also designed multiple applications or components myself. Therefor I have frequently reflected on the following question: What is a good design?

Like a new building cannot be built without a design, an IT application cannot be implemented without a design. The purpose of a design is multiple, e.g. it is meant

• to convince stakeholders that the application covers the business requirements,
• to guide the development team in implementing the application,
• to make sure that the application is built on a solid and – at the same time – extensible foundation,
• to prevent that pieces are duplicated, but – instead – reusable components are identified,
• to make sure that the application is transparent and maintainable (also for developers that were not involved in the initial development).

It is challenge for an architect to meet all these goals. The design must be understandable for a large group of people with different backgrounds. That is only possible if… the design is simple. Or at least the architect should be able to structure his ideas in such a way that the intended audience perceives it as simple. On the one hand that means that the architects must be able to identify the right (sub) building blocks and indicate the correct techniques to be used. On the other hand it means that he should also make use of the right visualization tools, such as overview pictures, interaction diagrams, process flows, UML schema’s etc.

From my experience I have learned that if the audience has difficulties in understanding the design then you have to revise it. For example by splitting up parts of the design into smaller pieces. Or by making better use of visualisation tools. And sometimes it is even better to replace a highly flexible but abstract design by a less generic but more understandable design. In such cases the loss of genericity is earned back a design that is 

• more easy to understand, 
• quicker to build, 
• less error prone (and thus will result in less test of production defects),
• and better maintainable,

which – in my opinion – are characteristics of a well-designed application.

But what if it concerns a really complex application? Then  the challenge is to still break it down is smaller components with a simple designs.

This has brought me to the conclusion “Only a simple design is a good design”. Or stated differently “Simplicity is the truth“! Or is my perception of the truth too simple?