Some developers seem to think that writing tests for a software application is the best and only thing needed to write good software. It isn't. There's a lot more to it than that.
When you design or architect a piece of software, you need to be aware of the needs of all people that are somehow involved in it.
By needs, I mean the human needs or concerns that form the purpose of the software's existence. To write good software you need to be aware of these.
Needs
A need is something that is essential to the well-being of a person. I use the term need in the sense of Maslow's hierarchy of needs. People have a variety of needs and they expect some of these needs to be fulfilled by the software application.
These are some of the human needs that are related to software:
- Basic needs
- Safety
- Esteem / Respect
- Belonging
- Creativity
There several types of people involved in your software:
- end-users: the people that actually use your software
- developers: you, your fellow developers, others
- business: managers, CEO's, business oriented people
These people have many different needs. Most of which you don't know about. But in some way they are reflected in different software aspects.
Aspects
Software has a number of needs-related characteristics. Let's call them aspects. These characteristics can be reduced to one or more basic human needs.
Functionality
This aspect simply says that the software should do what it's supposed to do. Have lots of features and no bugs.
The functions of a software application helps a person to fulfill all kinds of needs: from buying food to spiritual growth. This is part of why it's so interesting to be a developer. Your work can be used in almost all fields of life.
Lack of functionality brings disappointment to users. They will try competitive products, if possible. Good software helps people to reach their goals and fulfill their needs.
Needs: all types of needs
Elements: features, usability, documentation, short time-to-market, bug-free
People: end-users, business
Speed
Processing speed is a pervasive aspect of software. Faster is almost always better. Why? Because whatever you want from a piece of software, your need will be fulfilled earlier if the software is faster.
Slow software leads to frustration, an emotion that expresses that needs are not fulfilled fast enough. Only fast software can bring people in a state of flow.
Speed is tricky, because at the start of a project, the software you create is fast enough. It just becomes slower and slower as you add more features, or add more data. So you need to think ahead. Create a design with the working software in mind. Picture your customers using it, and estimate the amount of data they will be processing. Plan for scalability.
Needs: all types of needs
Elements: hardware, architecture, scalability, optimization
People: end-users, developers, business
Maintainability
Maintainability is about the time it takes for someone to change the software. The time it takes to learn it; the ease of making changes.
If your software is maintainable, you and other developers are able to be creative while developing it further. Maintaining software builds a community of developers and this leads to a sense of belonging. Working on well-maintainable software lifts your self-esteem and the esteem of the other developers.
Needs: esteem, belonging, creativity
Elements: elegance, simplicity, architecture, design patterns, documentation, tests, code conventions, logging
People: developers, business
Security
Security is both a software aspect and a basic human need. People need to be safe, and feel that their software is safe to use.
Needs: safety
Elements: privacy, risk analysis, input checking
People: end-users, business
Low Cost
And then there is cost: software development costs money, of course. I call this "low cost", because the lower the cost, the better.
You can also think of cost in a broader sense: the negative effects of the software to society, and to the environment.
The cost of software is not simply reducible to a human need.
Needs: any, indirectly
Elements: timely delivery, cost of development, cost of maintenance, environmental cost
People: end-users, business
About these aspects
These aspects are not cast in stone. I just made them up ;) I just picked some to waken your awareness to these things. You may find another subdivision more useful.
The aspects are orthogonal: they don't overlap, and the one cannot be reduced to the other.
But even though the aspects are orthogonal, they are not independent. Every new feature may reduce the speed. All aspects need maintenance. Everything that must be made costs money.
Note the "people" parts of the aspects: if "developers" are not listed among them, you will need to place yourself in the position of other people to understand their needs. Security, for example, is not important to the developer. The developer will need to consider what the end-user and the business will consider important when it comes to security.
In architecture design these aspects are usually called "stakes" and the people that are involved, stakeholders. The difference this blog tries to make is to emphasize that these stakes are based on human needs, and that makes it a bit more personal.
Balance
You will find your self thinking: yes, I understand. These are all worthy causes, but it takes way too much time to build software that fulfills all these aspects!
You are right. And this is exactly the point! First you need to be aware of all these aspects. Then you need to weigh all of them. Then you need to come to the right balance: which aspects are more important and which are less important, in the current project? You can just keep this in mind; or you might put it in writing if you intend to set a standard.
But you need to consider these aspects early on in the software trajectory. They are architectural decisions. Changing your stance on these issues may be very hard and costly.
Balancing aspects is the most important role of a software designer or architect.
Finally
You may have noticed that writing tests is just a small aspect of software design. It helps to write maintainable code, but it is not the whole picture. Some projects benefit more from focusing on other aspects. And in some projects automated tests are just a waste of time. It all depends.
