Not necessarily because it's better. But because the incentive to enshittify it is lacking.
Closed / proprietary ecosystems tend to be nice for a while. And then disappear without warning. Or turn into crap, like a big sinking ship taking all its users down with it.
FOSS / open platforms tend to fork and/or evolve. And (if they survive) improve over time. That I can deal with.
A good example of the forking / gradual evolution I can live with.
Let's not pretend this word has decades of deep cultural and etymological history behind it. It's not a technical term or a term of art, it's a meme. It's something Cory Doctorow came up with in a blog post last year that only a few tech people care about. It's a hipster nerd poop joke.
And because it fits cleanly into a description of anything hipster nerds consider to be "turning into shit," it inevitably will, until people get tired of the meme and move on.
I do think it's odd to link to a definition of a word as the author does, and then use it differently without explanation (potentially depriving the reader of some interesting insight into the phenomena under discussion, if the reasons are good).
Secondly, doesn't 'misuse'really just mean 'used differently from how most people use it'? In which case, I think the descriptor probably applies, given the word's recent coinage and limited usage
Emshitifaction?
It nicely captures a lot of the usually "fuzzier" things of technical debt, like how code even with no changes and no changing requirement somehow accrues technical debt (you get better, your idealized effort reduces).
That'd also play into the whole metaphor of technical debt.
I will second this. I can't count how many projects were started with a clean design and clean early releases (what worked well), to be later messed up with business changes because the original (business) idea didn't work. And those sudden changes are expected to be implemented usually "yesterday", which adds additional momentum to the project's downward spiral.
If the point of a project was to run a business, I would argue the project was messed up from the start if it could not adapt to the changes. Very little software survives contact with the real world.
Scrappy prototype code is written with developer velocity as the most important property. I’ll throw everything in one file. Stick to tools I know well. Copy from other projects. Use crap variable names and generally make a bit of a mess. Something made fast can be remade fast if it’s wrong.
Code you expect to last a long time should have tests, CI and documentation. If I’m serious, I’ll often rewrite the code several times before deciding on a final design.
A good engineer should be able to switch between styles based on the needs of the project. And a good company will make those needs explicit to the engineering team and they’ll be transparent and trustworthy when expectations change. (Eg if a prototype is going to stay in production long term, they need to tell the engineering team).
It’s fine for businesses to pivot. And it’s fine for engineers to make quick prototypes to test a business idea. But everyone needs to be on the same page the whole way along.
The other two important criteria implied by this new term are that it is deliberate and that it is taken for the benefit of the “author” (company) at the expense of the user.
Bugs are inadvertent and have no intent so don’t match either criterion.
Google’s so-called “integrity” system is DRM for the benefit of advertisers (and thus Google), not users. Intel’s on-chip security manager isn’t for the user’s benefit and adds security risks.
Encrusting photoshop or Word with a million features or back-compatibility with a mistake made decades ago may make the program worse, but are in service of giving customers what they want. It may make the application worse in some ways but the motivation is pro-customer, regardless of the ultimate result. (Note: I chose these two programs bc I don’t even like either)
> Bugs are inadvertent and have no intent so don’t match either criterion.
Yes, good distinctions. Very different from inadvertent bugs or routine technical debt.
So, it’s not as general a term as you are implying and definitely the usage in this article doesn’t make sense.
> It’s not as general a term as you are implying
My point is that even if the term isn't "supposed" to be general it definitely sounds like that to a non-trivial number of people, which is why these sort of discussions crop up almost every time the term gets mentioned in comment threads on this site.
And you said "I'll ensure it gets done by Friday."
Would you expect to be fired for failing to take initiative?
As an aside, it's interesting that the phenomenon of expectations around the meaning of terms goes beyond obvious relationships to existing known words but even to the way a word sounds: https://en.wikipedia.org/wiki/Bouba/kiki_effect
Is someone keeping a list of features that qualify for the label? For example browsers like Safari make it very difficult to export bookmarks to another browser like Firefox, even though a simple json file would suffice.
Codebases can enshitified, this is a deliberate action. Having a zombie corpse codebase where bugs grow faster than features is not necessarily enshitification.
An enshitified codebase is created when a product person or a TL spends an undo amount of technical debt on new features or even better anti-features.
> Large codebases will eventually reach an “enshittification point” — the point at which bugs are introduced faster than they can reasonably be fixed.
I think of enshitification primarily as an organisational/business phenomenon rather than a technical one.
It doesn’t necessarily emerge “bottom up” as the result of technical debt but from top down as a result of misalignment of values between the brutally commercial goals of the business and the values/goals if its customers. Tech debt and development velocity do play into this but I don’t think it’s the primary driver of it.
The term is a useful one at that level of abstraction imho because we already have quite a lot of language to describe things like this at the lower, more technical level.