Many existing systems have a substantial amount of older code, which may
be poorly organised, or organised in a more traditional way
incorporate mysterious design choices and be difficult to understand
utilise modules or libraries which are no longer maintained
employ deprecated functionality or language features
be written in languages or styles that are no longer common
We specialise in legacy systems meeting these criteria. We are experienced in dealing with projects of every size, from basic scripts to large-scale applications encompassing hundreds of database tables, and code lines numbering in the hundreds of thousands.
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
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” 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.
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.
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.
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.