Foundations — Technical debt — types, managing

This page builds every symbol and word the parent note Technical Debt uses, starting from nothing. If a term below feels obvious, read it anyway — the parent note assumes you already picture it, and here we draw the picture.

---

1. What is "code" and why can it be "messy"?

Before we can borrow, we need something to borrow against. In this topic that thing is source code: the human-written instructions that become a running program.

The whole topic hinges on this: debt is measured in changeability, never in whether the program is correct. (See the mistake in the parent: "debt = bug" is wrong for exactly this reason.)

---

2. The money words: Principal and Interest

The parent note borrows two words from banking. You must picture a real loan first.

Now map it onto code:

Loan word	In code it means	The picture
Principal $P$	Cost to properly fix the messy code (refactor it)	one big cleanup, done once
Interest	Extra effort each time you edit the messy code	a small tax, paid over and over

Every one of these is a plain number. Let us earn each symbol before the formula uses it.

---

3. Earning $C_0$ — the "clean price" of a change

Picture a change as a job: "add a discount to the checkout." If the code were tidy, this job takes some number of days — call it $C_0$. It is not zero (even clean code takes work); it is the fair price.

---

4. Earning $i$ — how "steep" the mess is

So one change through the mess costs:

$\underset{\text{clean price}}{\underbrace{C_0}}+\underset{\text{extra from mess}}{\underbrace{C_{0}i}}=C_0(1+i)$

---

5. Earning $n$ — how many times you'll pay interest

This is the single most important lever in the whole topic: the same mess is cheap in cold code and ruinous in hot code, purely because of $n$.

---

6. Putting it together — the $\sum$ (summation) symbol

The parent writes:

${\text{Interest}}_{\text{total}}={\sum }_{k=1}^n{C}_{0}i=n{C}_{0}i$

A brand-new reader may not know the $\sum$ sign. Here it is, from zero.

Here the "thing on the right" is $C_{0}i$ — the extra cost of one change. There are $n$ changes, and each adds the same extra $C_{0}i$:

$\underset{\text{change 1}}{\underbrace{C_{0}i}}+\underset{\text{change 2}}{\underbrace{C_{0}i}}+\cdots +\underset{\text{change }n}{\underbrace{C_{0}i}}=n{C}_{0}i$

---

7. The decision rule and the $<$ /  ​ notation

The parent boxes:

$\boxed{P<n{C}_{0}i}$

---

8. Two named-people / named-idea terms

---

9. Supporting vocabulary the parent leans on

• Refactor / Refactoring — change how code is written without changing what it does; this is how you "pay the principal."
• Code Smells — surface signs of mess (duplication, huge functions) that hint at debt.
• Coupling and Cohesion — coupling = how tangled pieces are; high coupling is classic design debt.
• Unit Testing / Test Driven Development — missing tests is test debt; tests are what let you refactor without fear.
• Continuous Integration — slow/manual builds are infrastructure debt.
• Software Maintainability — the overall "how easy to change" quality that debt erodes.
• Agile Sprint Planning — where you reserve a slice of time (e.g. 20%) to pay down debt.
• Debt ratio — remediation cost $÷$ development cost; a single number to track how buried you are.

---

How the foundations feed the topic

---

Equipment checklist

Cover the right side and test yourself — you are ready for the parent note when each is instant.

• What does $C_0$ mean, in one phrase? ::: The cost (in days) of one change if the code were already clean — the baseline "clean price."
• What kind of number is $i$, and what does $i=0.5$ say? ::: A fraction; $i=0.5$ means each change is 50% slower because of the mess.
• What does $n$ count? ::: The number of future changes that will touch this messy code.
• Translate $\sum _{k=1}^n{C}_{0}i$ into words. ::: "Add the extra cost $C_{0}i$ once for each of the $n$ changes" — which equals $n{C}_{0}i$.
• Why does the sum collapse to $n{C}_{0}i$? ::: Because every term is the same number $C_{0}i$, and adding the same number $n$ times is multiplying by $n$.
• Read the rule $P<n{C}_{0}i$ aloud in plain English. ::: "Fix it when the one-time fix cost $P$ is smaller than all the future slowdown $n{C}_{0}i$ you'd avoid."
• What is the difference between $P$ (principal) and interest? ::: $P$ is a one-time cleanup cost; interest is the recurring extra effort paid on every change until you fix it.
• Is debt the same as a bug? ::: No — debt is working code that's hard to change; a bug is code that behaves wrong.
• Name Fowler's two axes. ::: Deliberate vs Inadvertent, and Reckless vs Prudent.
• What does "refactor" mean? ::: Change how code is written without changing what it does — the act of paying the principal.