All software development stages matter
When we are building software, it is important to be aware that the program we are developing will have several years of life (production), and not that everything will end when all the functionalities that the client requested are programmed. This brings great responsibility in the design of the system so that it is easy to maintain and scalable:
A very important factor to take into account when designing software is the amount of information that is going to be handled within 4–5 years. This is a common problem that I have observed when creating applications, many times software developers do not have a long-term vision of the conditions to which the program is going to be subjected, in this way the software is designed as if it is never going to have a lot of information, for example, ALL the records are obtained from the database, maybe this will work during the development of the application, but believe me, this will not work in a few years when the application has more than 20K records, It is very likely that the user will have to wait more than 5 seconds, and even if this amount of time sounds very little, for the user is a lot, and they will assume the information is not going to load, and in the worst case a time-out will occur causing an error in the software.
The example above is not only a problem for users, but it also causes many problems for the company that developed the software, just think about it, to solve these optimization problems the company will have to invest valuable resources such as time and programmers, which is a problem that could have been easily avoided with a good software planning, and a good long-term vision of the operation of the project, so that means it is possible to avoid doing the same thing twice because the first time it was badly done.
It is also very important to think of other programmers when developing a project, by the others I mean the programmers who will be maintaining the software. We must stop being selfish and stop writing code that is difficult to understand and modify. Although this code works, it will not make the work easy for one of those in charge of maintaining the software (we can be one of them). Many hours can be invested just because someone did not care about the maintenance stage or other problems that it can cause.
Tests can often be the enemy of programmers, there is nothing more frustrating than having new functionality ready and then running the tests to see a lot of red letters destroying the happiness of having finished the task. But as much as we hate tests, there is a great reason why they are implemented in the project, and they assure us that the code that is currently working and is still working after some time. The code we write does not change, but the libraries do change, causing many errors in the project. Sometimes it happens that software developers decide to remove the tests that are failing due to the fact that they stopped working out of nowhere after some years, and thus when the tests are run on GitHub the expected green check appears. This action is not going to bring any good to the project, firstly because tests that are being removed someone had to invest time, and secondly, how are we going to know if this functionality will be more damaged over time? The easiest solutions are not always the best ones, we need to be good programmers and professionals, and do the job well, even if it is a complicated task
The next time we are going to develop a new project it is important to take into account that the maintenance stage is very important and essential for the project, the work does not end when the clients start using the program, there is more than that, for this reason, a long-term vision is crucial for success.
