Your current software. Vital, but faltering?
Your software is vital, serving essential business processes and often encapsulating your intellectual capital at the same time. But it gradually ages, outgrows its original scope, is used in unforeseen ways, or its quality declines due to ad-hoc modifications. Languages become outdated, or enhanced UX demands introduce new challenges. This poses important questions. Let's resolve your legacy challenge, together.
"When should I refactor and how?"
"Shall I refactor or redevelop, what are the tradeoffs?"
"To what extend should I migrate software?"
"How do I migrate proprietary functionalities?"
"How do I resource a refactoring or migration project?"
Our value & offering
- Remediating technical debt
- Levelling up: UI & deployment
- Remediating security issues
- Replacing proprietary software
- Replacing implementation languages
- Replacing spreadsheet implementations
We have extensive migration and refactoring experience, in industries ranging from high-tech to finance. From surgical replacements to full-scope application-migrations. Together we assess your challenges, weigh return-on-investment and identify a roadmap to resolution.
We blend in to do the work together, or we take on the entire scope as a turnkey-project.
Software refactoring. A new lease of life for your code.
Refactoring is the systematic process of improving code without creating new functionalities, by transforming compromised code into clean code and simple design. Obtain code that makes maintenance and future developments predictable, before a seemingly workable situation develops into an ownership nightmare.
Code quality deterioration origininates from a gradual buildup of inefficient code, also known as technical debt, or postponed maintenance. This is often caused by tight project deadlines, resulting in quick fixes or workarounds that never mature into decently integrated solutions. Today's relief, but tomorrow's sub-optimal code.
Remediating technical debt
Technical debt mitigation starts with identifying code smells: indicators of common code quality problems. In addition, low-quality documentation, insufficient test-suites and self-made management tools are often added to the list of actionable items.
We revive your software in a phased approach, addressing the hardest things first: starting with modularization, by separating functionalities and workflows into proper backend and frontend orderings. From there, we further granulate design along the single responsibility principle, where each section of code performs a single, well-defined and testable task. The end result: rejuvinated code. The pain removed, the jewels intact.
Common code smells:
Poor variable handling
Substandard variable naming or the use of global variables, that can be modified from everywhere, and which state can affect every operation.
Code, methods and classes that have increased to unmanagable proportions, resulting in difficult to grasp code, often as the result of ad-hoc developments.
Incorrect application of object-oriented programming principles, often resulting from unforeseen scope extensions or local refactoring efforts.
Imposing shotgun surgery, being forced to make many small changes to many different classes, while implementating functional change.
The presence of dead code, lazy classes, duplicate code or partially unused methods or fields. Often the result of ad-hoc and unmatured functional change.
Excessive coupling between classes, making change cumbersome to implement. Often the result of poor design.
Depictions: Refactoring Guru.
Levelling up: UI and deployment
New generations of users and developers, in evolved roles and responsibilities, require enhanced capabilities from legacy software, typically in the realm of deployment and user experience. The most prevalent use-cases we see:
- Moving from stand-alone use to a multi-client service
- Moving to a web / cloud-based setting
- Requests for improved user experience and GUI capabilities
- Integration in larger business workflows and reporting chains
- Employment on other platforms like Linux/Windows
- Unlocking availability to external parties
We build modern (web) UI on top of your legacy software, while proofing it for deployment in one go. Or build and deploy yourself, using Simian Web Apps: deploy on-premise or in the cloud, and manage authorization yourself. Level up, quickly and cost-effective.
Remediating security issues
It is no surprise that many developers do not embrace security in their development process. They often feel like it is not their job. Also, neither the benefit of addressing security concerns nor the risk of ignoring them are immediately obvious. However, application security is increasingly critical to the viability of software and platforms.
We help with code security. We protect code, applications and platforms from unauthorized (data) access, modification, or exploitation. This involves identification and mitigation of security vulnerabilities in the design of your code, and your deployment platform. A new lease of life for your legacy code, secured and future-proof.
Software migration. A new lease of life for your IP.
Migration involves moving one or more software programs from one implementation to another, while minimizing reengineering efforts. The motivation for this is, above all, the timely renewal or even survival of your intellectual property and operational workflows. From obsoleting proprietary code to language-reimplementations, together we engage the challenge with confidence.
Replacing proprietary software
The case for moving to open-source software is often obvious: reducing costs, obtaining flexibility, removing dependencies from third parties or a mix of all these. However, migration is often an arduous task: from “identifying the right technology” to “deploying the new version”, a lot of hurdles are to be crossed. Let us help. Following a strong migration framework, together we mitigate the common risks involved:
- Identify the right technology
- Simplify your existing code base
- Create self-contained modules
- Separate internal code from external dependencies
- Code refactoring where required
- Update and list external dependencies
- Provide documentation and examples
- Back-to-back comparative testing
With our phased approach, combined with your guidance on how to share the work, cost transparency is ensured. Together, we break the proprietary chains that hold you back.
Replacing implementation languages
"Old" software languages do not necessarily mean obsolete, and "old" software may perform just as well as "new" code, as FORTRAN proves so often. However, new generations of developers are trained in newer languages and modern software concepts, posing barriers to get deeply involved in legacy code. The need for new functions in old code, in a timely manner, therefore often builds the case for migration.
We know both the old and the new, and the mixtures in between. Depending on code size and other factors, we start with defining a suitable strategy. We help you navigate the decision processes and take on the reimplementation as you see fit. Your software, future-proofed at your own pace.
Phased or piecewise migration, calling new fuctionalities from within existing code. Care is required for type conversions and performance (data comms). Appealing option, as it allows stepwise and risk-managed conversion. Ideal for large conversions.
The option with the highest lead-time as it requires full migration in one go, yet the simplest one. Also the best performing one, as there will be no data conversions between languages.
Typically suited for larger and modular projects. Often used for partial or surgical language migrations.
Replacing spreadsheet implementations
Microsoft Excel is still widely used, and for good reason: it allows domain experts without programming background to develop elaborate functionalities. A significant amount of intellectual property in use today is developed with spreadsheets. However, models developed in spreadsheets are hard to scale and governance is an issue.
In addition, as methodologies grow in complexity and size, implementations become increasingly error-prone and hard to change. In the long run, risk and ownership costs become unbearable. We migrate your spreadsheet / VBA implementations to code, and redeploy to ensure continuity:
- Delivered as a service (deployed): API or (web) GUI
- Functionalities integrated into larger workflow apps
- Delivered as Excel add-ins: separating code and data
We translate your IP into software. You migrate away from Excel with confidence.
Evolving methodologies and algorithms
Usage of your software evolves: it is used in unforeseen ways, it outgrows the original scope or initial software structures become unfit for incorporating new realities and circumstances. Entirely new algorithms may be in need, or current ones require refitting for increased dimensionality and problem size. Or the software may be required to host more and more use cases.
With our scientific backgrounds, we understand the computational challenges involved. Our extensive scientific software development experience enables us to translate your new concepts into evolved algorithms that work. Your software, modernized for a new lease of life.