In a perfect world, every software developer would finish school, build a product from scratch, IPO the company and retire. However, that’s very, very rarely the case and the majority of software people will at one time or another in their careers inherit a codebase that they weren’t involved in creating.
The most common situations where this happens are when a company is acquired by another and when joining a company (because of staff growth or turnover). But, regardless of the reason, the software developers, managers and executives involved are expected to take it over and continue to achieve forward progress.
The problem is that not all codebases are created equal – they can range from absolute disasters to dream scenarios; from the ridiculous to the sublime. Plus, aside from the code itself, there are a number of other factors which have a huge impact on the success or failure of the transition.
So, the purpose of this post is to give a framework for assessing how much of a risk the transition will be. Put another way, it’s also a framework for asking the right questions and for setting expectations at the right level.
How Screwed Are You?…a formula
Every situation is unique, but this is my rough formula to calculate the “Codebase Risk Factor” (CRF):
If you’ve immediately started to glaze-over from the math, don’t worry, I’m going to break it down for you.
This formula factors in what I believe are the 5 main risk factors when you inherit a codebase:
- Test Coverage (“tc“)
- Team Availability (“ta“)
- Team (availability) Duration (“td“)
- Defect Find/Fix Ratio (“ffr“)
- Age of Codebase (“ac“)
The formula then weights each of these factors to give an overall score – the higher the number, the more screwed you are.
Let’s look at each of these factors in more detail.
There are many other places you can go to read more about the benefits of test coverage and Test Driven Development (TDD) in general. I am not going to make that case here.
Suffice to say that, when you inherit a codebase, Test Coverage is your friend.
For those that are new to the concept, Test Coverage is usually defined as a percentage and measures how much of the codebase comes with automated tests that validate whether it’s working or not.
When you first inherit a codebase, you understand almost nothing about it. However, despite that, in most cases you are going to be expected to a. keep it working and b. add new features. Good Test Coverage lets you add and change things in the codebase with a much lower risk of inadvertently breaking something else that you don’t understand yet.
So, how do you assess Test Coverage? Fortunately, for most platforms and languages (in fact all the platforms and languages I’ve come across), there are one or more automated tools to analyze Test Coverage. These are not perfect and you should always ask the developers who worked on the code originally what they believe the Test Coverage to be (more on that below).
Also, beware of getting a false sense of security from a raw Test Coverage % number. Just like any codebase, not all Test Coverage is created equal. I’ve seen many cases where tests are written but they don’t actually properly test the code in question. Again, this is why you should seek out the view of the developers who worked on the codebase originally.
To be blunt, if you inherit a codebase but don’t have any access to the developers that wrote it, I’d say you’re in Big Trouble ™.
Only the original developers know where the bodies are buried: they understand how much Tech Debt has accumulated in the codebase that you’ll need to deal with, they know which parts of the code are solid versus which kept them awake at night and they know which bits of code were written by the good developers and which by that idiot that was fired.
By “developers”, I also count devops people since they are arguably the most important in keeping what you inherit up and running.
Now, by “Team Availability”, I don’t necessarily mean that the developers have to still be working for you full-time (although that would be best) but that they are available to answer questions and provide advice on an as-needed basis.
So, Team Availability is also defined as a percentage. You can either think of it as the % of people (e.g. 2 members of the original team of 10 are available, so 20%) or as a % of the people’s time (e.g. the original developers are available 1 day a week, so 20%).
Team (availability) Duration
Having access to the original team is great but often the follow-on question is, for how long?
From experience, I’d say 6 months is enough for most cases. It’s enough time to learn what’s already there and to make significant forward progress with new features. After 6 months, the original developers no longer have familiarity with the newest code so their usefulness starts to diminish.
If you’re planning on acquiring/inheriting a codebase, I’d recommend that the absolute minimum you should try to keep the original team available for is 3 months.
Defect Find/Fix Ratio
The Defect Find/Fix Ratio is simply a measure of how rapidly bugs are being found in the code versus fixed in the code. It’s a useful measure of how troubled the codebase is at the point in time you inherit it. If bugs are being found faster than they’re being fixed, that’s an indication of a problem.
In practice, the amount of time allocated to bug fixing varies based on the team’s other commitments and, therefore, the Find/Fix Ratio will tend to oscillate. So, it’s good to look at the Find/Fix Ratio over a period of time; the past month at least. The lower the ratio, the better.
Age of Codebase
While it’s true that code itself doesn’t age or rust, older codebases are, in general, more problematic.
There are a number of reasons for this: firstly, the older the codebase, the more likely that the people who wrote the code are no longer available and/or have forgotten how it works.
Secondly, the older the codebase, the older the versions of the libraries, packages, tools, etc that it depends on, unless there has been very deliberate effort to update these (hint: this rarely happens). This makes it much harder to make changes to the codebase, especially if some of the versions it depends on have reach end-of-life or are no longer compatible. This is all Tech Debt that you will have to address before you can move forward.
Let’s imagine that ACME Corp acquires Widgets Inc and the poor VP Engineering at ACME Corp inherits Widgets Inc’s codebase.
Widget Inc’s codebase is 4 years old. The team has been pretty stable at 10 people but 7 of those people have quit in anger because of the acquisition. The remaining 3 have been persuaded to stay around for 4 months in return for some ongoing stock vesting and a retention bonus.
The VP Engineering quizzes the remaining 3 and runs the test coverage tool. He also looks at the bug tracking system to see the recent trend. He discovers that Test Coverage is about 40% and, in the past 3 months, 280 bugs have been reported, of which 80 have been fixed.
So, here are our inputs to the formula:
- test coverage: tc = 40%
- team availability: ta = 30%
- team (availability) duration: td = 4 months
- defect find/fix ratio: ffr = 280/80 = 3.5
- age of codebase = 4 years
Plugging them into the formula, here’s what we get:
So, this yields a Codebase Risk Factor of 320, compared to (as the mathematically-inclined will have noticed) a perfect score of 20.
In layman’s terms, pretty screwed.
Agree or disagree? Please leave a comment.