I Want My Apps ASAP: As Simple As Possible

Why Simple ?

Superficially and usually incorrectly, simplicity in technology is equated to lack of sophisticated features and their agility in accommodating evolving requirements. This is implied from words like complex, complexity and complicated used in technology literature or speech to refer to sophistication in applications, their engineering and the underlying domain.

Conversely, complexity is a major cause of faulty and non-performant systems requiring constant maintenance and support. This leads to high development, maintenance and operational costs. Frequent maintenance that does not remediate systems' complexity makes systems brittle. That makes further maintenance troublesome. As a result, complexity adversely affects systems' longevity. Such applications reach obsolescence soon necessitating early replacement or renovation both of which are costly initiatives.

Reducing and Managing Complexity

Complexity in software can be essential, accidental or optional. Essential complexity refers to the complexity inherent in the domain and exists in the application because of the representation of the domain in code. This complexity is irreducible. However, it can be managed such that only a part of such complexity is under consideration at a given time. This can be achieved by decomposing the functionality into cohesive and loosely coupled components. GoF (Gang of Four) design patterns provide several useful abstractions that help manage essential complexity when applied in relevant contexts.

Accidental complexity arises from poor design and implementation. This could be due to

1. an inexperienced team,
2. lack of understanding of the domain, tools and technologies involved in implementation,
3. over-reliance on third party frameworks or libraries,
4. incorrect application of patterns.

Accidental complexity in an application is most easily identified by the lack of testability. For an application to be comprehensively testable, it should be possible to test any of its components independently by mocking or stubbing its dependencies. Testability allows understanding a system and its components. It also makes applications flexible and extensible.

Finally, optional complexity arises from features that are not essential for the application. Reducing optional features may reduce optional complexity. It is not uncommon to find reduction in optional complexity in subsequent versions of an application. This happens once the usage of a particular feature is not high enough to justify its maintenance and support and it is removed. Occasionally a feature becomes optional because of business reasons and is decommissioned resulting in reduced optional complexity. Certain forms of accidental complexity such as shared state, strong coupling or dependency relationships may make reduction in optional complexity challenging.

It is important to identify and avoid complexity where possible. Where complexity cannot be avoided because it adds some other value to the application, e.g., performance, resilience, etc., it should be kept isolated from the core functionality. That helps keep the rest of the application ASAP (as simple as possible).

The Law of Conservation of Complexity

The law of conservation of complexity states that every application has an inherent amount of complexity that cannot be removed or hidden. Instead, it must be dealt with, either in product development or in user interaction.

This law was first stated by Larry Tesler and is also know as Tesler's Law. Tesler, a computer scientist and a HCI (Human Computer Interaction) specialist at Xerox PARC, argued for simplifying user interactions for several users or several repeated sessions. This is achieved by incorporating the complexity of interactions into the system thus increasing its complexity. Thus, if the net complexity of user interactions and system implementation cannot be reduced any further, it can be shifted between user interactions and the system or divided between the two.

Interestingly, this law applies not just to HCI but also generally to software engineering. Computer programs have inherent irreducible complexity characteristic to their functionality. Assuming an ideal situation where further complexity cannot be added into a program, its characteristic irreducible complexity can be divided between the program's components. As each component's complexity is lower than the overall complexity of the program, they are easier to understand and reason about.

Simply Be Sophisticated

Complexity in an application does not guarantee sophistication but simplicity makes it possible to introduce sophistication. It is easy to let complexity slip into applications while keeping them simple requires diligence, discipline and devotion. Therefore, simplicity has to be a part of the culture of a technology organisation to deliver technology that is affordable, usable and useful.

Omar Bashir is a software developer who is passionate about developing systems that are sophisticated and yet simple.