Runnig old systems smoothly again by relaunching a software
Technologies as well as concepts are constantly evolving and have made enormous leaps in recent years in the development of web applications and web-based software. While certain concepts, processes and architectures used to be reserved for high-level languages such as JAVA or C, they have long since arrived in
However, all software has to be maintained and provided with important updates, so that these legacy systems run smoothly again after a software relaunch. With its server/client architecture, web-based software here benefits form its centrally maintained server, so no actions are required on the user’s systems.
Software updates and upgrades
Every software and application requires continuous support and maintenance, as security holes have to be closed and new functions can be made available by new versions.
Here a distinction is made between minor updates and major upgrades. These are often reflected in the version number of software (major before the dot, minor after the dot).
Reduce technical debt through refactoring
Clean up and improve code
Software that has been developed or extended over a longer period of time accumulates so-called technical debt, so that software refactoring should be considered in order to reduce it.
This perhaps can be compared to a flat in which you live for a long period of time, but where there hasn’t been time to clean up in between. Things accumulate in places where you don’t really need them anymore and there are corners where stuff is deposited that doesn’t belong there.
Refactoring involves tidying up and improving code, writing omitted tests to increase test coverage, and cleanly resolving “shortcuts” that may have been built in along the way before they cause further development difficulties. Or, in addition to reducing complexity, missing documentation can be added.
This often makes the software more robust and the further development easier and therefore cheaper. The invested budget for the refactoring saves, among other things, ideally later on the development budget.
A certain budget for refactoring should be continuously planned and invested, especially for products or applications that are used over a longer period of time.
Tell us about your software and we will be happy to advise you!
ACTUAL analysis / TARGET concept
Whether an upgrade, a refactoring or a new development is planned, the first step is always the preparation of an ACTUAL state analysis and a TARGET state concept. After we have took inventory, we suggest possible solution options and explain the advantages and disadvantages if necessary.
It allways begins with the creation of an ACTUAL state analysis and a TARGET state concept
In addition to the application itself, additional installed components or modules must also be taken into account, for example in the case of a major upgrade. The upgrade may result in previously used additional components of the application no longer being available or being replaced by alternatives. In this case, the upgrade may be more complex or the data transfer may have to be planned more precisely.
We can, if required, provide an estimate of the effort required to update the software, before the lifecycle of your major version expires. In doing so, we take into account which functions and modules have been used so far and whether corresponding updates are also available for them. If not, we suggest alternatives and advise you on the possible options.
Once the decision is clear which type of software modernization or relaunch is most appropriate, the implementation & conception is planned. For this purpose we create appropriate tickets for the upcoming tasks in our project management software. The tickets describe in detail what has to be done and possible dependencies can be defined.
They then serve as a basis for developers and system administrators and there state reflects the progress during the implementation.
Preparation for modernisation
In preparation for a software modernization, normaly a copy of the current software is installed on a dedicated development server or staging system so that the adjustments can be made without creating issues in the productive system. This way, you can also perform the acceptance of all adaptations and modernizations yourself at a later date without interfering with productive operation.
Testing, the quality factor of software projects
Then, first of all, the software is equipped with tests, since often no or only few tests are found in outdated software. This increases the so-called test coverage, a decisive quality factor for software projects and products. This also enables finding and correcting of already existing errors. Since a software upgrade often includes upgrading existing functions, the tests can then ensure that these functions continue to work and that all dependencies remain intact. This significantly increases the maintainability and quality of the code.
Implementation and programming
The next step is the implementation and programming, which begins with a static code analysis, the source code review. This analysis identifies, for example, obsolete functions, missing namespaces, incorrect naming and other errors in the code. Based on this, the code can then be revised and modernized. If the code is compatible with the desired version of the framework or CMS the software was developed in, an upgrade can also be made.
When performing the modernization, unused code can be identified and removed and the performance of the code can be improved.
Import of old data and testing
When all work is finally completed, the old data that has changed since the work began is imported from the productive system. At this point, the new code is "married" to the old data and the updated software is ready for use.
Afterwards, the customer can perform the acceptance test on the staging system.