At first, the software was very simple and developers could generate it directly by writing code. There was no planning, but a system was formed based on several decisions.
Later, as the requirements became more numerous, the software could only be developed by a larger number of developers who made up the team. In order to produce the desired product, members of the team were directed to cooperate with one another.
With the increasing complexity of the software, the addition of new functionalities became more and more difficult, as did the finding and debugging. Over time, the idea came up that this problem could easily be overcome by introducing a methodology.
Stages of software development
Every new idea in a program must go through a series of stages of development. At a general level, there are always 6: Analysis, Design, Development, Testing, Production and Maintenance. Each company or even each developer can have a series of sub-stages and also modify the general stages to suit their style. Some developments are named like this because it needs some new objects, but they can be improvements or corrections on other projects.
1. Analysis
It is the first of the stages, it corresponds to listening to the requests for the system. The way of bringing ideas to software is planned, here the programming language and the infrastructure should not be an impediment.
From the system, consultant improvements are proposed that sometimes the user ignores to improve the program. I usually use prototypes so that the user can preview and make modifications before any other phase. At the end of this phase, it is verified if there is a previously installed systems environment or if it is a totally new development. Do not forget to include budget servers, licenses, databases among the highlights.
2. Design
This phase is when all the infrastructure that will support the project is carried out. We usually talk about database objects, especially tables and the relationships between them. All the necessary functionalities are prepared to supply the requirements detected in the analysis. I present a second prototype since the first one only includes functionalities, this one shows some design.
The user always wants to include more things and it must be made clear that this influences the time and cost of the project. After approving the prototype, the proposal is presented and an agreement is reached. The main problem is in calculating the time for the development stages, for this it is better to give an anticipated time but that is paid on the functionalities.
If the project is very complex, it is better to carry it out in stages to avoid overflowing the time and cost of the entire program.
3. Developing
It is the moment of the code is independent of the programming language, of the methodologies, of the style of the programmer, etc. Improvements or objections to program performance may be raised. Within the development stages, it is the most delicate because each modification can change the entire planning. Because of the delicacy of the whole process, it is important that you choose a trusted company, with many released projects, such as software development company VironIT.
This phase itself has sub-phases to implement: analysis and design, coding, engineering tests and adjustments. The progress of the software is usually presented here on the number of total functionalities over those completed.
4. Analysis and design
Unlike the stages of the idea, the programmer must identify processes and functions that can be reused. This, with the intention of taking them to a library for the software. Likewise, depending on the programming language, you can previously calculate the development time on the requirements. If you are interested in learning programming be sure to check www.futurelearn.com.
5. Coding
Library creation ends up being done dynamically, and is modified multiple times as needed. This is so at least in my case, but it may be that the person who made the design, has a lot of experience which would avoid this particularity. After that the forms, screens, reports are made, among other requests. The latter include communication with other programs as well as interfaces among others.
6. Engineering tests
These are the tests of each functionality on each screen or report. Creation, modification, consultation and deletion must be tested in each case. Some engineers often automate this process, but I prefer to do it at least hybrid. Since on the way adjustments and tests are presented on them.
It is preferable to write down all the adjustments to adapt them later, otherwise, this phase could take too long. These tests are different from the main tests since these are carried out by programmers and others by users who normally do not know programming.
7. Adjustments
Some include this phase with the previous one, as soon as it is finished, the tests must be carried out again. There may be multiple cycles that delay projects, but it is inevitable in some cases. On the other hand, if the programmers are very new, there are too many bugs (system failures). Then development teams should have a mix between novice and experienced for all stages of development.
8. Tests
These are tests performed by end users, which must be available. It is advisable to have several users since a single one would not find all the possible faults. A list of tests to be performed can be presented to avoid skipping modules or screens. From here, a large list of detected bugs is generated, which are adjusted in a series of cycles. It is very important to make it clear that no new functionality will be developed.
9. Production and maintenance
The developments are made in local environments, that is, on the developers’ machines. The analysis should make it clear that it is necessary for everything to work properly. Many times we forget the documentation of the program, this is the time to do it. Why not before? Well, the documentation would have to be modified at the same time as the tests. Domains, networks, servers or hosting, etc. must already be available.
From here it begins to run terms of guarantees, such as support and stability. At the end of the warranty period it is possible to carry out an extension on it. But it is even better to offer the external support service on the application or a new project. This is the last of the stages of developing a single version software.
Conclusion
In practice, after noticing problems at a particular stage, developers often reverted to the previous stages. This has led to the development of more advanced models such as: waterfall model with prototypes, V-model, spiral model, a model for rapid application development, chaos model, extreme programming model, model for adaptive application development, model for agile application development, etc.
