5 ms·
I have noticed that business folks roll their eyes when "tech debt" comes up. I sympathize, as it didn't used to be that way. COBOL on a mainframe would remai
by tyingq 7y ago
I have noticed that business folks roll their eyes when "tech debt" comes up. I sympathize, as it didn't used to be that way. COBOL on a mainframe would remain current for decades. Tools and languages are very fragmented these days. I recently tried to get a popular node.js app (tech radar) up and running, but npm just kept bombing out on abandoned packages. The project is 2 years old and already "debt ridden".
Funny, because it's all client side/ browser JavaScript. Node isn't really needed, but that's the toolchain. So it's borked for no good reason.
- noelwelsh 7y agoThe interesting kind of technical debt is when you realize you modeled the problem wrong, or the problem has changed and you need to change the model. A simple example is an auth system that assumes a one-to-one correspondence between account and user login. Then you get, for examples, agencies that are conceptually one account but have multiple logins (so each client can only see their own account). Oops, that breaks the model. Changing this requires database migration, code changes, UX changes, and so on. It's a conceptually simple change but has wide implications.
- tyingq 7y agoBusiness folks are more sympathetic to that kind of tech debt. The eye rolling is more around silly plumbing, version upgrades, etc, that add no business value. The React ecosystem is a good example to me. No two shops use the same stack. And alternatives like Angular are more "batteries included" and stable / "good enough to get the job done". But less popular.
- glic3rinu 7y agoI wouldn’t categorize this as technical debt unless you’ve deriberatly choosen to implement the wrong abstraction first, to get the product out the door earlier, or some other short term benefit. Technical debt is a deliberate action with some upfront knowledge of its consequences.
- tarr11 7y ago“It didn’t used to be this way” because of the internet. Not because the way COBOL programs were developed were inherently superior. Once these cobol powered servers were accessible to hacking, “not changing anything” no longer worked. https://www.computerworld.com/article/3181809/cobol-plays-major-role-in-us-government-breaches.amp.html https://www.computerworld.com/article/3181809/cobol-plays-ma...
- tyingq 7y agoI get your point, but it feels like things have swung too far in the opposite direction. Compared to other engineering (chemical, civil, industrial, etc), we do a lot of change for little good reason. There's too many ways to solve the same problem, which kills "best practice".
- BurningFrog 7y agoIn general I don't think tech debt should be communicated to the business people. It's an internal part of engineering work, and doesn't impact users. You can think of this as "encapsulation" if you like. Also what it sounds like to outsiders is "we're taking time off to fix things we didn't bother to do right in the first place". And that's not *100% wrong...
- tyingq 7y agoThey are paying for it, so I'm not clear on how you hide it. They'll figure it out, and you look disingenuous when they do.
- TeMPOraL 7y agoI understand GP as saying that if business people know about technical debt, it means you're giving them too much details. Business people care about features being implemented and bugs being fixed; they don't (shouldn't) care if implementing a feature is 1/3 direct work on the feature, and 2/3 fixing the architecture to make the direct work on this and future features faster - but if you communicate this split to them, they'll start asking if you couldn't cut that 2/3 part out.
- BurningFrog 7y agoThanks for explaining my point better than I would have :)
- kd5bjo 7y agoI mostly agree with this in theory, but there’s a tragedy of the commons problem when working on a development team. A developer who takes the quick-and-dirty route will appear more productive in the short term than one who tries to maintain long-term development velocity. If they’re working on a shared codebase together, the latter developer will end up cleaning up the mess left by the former and getting less recognition from management. In all likelihood, this developer will either leave due to resentment, be laid off for underperformance, or stop doing the maintenance work. In any case, there’s no longer anyone seeing to the long-term development velocity and the team’s productivity will slowly grind to a halt.
- wwn_se 7y agoBack then technology could set more boundaries than today. Most of these old mainframe systems I have worked with, use batch jobs (running at night when the system is offline) today being offline is often not acceptable and the users can't wait until the next job to have their data in the system. But I agree that being conservative with pulling in new technologies and dependencies, new and good is not the same. I think the biggest thing with tech dept is communication. We can do this in 1 sprint but then it will cost more in the future. If business always choose the quick matter how you put it and explain when it causes problems, yeah... :(
- mwfunk 7y agoThis makes me think part of the problem with tech debt is that it means different things to different people. Some people might describe it as a codebase just not keeping up with this month's latest and greatest JS frameworks, but I think of it as something much more nefarious- low level shittiness and incoherency that tends to seep into long-lived large projects over time. Eventually the lack of refactoring to account for new features or behaviors turns it into a giant blob of spaghetti, where everything knows about everything and what should be minor, localized changes can have unforeseen consequences. This is harder to deal with IMO because it's something that appears so slowly that it's hard to stop in isolated instances ("WTF, you wanna rewrite this whole class instead of just commenting out that one line and adding one more tiny code path to fix this bug right now?!?"). That type of technical debt is more of a boiling frog problem where it's not obvious to everyone how bad it is until serious consequences have started to arise.
- tyingq 7y agoWell said, and often an artifact of "agile" where shortcuts are rewarded.
- defined 7y agoGreat point!
- rdiddly 7y agoMaybe instead of "paying off tech debt" we should sell it as "frog-cooling." I'm only half joking. They'll respond to that by saying "WTF?" and you can be like "Yeah the frog's been in the pot not realizing it's heating up, and is about to boil." Gives it some urgency.
- bcrosby95 7y agoJava is pretty good at this. Before jigsaw we had projects that we hadn't touched for 13 years and they still compiled on the newest versions. There's positives and negatives to this of course.
- alacombe 7y ago> COBOL on a mainframe would remain current for decades Only if the underlying problem solved by the program doesn't change for decades, and even if this case, the piece of software in question is a constrain to the industry using it. I'm sure a dentist would loves to have some fancy REST 4.0 BUZZ-WORD-OF-THE-DAY client management system. I am using some industry "standard" industrial CNC software and it not only constrains me to 15 years old hardware but also restrict me to use programming quirk specific to this software which very much qualify as being "tech debt". In this case, the business is built around the software.
- closeparen 7y agoThere's really a few distinct concepts here, and I think it's important to be precise. - Keeping up with platform churn. How much of this you will do is really a CTO level choice, in terms of a) permitting internal platform teams to break backwards compatibility, and b) permitting adoption of trendy technology from outside. - Knowingly trading off quality for speed to meet a deadline. This is tech debt in the strictest sense and you can quantify it as you accumulate it. Tech debt comes from a business / product management choice to force a project to release before it meets standards. - Seeing better abstractions and decompositions, new test cases, observability hooks, etc. with the benefit of hindsight and experience. Examples: we found four bugs in this module this quarter and it's really complex, I see a simpler and less error-prone way to rewrite it. There's a lot of interest in adding new features with a certain shape and each time you have to touch code in three different places, let me consolidate those so you only have to touch one. People keep asking a particular question that requires painstaking correlation of different logs, let's add a new logging topic that answers it directly. Stuff like this. These are never strictly necessary and business impact is hard to quantify, but if you do this stuff never, you're going to have a lot of cruft in a few years.
- Aeolun 7y agoI’ve recently been reading ‘A deepness in the sky’ and it has the concept of ‘Programmer-Archeologists’ exactly for this reason. It’s set many thousands of years in the future and I have trouble imagining how many old versions of packages and libraries would exist at that point.
- WrtCdEvrydy 7y agoTrust me, in 20-30 years, after the apocalypse, someone needs to turn on a water filter and npm can't download the correct package... and they die of dehydration... just write the Black Mirror episode around it!
- Vinnl 7y agoI've got Javascript projects of a couple of years old. There are certainly things I'd do differently now if I were to set them up today, but I wouldn't consider that technical debt: those things are not giving me practical problems in the foreseeable future. The only of such projects that I'm still running which does have significant technical debt, from my point of view, is the one I set up without a CI system and without a package manager with a lock file (those didn't exist back then) - I cannot update that code today, because I cannot build it. Rewriting that one with a reproducible build set up is something I consider tech debt and which is still on my TODO list of intending to solve one day.