In a relay race, tight collaboration between runners is essential. Each runner must not only focus on running as fast as possible but also consider how to pass the baton to the next runner in the most advantageous way. Software development is quite similar to relay racing. While "racing" implies quick results, "developing" takes time. If development only focuses on immediate goals without considering future steps, long-term success is unlikely.
Developers love creating new things, but they are often less enthusiastic about taking over maintenance and continuing the work others have started. However, this view might be somewhat misleading. Developers are already working within environments, tools, and methodologies created by others. In this sense, developers don't mind building on top of existing frameworks. Ultimately, what developers desire is a solid base, enabling them to add features and maintain the software effectively.
When developing a new program, many developers focus primarily on "creating" the functionality itself, but development is about more than just making things work. Developers must have a long-term vision, planning for the future while working on the present. Just ensuring that the features work as per the specifications doesn't mean the task is complete. A developer's true task is to anticipate how the software will evolve over time.
The ability to foresee the future is crucial for developers. Implementing features correctly is essential, but over time, nearly anyone can achieve that. What truly sets a good developer apart is the ability to anticipate and plan for the software's operational efficiency. Unfortunately, most specifications and feature documents don't focus on how the system should operate in the long term. The criteria for evaluating a software product often overlook operational efficiency.
Operational Efficiency: Minimizing Human Effort in Software Use, Modification, and Maintenance
Operational efficiency involves minimizing the work required by individuals when using, modifying, or maintaining software. Some might question whether improving user experience (UX) falls under operational efficiency, but poor UX often leads to increased modification work, which, in turn, impacts the efficiency of software operation. Therefore, improving user experience to minimize repetitive and unnecessary tasks is an essential part of operational efficiency.
The key to minimizing human effort for modifications is to maintain clean and maintainable source code. Through constant refactoring, code should remain extensible without disrupting the underlying structure. The deployment process should be streamlined and clear, so developers and operators can manage the software smoothly. Furthermore, the deployment system itself should undergo continuous improvement.
Minimizing Effort in Service Maintenance
The word "maintenance" often gives the impression of a stable, cost-free activity, but maintaining a stable system can actually be quite costly. Maintenance typically involves addressing issues that arise after the system is "stable," requiring significant efforts to resolve problems, even if the system is not actively changing. This creates a need for momentum, which can be draining on developers and operations staff. These activities, such as infrastructure maintenance and minimizing the impact of failures, often result in fatigue for those involved.
The Common Pitfalls of Long-Term Development Teams
At the beginning of a project, team members are usually enthusiastic and eager to contribute. The project has a strong sense of energy and momentum, making it more likely to succeed.
As the project progresses, the team grows, and developers who contributed early on may move on to other projects. As this shift happens, the project may lose some of its initial excitement, and the original team may no longer maintain the same level of commitment.
By the time the project reaches its later stages, the context of the service may be stable, but the context of the code becomes disorganized. When the initial developers leave, those who remain often feel like janitors rather than engineers. This is a cycle that is difficult to reverse, but it can be prevented by thinking about the software's future operation from the very beginning.
The Importance of Thinking About the Future
The key to addressing these issues is to plan for future operations right from the outset. Losing users or customers is a serious problem, but a team losing its passion and motivation is even worse. Developers might think it’s best to work on the exciting parts at the start and move on, but their code, comments, and documentation will last far longer than their initial excitement. Future engineers will judge their work, and they might end up facing the consequences of their short-sightedness.
While it might be tempting to focus only on development, engineers should always strive to improve the quality of their code and think about how their work will serve future needs. Software architecture and operational design should go hand in hand, and the same applies to software refactoring. Developers should continuously improve both the software and the operational systems that support it.