The Six Laws of Good Software_

Hacker News
Featured image

In the digital age, software has extended its tentacles into virtually every aspect of our lives. It pulls the strings behind the magic of our smartphones and computers, drives the revolution in our cars, and has even found its way into our household appliances. Even our refrigerators and vacuum cleaners have not been spared. But what separates outstanding software from the rest? To answer this question, we explore six universal laws of excellent software.

1. Law of Simplicity

The first and unshakable commandment of top-class software is simplicity. Overengineering is an all too common disease in the world of development, and unfortunately, the consequence is often unnecessary complexity that is shifted onto the user. Instead, the user longs for software that is characterized by a smooth implementation, intuitive operation, and trouble-free operation.
At its core, top-class software should be designed as simply as possible to facilitate both navigation for the user and onboarding for new team members. It’s an undeniable truth that complex software and messy spaghetti code can be off-putting and increase the risk of errors. Therefore, simplicity is not a luxury, but a key principle of good software - a beacon that points the way to high usability and effective use.

2. Law of Robustness

Good software is characterized by not only running smoothly, but also mastering the unpredictable. Whether it’s a user error or an unexpected situation, the software should be resilient enough to tolerate errors and still work continuously and reliably.
Despite all efforts, absolute robustness is often a kind of ‘Holy Grail’ of software development that is rarely achieved in practice, especially when necessary system software components are missing or do not function correctly. In such cases, however, the software should at least be able to issue a useful error message and shut itself down in an orderly and controlled manner. For even in the face of failure, good software remains true to its reputation for reliability and user-friendliness.

3. Law of Maintainability

A central principle of excellent software is its maintainability. It is designed so that it can be updated, modified, and improved effortlessly. This feature becomes important when considering that software is often used over a long period during which requirements and technological standards can continuously change.
Optimal code is governed by the principle of modularity, which allows for flexible insertion, replacement, and removal of components. But even more important is the clarity and thorough documentation of the code. These properties not only enable a better understanding of the software architecture, but they also pave the way for effective maintenance and continuous improvements. Because well-documented code is like an open book that opens the doors wide for innovations and adjustments.

4. Law of User-Orientation

Optimal software lives and breathes the user; the user experience is the centerpiece and pulse of all digital solutions. It’s not just an aspect to be considered, but the foundation on which the software architecture rests. It is tailored, sculpted, and polished to meet the expectations, requirements, and feedback of users. But it’s not enough to just listen to the voices of users; they need to be integrated and incorporated into the software.
First-class software is not only intuitive to use, but it’s also a beacon of functionality and efficiency that makes users' working lives easier. For this vision to become a reality, future users need to be involved in the development process from the beginning.
The so-called user-centered development is not a linear process, but an iterative journey that builds on the foundation of direct communication with users. It typically consists of the following stations:

  1. A thorough analysis of the usage context to set the stage for the development process.
  2. A clear definition of requirements that forms the template for the software design.
  3. The conception and design itself, which form the core of the software.
  4. A rigorous evaluation that checks and verifies the effectiveness and value of the developed solution.

5. Law of Performance

Good software must be powerful. It should not only work, but also act seamlessly and efficiently by effectively mobilizing the system’s own resources. It is lightning-fast, responsive, and operates in a perfect balance to keep resource consumption to a minimum. Here, “efficiency” is the guiding principle; a term often confused with “effectiveness”. But these two concepts are not synonymous: effectiveness refers to achieving set goals, while efficiency describes the careful and optimal use of resources.
Regrettably, efficiency tends to take a back seat during the early phase of projects, which can lead to potential obstacles later on. Effectiveness remains consistently important, but it often conflicts with efficiency - efficient code can be too complex to understand at first glance. Therefore, the development process requires a high degree of finesse to balance between efficiency and effectiveness, depending on the specific requirements and goals of the project.

6. Law of Security

The last but by no means least law of high-quality software is security. It is the bulwark that shields user data and information from the constantly changing attacks and threats of the digital world. It respects the privacy and confidentiality of users while remaining robust against external threats.
However, security in software is not just an additive aspect or an afterthought feature - it is rather a cornerstone of the software architecture. The axiom of software security calls for a development that embodies “Security-by-Design”. This requires that security is not treated as an afterthought, but as an essential building block that is integrated into the development process from the very beginning.

Amidst the constant flow of technological change and evolving requirements, these laws prove to be timeless and consistently relevant. They are our guiding star on the path to ensuring quality, efficiency, and user-friendliness in the software world. They assist us in creating and using digital tools that not only serve to simplify our daily lives, but also enrich them with every click and keystroke.