Comment by MrThoughtful | Hacker News Reader

Comment by MrThoughtful | Hacker News Reader

Parent Full thread

    the average developer spends 42% of their
    work week on maintenance

Indeed, I see that happening all around me when I watch how my friends build their startups. The first few months they are productive, and then they sink deeper and deeper into the quicksand of catching up with changes in their stack.

So far, I have done a somewhat good job of avoiding that. And I have a keen eye on avoiding it for the future.

I think a good stack to use is:

    OS: Debian
    DB: SQLite
    Webserver: Apache
    Backend Language: Python
    Backend Library: Django
    Frontend: HTML + CSS + Javascript
    Frontend library: Handlebars

And no other dependencies.

I called Django a "library" instead of a framework, because I do not create projects via "django-admin startproject myproject" but rather just do "import django" in the files that make use of Django functionality.

In the frontend, the only thing I use a library for is templating content that is dynamically updated on the client. Handlebars does it in a sane way.

This way, I expect that my stack is stable enough for me to keep all projects functional for decades to come. With less than a week of maintenance per year.

> the average developer spends 42% of their work week on maintenance

Apart from the big question of where that number is from - How is that even a "bad" thing?

I've been on projects where about 100% of the work was maintenance. The app was done. It provided value. Things broke, bugs were uncovered, but the cost of maintaining the app was far eclipsed by the cost of maintaining it.

It's one of the things I hate about software development - every other industry accepts that things require maintenance and that spending on maintenance is a hard requirement to keep the thing you invested tons of money in running. Only software development seems to believe that anything, anywhere reaches a magic state of "done" and will never need to be touched again. And that the only thing that adds value is adding new features.

>Only software development seems to believe that anything, anywhere reaches a magic state of "done" and will never need to be touched again.

The problem is the mental model. There is a state of "done" for a lot of software. But it subsequently becomes "undone" due to outside factors.

There's no bearings, gaskets and lubricants that need maintenance. The software stays the same. So why would the software need maintenance.

Maintenance in software is because software runs on hardware. Hardware gets updates, and then the software needs updates to match.

Maintenance in software is because software runs on a changing OS.

Maintenance in software is because software interacts with other software that changes.

I think it's this lack of mental model of _why_ software needs maintenance, that it's not planned for.

I wonder how much of "tech debt" would be easier to explain to certain business processes if better reframed under a "bearings, gaskets, and lubricants" model? We don't always have the engineering tools to predict strong "wear and tear" models of such things in software like civil and mechanical engineers have for common bearings/gaskets/lubricants, but on the other side we are also maybe closer than ever to having some baselines: most modern OSes now experience major changes once every 6 months, often with alternating (1 year) "LTS" releases; most modern tools and frameworks follow similar 6 month patterns. The big unfortunate bit is that most of those timelines don't align, but in general "needs to be 're-oiled' once ever 6 months" is starting to be the regular view of things.

(The other thing that this framing calls to mind is that a company doesn't usually send a civil or mechanical engineer to do the general maintenance checks, they first send a cheaper mechanic or other equivalent laborer. This is both where the analogy partly falls apart because not all software maintenance tasks in these 6 month timeframes are "easy"/"trivial" and sometimes need massive software engineering work, and also where we again maybe see hints that in some ways the software industry still maybe needs more of a better defined engineer/mechanic split than it has today.)

>We don't always have the engineering tools to predict strong "wear and tear" models of such things in software like civil and mechanical engineers have for common bearings/gaskets/lubricants

Because it's not wear. Wear can be measured. Wear is predictable. This again comes back to the mental model.

>most modern OSes now experience major changes once every 6 months, often with alternating (1 year) "LTS" releases

For the OS, this is a fair point. Maybe it should be mandatory to plan for OS updates, which often cause a host of issues.

>some ways the software industry still maybe needs more of a better defined engineer/mechanic split than it has today

I think the reason we don't have a proper split here, is because a split here isn't really possible. Maintenance work _is_ engineering work, you need good judgment to decide whether a dependency update is ok.

A proper test suite can help make the maintenance easier. But there's no mechanic equivalent, since there's not necessarily modular parts to be replaced when interfaces change.

I think all in all we need to move away from engineering analogies. SW engineering is different enough that these analogies do more harm than good. And in the end we should have the self-confidence to ask our managers to understand software as its own discipline.

If a manager doesn't understand what they're managing without heavy-handed analogies, they are in the wrong position.

I probably spend well over 50% of my time testing for (and finding) issues. In my experience, finding issues is 99% of the time involved in fixing them. Once I find the cause of a problem, the fix is almost immediate.

> Thank the dependency hell we’ve put ourselves in.

This was something that we knew was coming, ten years ago. Modular programming is an old, well-established discipline, but that generally means modules of code that we write, or that we control. I write most of my stuff, using a modular architecture, and I write almost every single one of my reusable modules.

Things are very, very different, when we import stuff from outside our sphere. Heck, even system modules can be a problem. Remember "DLL Hell"?

When I first started seeing people excitedly talking about great frameworks and libraries they use, on development boards, I was, like "I don't think this will end well."

I just hope that we don't throw out the modular programming baby with the dependency hell bathwater.

Great stack, I use a very similar stack and for the same reasons. I imagine you’re also in your late 30’s.

Honestly the best UI I’ve seen is the terminal-based one at libraries in the 80’s and 90’s that allowed you to find books. Lightning fast and allowed the user to become an expert quickly, especially because the UI essentially never changed.

If you design things with Occam’s razor in mind, a full page reload doesn’t feel like one.

Nowadays I build software to last as long as possible without future investment of time and effort spent on maintenance. Meanwhile the industry seems to have developed some need to mess with their programs all the time. It’s almost like a tic.

> I think a good stack to use is:

These things are relative though, also futureproofing your stack will run into issues later if you need to scale to N number of requests etc.

When you are thinking forward for optimizations, you may re-evaluate your thoughts on the right stack.

> When you are thinking forward for optimizations, you may re-evaluate your thoughts on the right stack.

Most projects never get there and even the ones that survive would be well served by a single EC2 instance.

Nothing about that stack jumps out as that problematic, maybe go with a PostgreSQL instance running in a container if need be, but the rest can scale pretty well both horizontally and vertically.

If it becomes a problem then just throw some more money at resources to fix it and if at some point the sums get so substantial that it feels bad to do that, congratulations, you’ve made it far enough to rework your architecture.

And in the mean time, enjoy life for 20 years.

I am perfectly glad for all the things I did not do when they were not needed.

Designing and building amphibian hovercraft monorail dumptruck racecars for all those projects that only ever needed a wheelbarrow is just a diffetent form of technical debt. It's not investment because it never pays off. It's just work that does not produce output, that you pay before instead of after.

It only takes a little bit of thought to avoid the normal idea of technical debt where past thoughtlessness costs you work today. Plain old modularity, seperation of concerns, avoiding tight coupling, and not even those religiously but just as a prefference or guiding direction, pretty much takes care of the future.

Reply on news.ycombinator.com