Good Software

Simple solutions require very good software. But good software is very challenging. Hard to create and often expensive and complex. But there is good news: For almost every business IT problem good open (FOSS) software exist.

The definition of good is always context dependent. There is no overall universal qualification of good software. Software quality depends on the product (product quality) and the process used for creating and maintenance. You can use ISO 25010 to determine a subjective rating for software product quality. An objective standard is impossible since quality always depends a context. But fortunately there are common principles that makes it easy to distinguish good from bad software.

In general good simple software is software that does the job well, simple and without strings attached. 

Good software for your problem meets your requirements. Good software solutions share a number of common capabilities. Common capabilities found in good software solutions are:

  • Meet the functional requirements of the task in a simple way.
  • Robustness and long-term stability.
  • Battle tested for security flaws and risks are transparent. So no hidden backdoor or features. Since security is always context related: It is clear for what purpose the software is designed for and secured for.
  • Designed and created using privacy by design requirements. So only data that is needed is stored and protected.
  • Verifiable trustworthiness of functionality. E.g. by using repeatable test that are maintained. 
  • Ease and low cost of training for effective use.
  • Ease and low cost of maintenance.
  • Minimization of effort for maintenance.
  • Ease and low cost for modification.
  • Ease of replacement. The data model and all external APIs should be documented. So using a drop-in-replacement is easily possible. 
  • Compatibility and ease of integration with other applications.
  • Long-term availability of individuals able to train, maintain, modify, determine need for changes, etc.
  • Simple. So the software is not very flexible or highly configurable. So the software is no holy grail package or generic solution that can do everything simple (in theory) : You should always strive for the least amount of flexibility in your code as more flexibility means more complexity. Keep in mind that good design is an imperfect design and that a good code base can easily be refactored for other use-cases if necessary. 
  • Usage risks are clear. So all dependencies that can cause disruptions in usage are transparent. 

These capabilities for good simple software are often seen in FOSS software building blocks. Security, privacy and quantification of risks do require transparency. Full transparency of software code that can make or break your business is often hard to get for COTS software (Commercial off-the-shelf) packages.