Software entanglement is a hidden threat to custom software. Catching the early warning signs, and taking corrective action, helps organizations to avoid lasting damage to business-critical systems – and core business operations.
Thankfully, when you know what to look for, the symptoms of entanglement are easy to spot – even for non-technical leaders with only a cursory understanding of software management. In this blog, we’ll uncover what it is, why it’s a problem, and how to fix it.
What is entanglement?
Entanglement in software code – not to be confused with quantum entanglement – is when the performance of specific software components is overly dependent, or interdependent, on too many other components. When one small thing goes wrong, it can create bigger problems – even bring down an entire system.
Think of software as a machine that processes data. There are data inputs and data outputs. When you build a software system, the main inputs and outputs are usually clear to the user.
But under the hood, there are lots of smaller components performing tiny calculations that contribute to the overall output.
All those tiny calculations have their own inputs and outputs. Imagine it’s like a car engine. If one component goes wrong – say a cracked piston – it can impact the engine functionality or ultimately destroy the entire engine. If you want your custom software to be robust and reliable, it needs to be maintainable so that it’s understandable to everyone involved in managing, modifying, and developing it. That also makes it easy to fix when something goes wrong.
Entanglement is sometimes referred to as ‘spaghetti code’. That’s also a handy way to visualize it – strands of spaghetti that are intertwined in such a way that it’s hard to see where one strand begins and another one ends. The way we assess entanglement is to examine the dependency of each component on other components in the codebase. There are two ways to measure this:
- The number of dependencies for each component in the system.
- The number of cyclic dependencies that modules need to function properly.
The number of cyclic dependencies in a software system should ideally be zero. That’s because any modification to a component could lead to software failure.
Why entanglement is an issue
Entanglement affects both traditional monolithic architecture (a single, large codebase) and microservices (a collection of separate components connected to create one system). For software managers, and their companies, the key question is this: how important is change to your organization?
If you don’t need to evolve or update a custom software system with improvements over time, then entanglement probably won’t be an issue. On the other hand, if you have custom-coded software that needs to evolve alongside your business needs, customer demands, or advances in technology, then entanglement is a potential threat to your business-critical systems.
Here are common symptoms and issues of entanglement:
Ongoing bugs and fixes
Entangled limits complicate your development team’s ability to fix problems when they arise. That’s because if your developers fix one problem, it can create unforeseen issues in other areas of the codebase. This leads to a continuous cycle of bugs and fixes – one bug is fixed and another one appears.
Development and productivity slows
The complexity of entangled code can make custom-coded software hard for developers – both existing and new – to fully grasp. This can impact coding confidence. One consequence can be that developers prefer to develop new components rather than tinkering with existing ones, for fear of creating issues. As we’ve explored in previous blogs, more lines of code don’t necessarily equate to a better system or higher productivity.
Poor reusability of code
Entanglement also limits the reusability of code. Let’s say you have an invoicing module that depends on another dataset in order to function properly. If that module is then reused elsewhere without that other dataset connected to it – say in a webshop – it won’t function properly.
Why fix software entanglement?
Addressing entanglement in custom-coded software has two advantages for your business:
- It improves maintainability. Lower levels of entanglement mean developers can make changes to custom-coded software more easily without negatively impacting other aspects of the system.
- It mitigates risk. By reducing entanglement – and addressing other aspects of software quality – you can ensure business-critical systems stay online.
To achieve these two things, you need deep insight into source code quality. BonCode’s tool-based consultancy for software quality won’t fix entanglement for you. What it does do is provide valuable, visual insights into software quality – including the levels of entanglement. A simple traffic light system indicates threat levels. This enables software managers to prioritize and target entanglement through strategic restructuring, adding key refactoring tasks into development sprint cycles.
Gain actionable insights into entanglement and other aspects of software quality with BonCode’s tool-based consultancy. To discover how, get in touch with one of our experts.
