What Does the Test Pyramid Mean?

I've written about the test pyramid before. It provides a guideline on the type of tests you need and how many. But recently, I got in a conversation on what the test pyramid actually means. Is it about code coverage? Or is it purely about the number of tests? A Brief Recap The test pyramid gives us guidance on how our test suite should look like. We should have less tests that use many components and more that test only one or two components: The reason we follow this guidline is that the tests higher up the…


Disaster-Release Ratio: What Is It And What Can It Mean for You?

I was recently on the Tiny DevOps podcast and mentioned the Disaster-Release Ratio metric. And although I've written about it before, but the podcast made me decide I should dedicate a separate article to it. But before we continue, I came up with this metric while at work with a client, but someone else might already have thought of it before me and just named it differently. If so, feel free to point this out to me. What is a Disaster? The Disaster-Release Ratio is a simple metric that focusses on "disasters." These are bugs that make…


Perfect or Ideal?

When we set out to improve our legacy code and reduce the technical debt, should we go for perfection or for an ideal solution? Should we be perfectionists or idealists? The two may sound similar, but they have important differences. This is a reaction to an email by Jonathan Stark. He sends out a daily email about starting and improving your business. In one of these emails, he explains the difference like this: Perfectionism is a refusal to accept any standarshort of perfection.Idealism is the practice of pursuing ideals, even if they are unrealistic.Perfectionism is about rejection.Idealism…

Read more about the article How Do You Explain Technical Debt?
Photo by Maxim Hopman on Unsplash

How Do You Explain Technical Debt?

Are you finding yourself having a hard time explaining technical debt? You might have a good grasp of what technical debt is and why it's holding you back, but that doesn't mean your manager fully understands. Let's look at some ways you can explain things to management. The Debt Metaphor Ward Cunningham coined the term "technical debt" as a way to explain the concept of taking shortcuts and having to bear the consequences. So you can explain technical debt by taking that literally: it's a debt the team is taking. A certain technical choice is more costly…

Read more about the article How Does TDD Help With Technical Debt?
Photo by Xavi Cabrera on Unsplash

How Does TDD Help With Technical Debt?

If you've ever worked with me, you probably know I'm a big proponent of test-driven development, TDD. It's benefits are great, and drawbacks minimal. Often, the downsides exist in the critic's imagination or come from someone who has little experience with TDD. But if TDD drives our design, what if we already have a design, however bad. How can TDD help with technical debt? Allow me to elaborate. The Usual WorkFlow As a short reminder, TDD works as follows. Before you start writing (or changing) code, you write a failing test. Then, you add or change the…


Measuring Technical Debt

Once you realize you have a problem of technical debt, or if you want to investigate your code to see if the problem exists at all, there are objective ways of measuring this. Here are some metrics that might interest you. Why Metrics Before we list the metrics, let's briefly discuss why they're important. Metrics can objectify a discussion about technical debt. Some team members may think the situation is extremely bad while others may say everything's fine. These discussions can become emotional, especially if people take criticism on their code personally. Metrics will give you objective,…


The Human Side of Legacy Code

I've written several articles on the technical sides of legacy code and technical debt. But now, let's focus on the emotional side, the human factor. I've touched on this previously, but would like to expand on it a bit further. What Frustration Can Lead To Working with legacy code can be frustrating. Especially if there is not enough room to improve it. Or if there is room, but the team can't seem to succeed in improving, for whatever reason. Frustration that is left unaddressed for too long leads to all kinds of bad things. Developers can start…

Read more about the article Strangle Your Legacy Code
A Strangler fig growing around a boulder at Katandra Reserve, near Gosford, New South Wales, Australia - https://commons.wikimedia.org/wiki/File:Strangler_fig_boulder_katandra.jpg

Strangle Your Legacy Code

So you've decided to do something about that piece of legacy code that is taking too much of your team's time. Then you should be aware of the strangler pattern. Your Options When dealing with a piece of legacy code, you basically have three options: do nothingrefactorrewrite I've written about the first option, when it's OK not to touch the legacy software. I've also written a lot about refactoring and specifically about the choice between refactoring or rewriting. If you've been following this blog, you know I prefer a refactor. But sometimes, a rewrite is necesary. Like…


When Upper Management Doesn’t Want to Pay Off Technical Debt

Are you convinced your team should spend time paying off technical debt, but you can't get upper management on board? Here are some ideas that might help. Collect Numbers Upper management or the board of directors work a lot with numbers. Their job isn't always easy: the people they manage are most often not happy with the resources they get. They usually want more so that they can achieve more. But C-level managers need to take all groups, interests, budgets and future plans into account. So when you think they're taking a bad decision for not paying…

Read more about the article Categories of Technical Debt
Photo by chuttersnap on Unsplash

Categories of Technical Debt

There are many ways of categorizing technical debt. Here is just one way. I divide technical debt along two axes: intentional vs unintentional and known vs unknown. And I'll briefly mention a fifth category that doesn't fit well with these axes. Intentional Technical Debt Technical debt can be a conscious decision, like a real loan. It can make sense to incur technical debt. For example, if you need to find out if a certain feature will be used and is worth developing further. In that case, you might want to implement a minimal version quickly, to measure…


End of content

No more pages to load