Login
You're viewing the mstdn.social public feed.
  • Mar 1, 2025, 3:16 PM

    My understanding of the popular understanding of "technical debt" may be out of date. In your experience, when people say that phrase in casual conversation, do they *primarily* mean:

    * crappy code that someone ought to fix sometime?

    * deferring some useful action because the near-term benefits outweigh the additional cost to doing the action later?

    * getting a partial solution out quickly because it will teach you what a better solution would look like, despite that meaning rework?

    💬 19🔄 4⭐ 3

Replies

  • Mar 1, 2025, 4:18 PM

    Note: I'm not asking what technical debt *should* mean, but rather people's offhand use of the term. (Emphasizing "offhand" because people often have a surface meaning they act on, even if – when probed – they will find they have a different definition. But is that the definition that affects their day-to-day *actions*?)

    💬 0🔄 0⭐ 0
  • 💬 2🔄 0⭐ 1
  • Mar 1, 2025, 3:54 PM

    @jmeowmeow @marick my words, one is specific and limited to refactoring code. Deferred action might be upgrading a dependency or compiler or merging a feature branch, or even more broadly, knowing that a spike needs to happen and the longer its put off, the more costly it is to do. Like you know that your current db driver is end of life and need a new one but don't know what yet.

    💬 1🔄 0⭐ 0
  • Mar 1, 2025, 4:00 PM

    @Spoofer3 @marick Thanks. I have seen crappy code in the form of contagious copy paste without refactoring and found it unclear whether a decision to defer cleanup was deliberate or an unrecognized choice, or "this is no longer a hot part of the code, no cleanup is needed".

    Vs. "This is now the wrong shape but we don't have a short path forward".

    💬 2🔄 0⭐ 0
  • Mar 1, 2025, 11:07 PM

    @jmeowmeow @Spoofer3 Thanks partly to @Spoofer3's critique of a draft explanation, I'm shifting my explanation of the original technical debt metaphor to a tool deployed to allow a money guy to make the correct decision (fund refactoring so that the structure of the app matches the understanding of the problem) without forcing that person to become expert enough to make judgments in an unfamiliar domain (programming). (1/3)

    💬 1🔄 0⭐ 3
  • Mar 1, 2025, 11:07 PM

    Core, in my theory, is that in business, taking on debt is an *investment* that lets you do something that would otherwise be too slow or impossible. Also, debts get paid back as a matter of course (in Ward's business's context – short term debt – defaults would have been rare, I'm guessing.) (2/3)

    💬 2🔄 0⭐ 1
  • Mar 1, 2025, 11:07 PM

    So the metaphor hovers somewhere between "explain" and "explain away." Cynically, it could be seen as giving the money guy a reason not to ask more questions. Whether the metaphor really *does* illuminate something about the nature of software is secondary. (3/3)

    💬 1🔄 0⭐ 1
  • Mar 1, 2025, 11:14 PM

    I have a likely bogus speculation that "technical debt" lands differently for people who view debt as a way to fund current activities rather than as an investment. E.g., someone who doesn't pay their credit card balance off each month. (I was raised to believe that if I kept an outstanding balance on my credit card, all my German ancestors would rise up and drag me down to hell. So I never have. I did take out a small loan to afford a car once, to my eternal shame. Old-style Germans are weird.)

    💬 1🔄 0⭐ 2
  • 💬 1🔄 0⭐ 1
  • 💬 1🔄 0⭐ 1
  • Mar 3, 2025, 12:20 AM

    @cliffordheath In the original metaphor, it's the difference in... shape?... between the solution complexity in the programmers' heads and that expressed in the code.

    I have this notion that you have to grab new insights about the solution and instantiate them in the code, else they'll get lost and whatever's in the code will take over (especially for new people).

    💬 2🔄 0⭐ 1
  • Mar 3, 2025, 12:58 AM

    @marick In my experience, "new insights" are almost always mere inventions/abstractions designed to manage solution complexity, but which pile up so as to always increase the solution complexity and actively to block simplification efforts. "Solution complexity in the programmer's head" must be reduced by problem analysis, not by jumping to solutions

    💬 1🔄 0⭐ 1
  • Mar 4, 2025, 3:44 AM

    @cliffordheath I have a complicated relationship with simplicity that I've never been able to boil down to an, um, simple position.

    💬 0🔄 0⭐ 0
  • 💬 1🔄 3⭐ 1
  • Mar 5, 2025, 11:43 PM

    @tottinge @cliffordheath Yes. I'd built up this elaborate theory of how the debt metaphor was used to justify taking the time to put the learning into the code. Justifying it to "the suits." But he told me a few days ago that he doesn't remember if he ever described it to them.

    Another great theory cratered by lack of evidence.

    💬 2🔄 1⭐ 2
  • Mar 6, 2025, 12:44 AM

    @marick @tottinge @cliffordheath

    Sounds like he prepared to tell "the suits." Should the need arise, I assume. Perhaps it never did.

    Still, he clearly did use the metaphor as a tool to assist with thinking about the matter.

    💬 0🔄 0⭐ 1
  • 💬 2🔄 2⭐ 1
  • 💬 0🔄 1⭐ 1
  • 💬 1🔄 0⭐ 2
  • Mar 10, 2025, 1:55 PM

    @marick @RonJeffries @cliffordheath "Why are those developers still complaining about a change they had to make, like, 4 years ago?"

    "Because for them, it's not over yet; they have to deal with it every day."

    "You'd think they'd get over it."

    "It doesn't stop getting in their way. They were still trying to deal with it yesterday, which is why they brought it up."

    This is hard to explain. I keep trying.

    Exhibit A: agileotter.blogspot.com/2025/0

    💬 0🔄 2⭐ 1
  • Mar 7, 2025, 10:58 AM

    @marick Those two aspects of debt - borrowing as an intentional act and paying back a defined amount - are what make me avoid the term. I find the term technical debt is often used to launder short-sighted development and management, underresourcing, and basic neglect.

    I saw the term used recently in a slide deck describing our project - we are designing a small nuclear reactor to be licensed, built, and operated at a site we own and are actively preparing (i.e. this is very much not a "paper" reactor). We do a lot of work in parallel and our QA process requires we track Open Items and Assumptions Requiring Verification. Stuff like "We used software <X> which has not yet been qualified for use", "we don't know the dimension of this room because it hasn't been designed yet so we estimated how big it might be", or "we don't have a reference for the data and correlations used in this software and can't confirm they're applicable or correct*"

    We qualify software and issue calculations with Open Items, each of which are tracked, assigned an owner, given a description, and conditions for closure. We have a formal tracking system and accountability. Between design cycles we burn down the Open Items list by resolving each issue.

    In this case I'd say the debt metaphor is accurate and justified. We need to meet a schedule, we are doing work in parallel that in a perfect world would be done sequentially, and we cannot afford to quietly sweep problems under the rug**. Schedule-driven engineering sucks but it's the world we live in so we do our best to do it responsibly. Open Item tracking has been done for decades in big engineering projects like this. We don't have bots that close issues as WONTFIX just because nobody commented on it in a month. We don't have engineers closing OIs to meet metrics. We address each issue or ensure it is no longer relevant before closing it (i.e. we redid the analysis with software <Y> which is qualified for use and revised our calculation). We track our debts and pay them back.

    * Tell me again how LLMs and generative AI help me do my job vs actively making everything worse

    ** I was laid off in 2017 from a division of Westinghouse unrelated to the project that basically lost $6-12 billion and cooked the books to hide it. Now I'm on a similar project and I'll be damned if I let anyone pull that shit near me and sabotage this project.

    💬 1🔄 1⭐ 1
  • Mar 7, 2025, 11:33 PM

    @arclight That's an interesting and impressive story. Good for you!

    I had this speculation that the shift in the meaning of technical debt happened when it came in contact with people who didn't naturally think of debt as an investment (you take it on to speed things up, with the knowledge that you'll pay back extra later). My homebuilder dad had that attitude; other than that, he had the traditional German horror of debt. (1/2)

    💬 1🔄 0⭐ 1
  • Mar 7, 2025, 11:33 PM

    So the metaphor encountered people who treat credit card debt as funding current expenditures, endlessly rolled over. The assumption that paying it back was the end of a limited-duration process was unnatural in that context, so got lost.

    I now think that's bogus. But it would be a tidy theory, so there's that. (2/2)

    💬 0🔄 0⭐ 0
  • Mar 5, 2025, 10:46 AM

    @jmeowmeow @Spoofer3 @marick I can throw in one more "deferred action": "We don't have a clear design signal in the code yet to inform a refactoring, so we're waiting to see what happens next and adjust to that reality."

    💬 0🔄 0⭐ 1
  • Mar 5, 2025, 10:44 AM

    @jmeowmeow @marick IMHO, "deferred action" means "we chose not to build that yet though the code is fine", whereas crappy code means "we made a mess that we didn't cleaning up."

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 3:21 PM

    @marick i voted crappy but it definitely covers two possibilities, (a) code that's crappy because someone did it in a hurry and (b) code that used to be fine but that's an annoyance now because design preferences have changed

    💬 1🔄 0⭐ 1
  • 💬 0🔄 0⭐ 1
  • Mar 1, 2025, 3:23 PM

    @marick I suspect it's devolved into a synonym for "crappy code" that ought to be fixed but never is.

    My understanding of the concept is that you deliberately don't care too much about doing maintainable or thorough because the benefits of it asap are a priority. And then you're supposed to pay it off.

    What I like: code is never perfect, and if it's particularly imperfect and you need to be there again, you fix it first, without talking about debt.

    💬 2🔄 0⭐ 1
  • Mar 1, 2025, 3:27 PM

    @marick Talking about technical debt, creating issues for it, letting stakeholders prioritize it, has its place but I think has a risk. Those tend to be always at the bottom of the priority pile.

    I'd rather communicate to stakeholders that a priority that touches on messy code will take longer, and then fix any mess as part of the normal work.

    💬 1🔄 0⭐ 1
  • Mar 1, 2025, 11:28 PM

    @faassen My speculation – not yet confirmed with Ward – is that the metaphor was used to *not have to* explain programming to the stakeholders. To these stakeholders (I'm guessing), (1) debt is taken on to enable you to do something *now* that you'd otherwise have to do later or never, and (2) of course you pay it back.

    It makes "as we learn more, we have to revamp old code" into a "sure, that's the way my world works" rather than a "justify yourself."

    metaphor.wiki.oddly-influenced

    💬 1🔄 0⭐ 1
  • Mar 2, 2025, 12:18 AM

    @marick
    My understanding is that it isn't about
    code that's difficult as not enough has been learned yet, but code that deliberately takes shortcuts to accomplish its goals faster as a sounder (more accurate, featureful or maintainable) solution would take longer. Perhaps you argue that coming up with a sound solution that takes longer is always a learning process?

    💬 1🔄 0⭐ 0
  • Mar 2, 2025, 12:26 AM

    @marick
    Does the concept of technical debt only exist in the context of equally functional solutions to the problem, and the only difference is whether the history of the solution remains in the code or not, i.e it's only about refactoring?

    Or is it broader than that and there can be externally observable differences beyond maintainability - performance, usability, missing features and the like? So the technical debt leaks to the outside, but may still be worthwhile to stakeholders.

    💬 1🔄 0⭐ 1
  • Mar 3, 2025, 12:30 AM

    @faassen Talked with Ward Cunningham today. Although he coined the phrase, it was not that important to the actual company where he coined it. (My belief that he used it to "sell" refactoring to the "suits" was wrong.)

    So I'm now in the camp that we should just do away with it. It obscures more than it reveals.

    💬 1🔄 1⭐ 2
  • Mar 3, 2025, 2:07 AM

    @marick Interesting! I think there are different points when one might use it to explain

    * the cost of taking shortcuts explicitly for speed of development

    * that it's unavoidable because we're always learning that debt accumulates

    * why we should "fix" the shortcuts as a separate task, because they hinder development

    * why a task will take longer as we first need to tackle the cost we incurred earlier

    That's rather muddled. We could just use the words I just wrote too.

    💬 1🔄 0⭐ 1
  • Mar 4, 2025, 3:53 AM

    @faassen Yes. I think metaphors have a role. But I'm no longer sure the technical debt metaphor can be used to say anything much about the role of metaphor in organizing/aligning people.

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 11:21 PM

    @faassen The original metaphor is specific to an assumption that understanding of the problem ought to be embedded in the code, and that the history of design changes that led to today's code should not – it just makes things harder to understand.

    But the point I'll try to make in the upcoming episode is that the metaphor lands differently for people who think debt is something to be paid back vs. something to be rolled over into more debt.

    💬 0🔄 0⭐ 1
  • 💬 0🔄 0⭐ 1
  • Mar 1, 2025, 3:30 PM

    @marick I would say technical debt is that which stops you from adding new, useful features… not because the new feature would be hard, but because it would be hard in this product. So mostly the crappy code one, but it’s not really about it being crappy or about it being code.

    But “crappy code“ is exactly what most people mean, I think.

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 3:30 PM

    @marick IME ~90% of the time it refers to one of:
    * leaving older versions of dependencies in use (libraries or service API versions)
    * unoptimized code (eg SQL query that was fine when a table had 1k rows but is not fine now that it has 1m rows)
    * team decided to move from one pattern to another, but some components still use the “old way” leading to confusion and annoyance

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 3:32 PM

    @marick I've generally understood it to mean an easy, short-term kludge that should work properly 99% of the time, used in order to reach a deadline, with the intention to replace it with something more robust and safer, but then the person gets handed more work on something else and the kludge never gets fixed, then additional kludges get added to fix issues people had begun noticing elsewhere but didn't have time to track down the cause. The work to fix the original kludge grows.

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 3:36 PM

    @marick how about all of the above?

    Deferred action (notably cleanups and refactoring) with the short-term benefit of moving quickly, leading to long-term costs. Sometimes there's also no measurable difference between deferred action and inaction, e.g. Prototype going straight to production...

    💬 1🔄 0⭐ 1
  • 💬 0🔄 0⭐ 0
  • Mar 1, 2025, 3:42 PM

    Can't remember when someone used it to mean anything other than crappy code. Really grinds my gears

    💬 0🔄 0⭐ 0
  • 💬 1🔄 0⭐ 1
  • Mar 1, 2025, 11:35 PM

    @mark Yes. There's the general principle that engineering is about tradeoffs, and "now vs. later" is frequently one of them.

    What I'm zeroing in on now is how a metaphor tagged "technical debt" once helped the money guys to cede the tradeoff to the engineers¹, but now doesn 't help anyone do anything.

    metaphor.wiki.oddly-influenced

    💬 1🔄 0⭐ 1
  • Mar 2, 2025, 7:33 AM

    @marick oh sure. It's just a synonym for shitty code. And we can make shitty code to get it out of the door fast, to try it something, or we can just encounter it in an existing codebase.

    Tbh I'm not sure we lost all that much, in business taking out a loan is typically a good thing and paying it back is often avoided (just take it a new loan).

    💬 2🔄 0⭐ 1
  • Mar 2, 2025, 7:34 AM

    @marick And in my experience a lot of time when you have shitty code it's because either the world or our understanding of the world changed, and I'd rather have a term for that as I find that much harder to explain, even to fellow engineers

    💬 1🔄 0⭐ 1
  • Mar 3, 2025, 12:54 AM

    @mark I agree. Ward Cunningham (he tells me) had strong opinions about the need to revise the code to represent current understanding. But the "technical debt" metaphor wasn't really a part of that when it came to talking to people on the team or in the business.

    Understanding seems to have come from watching it done rather than giving things catchy names.

    💬 0🔄 0⭐ 1
  • Mar 3, 2025, 12:50 AM

    @mark Yeah, my whole built-up belief about the origin and original use of the metaphor turns out to be bogus. I had a beautiful theory, but it's unsupported by the memory of the person who actually coined the metaphor originally.

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 4:21 PM

    @marick this whole thing turned out bad again even though it started out so nice and clean! we better rewrite it in rust!

    💬 2🔄 0⭐ 1
  • Mar 1, 2025, 4:23 PM

    @marick what I hear is "we painted perfectly but here we are stuck in a corner again, can you believe it? we need better paint!"

    💬 0🔄 0⭐ 0
  • Mar 1, 2025, 11:38 PM

    @einarwh That's a reaction it might take a different metaphor to counteract. Something about replacing the engines mid-flight, maybe.

    💬 0🔄 0⭐ 0
  • Mar 1, 2025, 4:33 PM

    @marick These days, it mostly seems to have been coopted by non-developer IT people to mean stuff like “we have an old shitty ERP system that has been overdue for replacement for at least a decade”

    💬 0🔄 0⭐ 1
  • Mar 1, 2025, 4:36 PM

    @marick "crappy code" is much too generic. I'm sure it's "crappy", but I would speculate that it's crappy in the sense that it can no longer easily absorb ad-hoc patches because it has lost its degrees of freedom. It has been sprawled up in the effort to iteratively fit the terrain better (handle more "edge cases") and respond to changes. Most design is design by epicycle which is prone to grind to a halt after a while.

    💬 1🔄 0⭐ 1
  • Mar 1, 2025, 11:42 PM

    @einarwh I'm struck by how you used different metaphors to express your point: "degrees of freedom," "fit the terrain" (probably using as a metaphor mathematical metaphors that in turn appeal to our understanding of hills), "epicycles."

    Starting to wonder if part of the purpose of metaphors is to get people to stop nagging you about your specialty and just trust you know what you're doing.

    💬 1🔄 0⭐ 0