Succesfull Software 3/4: Future-proof applications for lower TCO

No matter how great your software looks, how intuitive and how feature-rich it is when deployment, it is bound to be challenged by changing requirements over its lifetime. Enter the importance of future-proofness: long-lasting software must be easy to maintain, adapt and extend.

The cost of running and maintaining software – updates, fixing bugs, etc. – can be massive, amounting to 15 or even 20% of the initial cost per year.

Ensuring high quality and future-proofness starts from the early stages of your software project. Here’s how our digital factory team builds software that keeps running well – whatever the future brings:

1. Understanding your business value: Cegeka foundation phase

At Cegeka, we all love (new) technology. Yet, we put your business at the heart of our applications. After all, the first and foremost requirement of future-proof software is that it meets customer expectations – today and in the future. That’s why we start every complex software development project with the foundation phase: a series of workshops aimed at understanding your business drivers and the software (architecture) you need to meet those needs – to make sure we build a first-time-right application.

Learn why the foundation phase is the basis for software success

2. Choosing proven, future-proof technology

When determining the technical scope, i.e. the architecture and technology stack needed, the future-proofness of the technology – languages, frameworks, methodologies, etc. – is top of mind as well. Thanks to years of experience and continuous training, our software engineers are not only familiar with the latest and the greatest trends and technology; they also understand which technologies are well-supported and are here to stay. We’ll use these as the solid foundations of your system.

3. Writing code: the power of discipline, teamwork and simplicity

The future-proofness of your software greatly hinges on the quality of the software architecture and code. High-quality code is easier to maintain, adapt, complement with a new module or new functionalities, or run in a new environment. Our software developers consistently adhere to best practices to ensure high-quality code:

• We write clean, reusable code that is easy to understand by colleagues, easy to test and read and is self-explanatory to those maintaining the code in the future.
• As two developers work together in a pair (pair programming), we produce better- quality code, making it easier for others to read it and modify when needed.
• All the code written belongs to the whole team (collective code ownership). That means that any developer can edit any piece of code and start working on the next iteration.
• We systematically keep the code organized and decluttered and improve its readability and maintainability. In this way, we minimize technical debt: the risk that faults from the past must be rectified before new features can be added (continuous refactoring).
• Continuous testing – both automated and manual – from the very start of the project helps developers detect bugs or deviations from the scope as soon as possible, before they affect the code, and support rapid changes of the application without the fear of impacting the existing code. A quick test helps verify that that entire application keeps working. In addition, we continuously monitor the code’s maintainability via tools, such code analysis tools.

Keep it simple! By writing the simplest-possible code, we ensure your software is easy to maintain: everyone can make changes and extend the system with new features.

Need proof of the maintainability of our software?
Read our software development story for Ventouris that is still future-proof after 15 years

4. Embracing feedback – in short, iterative feedback loops

Our developers work in short sprints, ensuring they can easily make changes to the code without too much impact on the timeline and the budget. At regular intervals, we meet with you to set priorities – if necessary, by comparing the cost consequences of an extra feature or of a reported bug with the cost of developing or fixing it.

5. Sharing knowledge

Best practices like pair programming, collective code ownership, code reviews and our agile development approach in general, facilitate knowledge sharing across the team. In this way, we ensure that our teams have in-depth knowledge of your system – rather than just one engineer who has been working on the system for a long time. Moreover, we work in close cooperation with you, transferring knowledge to ensure the continuity of your system.