Sustainable software development is becoming increasingly important to keep pace with the rapid technological advances that digital transformation brings. In fact, this often involves changing customer and market demands that need to be responded to. And such a response cannot always consist of buying or developing a new software solution. This is neither technologically nor economically sustainable. But how can software be developed sustainably? And what does it actually mean?
Sustainability in software development means developing software solutions that can be used over a longer period of time, but above all can also be changed and further developed. After all, software development is also about using resources responsibly. Developing software requires time, money, and energy. From an economic perspective alone, it makes little sense to meet every new requirement with a completely new product. A software solution is sustainable when it is able to be adapted efficiently and easily to new market or customer requirements.
If you deal with sustainable software development, you also have to deal with Software quality Distinguish. Because high software quality is the basic requirement for flexibly modifiable and further developable — and therefore sustainable — software. Both internal and external quality are decisive.
At the external software quality It is the driver functionality, scalability and efficiency of an application as well as the usability of the software. It must be possible to modify and extend features in a flexible way, while maintaining the performance and usability of the software solution.
But even more fundamental to sustainability is the internal quality of the software, because it forms the basis of the solution and is a prerequisite for high external quality. This depends on the nature of the source code. Three aspects are important: readability and traceability, testability and evolvability. Source code must be understandable at all times and by all software developers, both in its syntax and in its semantics. This means that it must be clearly legible formally and clearly comprehensible semantically. At the same time, it must be automatically testable in detail through unit tests, as well as in its entirety through integration and system tests. The primary goal is a high degree of software evolvability - that is, the "ability" of the source code to be flexibly modified. High readability, traceability and testability are important cornerstones of this ability, but evolvability also depends on code design. In other words, how the source code is structured and organised. But there are also tools and methods that can be used to ensure a high degree of modifiability from the outset.
Writing high-quality and therefore sustainable source code starts even before the actual coding. Namely with a well-thought-out software design. This does not mean how the complete solution and system architecture is structured or what the interfaces will look like later, but how the source code is structured. In the end, it's about the question of how to best get from (customer) requirement to code. And it's worth answering that question with the entire dev team even before writing a line of code. A particularly tried and tested technique for such a procedure is the so-called Flow Design.
In flow design, requirements are first broken down hierarchically to work out the primary functions, called dialogs here. A dialogue always consists of one or more interactions, which in turn can be broken down into data flows. These flows are represented graphically by various symbols and arrows. The aim is to solve the problem from the requirement down to the last detail using meaningful data flows in order to be able to determine contracts for classes and methods. The complete structure, including classes, methods, state variables and parameters, is therefore already known and "only" needs to be converted into code.
Clean Code Development is a value system for software developers that is designed to develop flexible source code in the long term. About values and virtues A corresponding mindset is built up among developers, the clean code principles and practices provide useful recommendations for action and tips for everyday work.
Many of the principles of clean code, which aim to make the source code evolvable, can already be taken into account through collaborative code design with flow design. For example, classes can be divided and designed in terms of their tasks and responsibilities so that there are no dependencies. And consistent test coverage can also be planned using Flow Design.
When it comes to actually implementing the code design - i.e. programming - the Clean Code principles and practices on readability and traceability help. For example, developers should adhere to syntactic conventions that allow the code to be read and entered quickly. This ensures that future developers can easily find their way around the code. Another principle is "don't repeat yourself". This means not simply copying sections of code, modifying them slightly, and then reusing them. If a sequence of commands is used more than once, it is usually badly structured. This makes the code unnecessarily long, increases the risk of inconsistency, and makes it harder to change because you have to make changes in several places.
So far we have only looked at the source code of a software solution. However, to be truly sustainable, software development must always be considered holistically. After all, who and what is the software solution being developed for? Whether it is the MVP or subsequent developments, requirements engineering and user experience design are critical to the sustainability of a solution and must go hand in hand with programming. If mistakes are made or wrong assumptions are made, even the cleanest and most sustainable source code won't do much good.
With Flow Design, you get from requirement to code in the most sustainable way. But how do you get to the requirement in the first place? Many companies continue to follow the path of a requirement specification. There is nothing wrong with this approach as a first step, but it is short-sighted to assume that the specification can simply be worked through piece by piece and the perfect software product will be created. This is because there is often a lack of holistic vision, as not all stakeholders are involved in the requirements definition process. However, it is even riskier to view requirements engineering as a single, closed process. Rather, requirements definition must be a continuous part of software development and the actual starting point of each iteration in order to develop a sustainable product.
If the requirements are not understood by all stakeholders and are not validated, questioned and adjusted on a regular basis, the right software product will simply not be developed. Similarly, if the right perspectives and forecasts are lacking and new issues are not responded to in a timely manner, the half-life of the subsequent solution will also be reduced.
As mentioned earlier, ideally all stakeholders of the future software product need to be involved in the software development process. However, when developing complex business solutions, one important group is often neglected: the future users. The risk is that if they cannot work with the software solution properly, they will be dissatisfied and, in the worst case, will not use the software at all.
In B2C applications, there is much more emphasis on user experience and usability - it's obvious, after all, the users are direct customers. But it is outdated to think that enterprise solutions are primarily designed for the enterprise - that is, to equate the enterprise with the customer. At the end of the day, even in this case, people are using the software product and need to be able to use it - happily, at best. Sustainable software development therefore means involving users (even for enterprise solutions).
The first step is to create user-characteristic prototypes using so-called personas. Based on these personas, user groups can be described in terms of their characteristics, pains and wishes, and interaction concepts can be developed in the next step. It is important to regularly check the assumptions made. Similar to the design of the source code, a high level of test coverage is essential for the user experience. Our Head of UX, Uwe Betzin, explains why usability testing is so important and how you can test your UX design: UX design must work
The question that remains is why not all software development companies develop sustainably. To answer this question, you have to take different perspectives:
Software developer's perspective:
Sustainable code design and working according to clean code is not (yet) an integral part of training to become a software developer. At the same time, becoming a Clean Coder requires a lot of dedication, diligence, and practice. Developers in a company often simply lack the necessary framework conditions to be able to learn and practice clean code development at all.
The service provider's perspective:
Creating these framework conditions, investing in sustainable software development, training staff and implementing appropriate quality assurance in projects involves high costs. Many software service providers do not take such a risk for fear of a lack of ROI.
And even the topic of holistic approach cannot be addressed by every software service provider, as not every company provides competencies and personnel across all levels of development.
Client's point of view:
The initial costs for sustainable software solutions are higher. On the one hand, this is due to the holistic approach to continuous requirements engineering and UX design. On the other hand, software development with clean code initially involves a higher investment than conventional development. These additional costs initially scare off many companies.
What is often neglected in this calculation, however, is the actual idea behind sustainable software — and thus a glimpse into the future. Because if you look at the total cost of ownership over the entire product lifetime, a completely different picture quickly emerges. Let's just take the clean code aspect: If little value is placed on high internal software quality during development, it becomes more complex to implement new features with each iteration. The costs do not increase linearly, but exponentially — and in reality this means that at some point the software can no longer be further developed at all.
Sustainable software development means the development of long-lasting software products that can be modified and developed flexibly and efficiently. In order to develop sustainable software, the following rules should be observed:
Which software quality features are important from a technical & economic perspective and how clean code development can help to achieve them
Clean code development is divided into different grades, which you as a developer climb one by one and repeat in an eternal cycle