Legacy system: IT siege lion's eternal pain

I often feel that we are very lucky that we are in an exciting time, we are entering the era of the software industry. In this era, our software development is no longer a small workshop, we are conducting large-scale development in a group. The software we develop is no longer an auxiliary tool designed for a certain workshop or a certain process. It moves from a certain unit to the entire group, to the entire industry, and even the entire society, playing an increasingly important role. The role and influence of a set of software has far exceeded everyone's imagination and has become an indispensable part of a region, a society, and even an entire country. Slowly, it has become difficult to imagine what life and work would be like without such and such software or system. This is an important characteristic of the era of the software industry.

However, in this exciting era of the software industry, the major software companies at the center of the era are depressing. The scale of software is getting bigger and bigger, the structure of software is getting more and more complex, but at the same time, the quality of software is getting lower and lower, and software maintenance is becoming more and more difficult, so that every small change needs to be hurt. move bones. Developers are at a loss for this, and testers become the only savior, and every small change needs to be tested at a huge cost. Software companies are struggling in such a vicious circle. There is no doubt that this has also become a scene of this exciting time.

In the past, the life cycle of a set of software was only 2 to 3 years. With the change of software requirements, we always chose to push the software down and re-develop it, but now this situation is changing. With the expansion of software scale, the accumulation of software data, and the improvement of software influence, we, as well as our customers, truly feel that it will become more and more difficult and impractical to tear down a set of software and develop it again. As a result, our software will be modified, maintained, modified, maintained...forever. What a painful thing this is!

A set of software, when it is first developed, everything is very clear: clear business requirements, clear design ideas, clear program code, after several requirements changes and maintenance, everything has become less so clear. The business requirements document has become ambiguous, the design ideas have been unable to keep up with the pace of changes, and the program code has become bloated with the complexity of the business logic. Programmers start not understanding code, and software development becomes less of a pleasure.

Over time, the software went through years and dozens of changes and maintenance, and things got worse. The original programmers have chosen to leave because they don't want to see their code anymore. His successor became even more clueless, and because he couldn't read the program, every modification of the code was like walking a tightrope. The tester becomes the only hope, and every modification by the developer means that the tester needs to test the entire program. Successors began to question the programming of the original designers. If any new technology happens to appear at this time, it will make the original system even more dilapidated and unbearable.

I believe this is the embarrassing situation that all enterprises in the software industry era have to face. Is the stumbling really our original design wrong? Yes, we've all questioned ourselves this way, so we started trying to put more effort into software design at the outset. We began to invest more time in requirements research, consider more possible requirements changes, make more interfaces, and achieve more flexible but complex designs. And then, have we solved our problem? Apparently not. Requirements didn't change as we thought: Changes we thought were possible didn't happen, turning the design we made for them into gimmicks; changes we didn't think about happened, caught us off guard, and the software The quality started to drop and we were beaten back to where we were. Is there really no cure for stumbling? In my opinion, if we do not understand the laws and characteristics of software development, then we will never find the long-awaited antidote. Now is the time, let us really calm down and analyze the laws and characteristics of software development. (Continued)

Related Documents
Legacy Systems: IT Siege Lions Perpetual Pain
Is Demand Change the Root of Evil?
What is system refactoring?
We should change our design habits.
Small steps and fast runs are like this (top)
Small steps and fast running work like this (bottom)
Code reuse should be done like this (1)
Code reuse should be like this To do (2)
code reuse should be done in this way (3)
it is not easy to do code reuse well (1)

Special note: I hope that netizens should indicate the author or source when reprinting this article to show respect for the author, thank you!