OK but I'm genuinely terrified by how common this is at my company, and its notably better at retention then the industry norm.
Screw Dead Internet Theory, this is my conspiracy: Crowdstrike style incidents are going to get more and more common as techdebt keeps growing.
I think you're on to something. Given how software is generally built to the lowest standard possible, there are more and more exploits piling on as a result. The details of any modern tech stack is far beyond human comprehension. It's just not possible to meaningfully audit all the code and all the different interactions within it. The whole thing is just a giant house of cards.
A few jobs ago, everyone hated the tech stack. The people who had come up with it had long left. I talked to everyone, then came up with a plan to transition to a modern stack. Got buy-in from management.
Half the people (and all who had said they hated the status quo) threatened to quit if we made the change.
Fortunately, it was just in time to collect the 1-year retention bonus. Life's too short. Walked away.
People are very resistant to change that reduces their expertise so that doesn't really surprise me.
I'm on a project where we original had three devs, but two of them did exactly what is depicted in this image, so now there's only me. There's a proper god damn mountain of tech debt that keeps growing. At this point it'd take me probably a solid couple of months to sort it out, but of course the customer doesn't want to pay for anything, because "what's the problem, it's still running". All I can really do is glance at it every now and then, like that gif with richard ayoade and the fire from IT crowd. It's a pretty big and widely used system too, so it's gonna be a real biblical clusterfuck when it finally shits the bed.
This is the curse of working in tech. As long as things are working smoothly from customer perspective then the pleas to spend the time to deal with the tech debt are ignored. Yet, when enough debt piles up and things start breaking then it's the people who've been warning about the problems the whole time who get blamed.
When a project is developed for a while, a lot of initial design decisions can become invalidated as business needs evolve. New features have to be added, and in many cases they go against original assumptions about how the project would be used. At that point you have to start making hacks and kludging new features in. This creates a lot of special cases and surprising behaviors making overall project brittle and hard to maintain. That's what's known as tech debt.
In an ideal world you would have time to do proper redesign to accommodate new features, clean up problems as you go, and so on. However, in reality there's usually just not enough time to do any of that so people just pile on features at the cost of overall development becoming harder and more error prone. This is a great discussion on the subject incidentally https://medium.com/@wm/the-generation-ship-model-of-software-development-5ef89a74854b
It also covers shortcuts you take to go faster while acknowledging it's not the correct way and you'll have to pay that debt later on. Like if you took a loan
"pay that debt later on", nothings more permanent than temporary. In my experience things are more likely to default than get paid lol
Nah, our tech stack is a loan shark who'll come collect technical debt in a month's time
I've actively been told off at work on multiple occasions for putting too much effort into making my code reusable and extendable later down the line
(As of recently I've had to rewrite an entire project from last year because I gave up and just wrote a big blob of difficult to maintain code, then unsurprisingly the requirements changed)
