Now, it is time to deliver the results of your work. However, the components that you deliver should not be considered a final product. With each iteration, you can improve pieces of software even if you already delivered them. The key point here is that you do your best to start deploying as soon as you can to show the value of your modernization effort.
The following sections describe some of the activities that you should consider in this phase.
Documenting the application
It is likely that the new application is different from the old one. You must create effective documentation that explains the new application to the people that do maintenance and the users and stakeholders of your applications.
Take advantage of any available resource that can help you document. Use class, sequence, and deployment diagrams to help people understand the application. Most types of Unified Modeling Language (UML) diagrams are designed for object-oriented languages, but you can adapt them easily to your situation. The advantage of using a standard type of diagram is that many people can understand them easily, which makes you seem more professional.
Your documentation must add value. So, avoid documentation that goes directly to the shelf. The usage of content management systems (for example, MediaWiki, WordPress, and Joomla) can help you create simple and collaborative documentation.
The documentation must be easily maintained. There are many tools that can generate documentation from the code or from the compiled objects. Use them (or create them) if possible.
Training the people
Depending on the modernization approach, you might have to train the users, the application maintenance personnel, or both.
The documentation that you previously built should be used as the primary reference for the trainees. Make sure that this documentation can be accessed easily and that it contains all the necessary information for the users and for the IT experts.
If the new application is more difficult to understand than the original, this is a good indication that the modernization plan needs improvement. Evaluate the new system from different points of view.
Defining your deployment strategy
Just as there are many modernization approaches, there is more than one way to deploy the new application. Make sure that both approaches are aligned. Here are some of the most common deployment techniques:
Big-bang approach
This approach for deployment replaces the entire application at one time. This approach is used with modernization projects that must solve an immediate problem affecting critical services. However, the associated risk is higher and must be carefully managed.
When you follow this type of approach, it is necessary to maintain the old application and the new application in parallel. The issue is that changes in the new system should be reflected in the old one and vice versa. This situation can lead to much work and effort.
Incremental approach
Also known as “Phased-out”, in this approach, sections of the application are re-engineered and added incrementally, which allows you to deliver results and identify errors more quickly.
When you follow this approach, you can change only one component at a time without considering the application as a whole. Thus, the modernization process might take longer to finish.
Evolutionary approach
Similar to the incremental approach, the evolutionary approach replaces sections of the original application with modernized parts. The difference is that in this approach, the sections to replace are selected based on their functions and not the structure of the application. This situation means that the developers put forth extra effort to identify functional parts that are separated in the original application.
To help you understand the differences in these approaches, consider this brief comparison of the three approaches.
