Legacy Code

Approach

• Review your code.
• Gauge feasibility. Is the code sufficiently understandable, and is the change you want to make realistic?
• Outline available options together with the estimated level of risk, timeframe and cost
• Discuss with you and draw up a customized flexible plan for your unique case
• Fix your problem according to the plan. Discuss adjusting the plan with you if any issues arise
• Test the solution in each of the scenarios in which it will be used
• Add automated tests where appropriate to reduce the possibility of future regressions
• Document the changes carefully.
• Document what we learned about your code – to make it easier for future developers

General Policies

• Avoid rewrites where possible. Rewrites are tempting because it’s easy to look at mysterious code and conclude it is dysfunctional or suboptimal. However, battle-worn code often has many bolt-ons to counter specific problems experienced in real-world use. A rewrite may mean discovering and then being forced to solve the same problems all over again.
• Prefer minimal impact repairs. This usually means providing fixes that are as specific as possible, because changing a general subroutine may have unintended effects on existing processes. This policy departs from the DRY (don’t repeat yourself) principle, as we may not attempt to reuse processes which are used too generally or not well understood. Instead we aim to deliver a safe solution which solves your problem quickly.
• Prefer a customised development method to one which is predefined or rigid. No specific method works well in all cases, because each problem is unique. Keeping a flexible approach means using our expertise to deliver the most appropriate solution in the most efficient way.
• Communicate with you at all times. This means providing regular updates of what facts have been discovered during the investigation, the status of any code updates, the results of any testing, and the progress of the project as a whole.

Salvage

“Salvage” applies to Legacy code that has developed problems completely preventing it from operating. It may be tempting to write the code off as useless in these circumstances, or opt for a complete rewrite. However, rewrites are often far less simple than they seem, and can result in escalating costs and timescales, and even result in entire projects ending up abandoned.

On the other hand, careful investigation may reveal the fundamental problem to be something simple. If it ran before, it can’t be too far from running again. Ugly code and mysterious error messages may make the code appear inextricably tangled, but this may be more of an issue with understanding, rather than an insurmountable problem with the architecture. Your code may not be optimal, but it probably doesn’t need to be – it just needs to be functional.

This is where our expertise and experience in dealing with legacy systems comes in. We can help get to the root of your problem much faster, saving you time and money – so you can focus on moving forward rather than being stuck trying to reinvent the wheel.

Optimisation

Your old code may be presenting a performance bottleneck, or your use case may have grown beyond the capabilities the original code can provide. It is often tempting to assume the old-fashioned architecture, code style or choice of language are at fault, and conclude a rewrite is necessary using more modern technologies. However, it is worth remembering that old code was often written in times when memory, bandwidth and CPU power were less plentiful – as a result it is often capable of being just as efficient as anything modern.

A better approach may be to simply get down to detail with your existing system and identify areas where improvements can be made. The prospect of wading into obscure-looking older code can seem daunting, but often the cost of achieving familiarity is far less than the ultimate cost of a rewrite. And with our expertise in getting up to speed (pun intended!) on legacy systems, you can shave the cost further and pull the performance of your system into shape in minimum time.

Enhancements

Your business may have developed a need for functionality not present in your original legacy system. It is usually preferable to code enhancements using up-to-date languages and methods. However your fresh development may still need substantial integration with existing processes, which can present a difficult problem if your code is written in a traditional style, or not well understood.

Our expertise in legacy systems will help you create and integrate the new functionality you need in the minimum time. Where possible we will create new code using present-day libraries and modern techniques – but we will also ensure new features fit old ones seamlessly to leave users believing the new features were always there.

Bug Fixes

Your legacy system may be generally in good shape, except for the occasional undesirable issue. However even small problems can be the limiting factor on user adoption and revenue if they are left unaddressed. If small frustrations have led you to consider a full rewrite, we would advise you to think again. Rewrites often face exactly the same issues that were encountered the first time round.

A better solution is usually to simply fix the original code. This can seem a daunting task if error messages are strange and code appears incomprehensible – however, this is where our experience in legacy systems comes into play. We have the expertise to deliver the fixes you need quickly, without compromising existing functionality.