3 ms·
I believe most experienced software types would agree that maintaining systems over time is a rather different skillset to building them in the first place. 'Fi
by contingencies 10y ago
I believe most experienced software types would agree that maintaining systems over time is a rather different skillset to building them in the first place. 'Fire and forget' is a great short-term commercial strategy, but usually a terrible operational one.
Certain (usually early) stages of a project may be time or resource rich or permit wide-ranging changes with minimal risk (client impact, downtime, live failover requirements, carefully engineered change-overs, etc.). At these times, an experienced person might opt to utilize resources to 'over-engineer' for contemporary requirements in the knowledge that it is a strong and well-reasoned long term play, while to the less experienced, non-technical project managers or stakeholders this may seem questionable.
Ultimately, every project is different but there is a 'sliding window' of project resources (particularly time and the availability of low-risk incremental change) and requirements (expanding, shifting, contracting).
A famous quote from a famous figure on migration: Those change-over things are really severe. Really severe problems. - Joseph Henry Condon, Bell Labs.[0]
Perhaps ultimately, over-engineering may be inefficient but efficient if considered in light of the alternatives: by parable, eventually including a rewrite in javascript that also reads email.
[0] https://github.com/globalcitizen/taoup https://github.com/globalcitizen/taoup
- Taek 10y agoIt requires you to think in many different ways. The first time you need to add a field or change a behavior and you realize that you're going to break everything running or built around the old version, your attitude towards building changes. Soon you spend more time figuring out how to make small changes that don't break anything than you do writing new features. Suddenly versioned protocols are your friend. Suddenly you find yourself wondering how awful it really would be to have a SaveFile and a SaveFileACID. And then later you might realize that what you really wanted was SaveFileDurable (way faster), but now you're starting to feel like PHP. And then some dependency goes and breaks half your libraries, and you become dependency averse. You vet your dependencies by the reputations of their maintainers instead of by the performance of their code. You intentionally start using slower, more awkward APIs that give you headaches today (why can't they just fix that off-by-one that they've documented so carefully?) because you know in 2 years it'll still work exactly the same. And that's more important than clean code or a 300% performance boost. Definitely a different skill set to write maintainable systems.
- ChemicalWarfare 10y agoSpeaking of the long term. The thing is the flavor of over-engineering JavaScript suffers from - bringing in frameworks/tech the project can be done without is bound to backfire at some point when (and in a ridiculously fast moving ecosystem like js we're talking 1-2 years) you can't find engineers with the skillet needed for the the "old tech"-based projects.