3 ms·
Unfortunately, if this becomes popular, I suspect it'll merely turn into another useless dogma like SOLID and OOP and whatever other buzzwordy acronym-paradigms
by userbinator 3y ago
Unfortunately, if this becomes popular, I suspect it'll merely turn into another useless dogma like SOLID and OOP and whatever other buzzwordy acronym-paradigms came before. I can make my own acronym with the same letters too: Simple Teachable Universal Powerful Intuitive Direct. Write some fluffy marketing-esque material with vague references about how each of those terms is a good thing, and with luck, you'll amass worshippers and develop consulting services and other sellable material about how much better you can make software by following these simple rules.
Does all this "snake-oil" actually work? My decades of personal experience says otherwise. You can't teach surface-level rote memorisation crap like this and expect it to make things better. I agree that simplicity is good and accidental complexity is to be avoided, but it's not something that can be distilled into trite talking points to be taught.
"There's no replacement for intelligence."
- jdougan 3y agoThe problem isn't intelligence, the problem is judgement. Many a smart person has built ridiculous and rickety towers of code, only understandable because they are smart. Good judgement mostly seems to come from bad judgement, failure, then picking the pieces up again while evaluating the causes. It also seems to require some emotional maturity and humility. You are correct that the various dogmas are not useful until the mental attitude is right. After then they are superfluous.
- deleted 3y ago[deleted]
- avidphantasm 3y agoI like to think I tend to write code that others like because I am usually not the smartest person in the room. I strive to make my code simpler because I can’t understand less simple code. If I find an approach to solving a problem that feels too complicated to me, I usually keep looking until I find something simpler.
- withinboredom 3y agoI would argue that this is not related to intelligence, but wisdom. Wisdom is something you earn through experience and can't be taught.
- fsloth 3y agoYes. Un-wise super intelligent programmers are the worst. They come up with the most amazing roundabout way to achieve even the most mundane tasks, and consider complex code a mark of honour, rather than a pathology to be purged. At some point people mature and realize that their job when writing code for work is not to concoct brilliant puzzles for next maintainer, but to do exactly the opposite. And then they reach the meta-level of realizing that simplifying things is actually just as hard and pleasing as puzzle-making, and they've reached a maturity in the quality their program design. The worst kinds of programmers are those that plateau at the "Riddler" stage. They potentially are able carve themselves a nice safe niche, but the value they could have delivered could have been so much more if they'd ever matured. "Oh, that code... yeah, better call Edward ... it's his baby, supercomplex. Nobody seems to be smart enough to work in it except Mr. Nygma". There are pieces of code that are potentially super-complex due to the intrinsic complexity of the problem space. But since for an outsider it's impossible to distinguish between the two, utmost empathy should be always used to introduce new people to such a thing.
- scns 3y agoWisdom can be written down and read. Those who seek may find it. Philosophy means The Love Of Wisdom.
- withinboredom 3y agoSomeone seeking wisdom is different than someone stumbling across wisdom before they are ready.
- blarg1 3y agoI remember after learning OOP I found myself unable to write any code without violating some principle. It's like trying to solve a puzzle that doesn't have a solution.
- BerislavLopac 3y agoIt reminds me of https://xkcd.com/601/ https://xkcd.com/601/
- blarg1 3y agoTook me much too long to realise that :(
- spinningslate 3y ago> simplicity is good and accidental complexity is to be avoided, but it's not something that can be distilled into trite talking points to be taught. No, "simplicity is good and accidental complexity is to be avoided" is that distillation. The difficulty is less the "what" than the "how". Compressing experience, expertise, wisdom, taste, humility, judgement and courage into an acronym is always going to fall short. Another useless dogma as you say.
- highwaylights 3y agoI don’t know that every acronym is necessarily bad. DRY, KISS, SOLID etc. Yeah they’re buzzwords, but they serve a pretty useful function of constantly reinforcing objectively good behaviours that should be inherently obvious but often are not. That said, my argument falls apart with DevOps which is simply moving automation to more stages of your delivery (which is good) because it’s been utterly co-opted by snake oil salesmen and uppity gatekeepers. Seriously, the amount of exceedingly difficult but otherwise passable workers I’ve had to straighten out because they’ve mistaken having access control rights to work with the production environment with being in charge of the whole development process is utterly wild. (I’ve checked too, no-one has told them or lead them to believe this so I’m sure it’s A DevOps thing). And, you know, Agile. But it’s not an acronym so I’ll leave that rant out.
- Uehreka 3y agoI have seen so many codebases turn into indirected, overabstracted brambles as a result of DRY. I’ve seen it so many times that I would not call DRY objectively good.
- klabb3 3y ago> Unfortunately, if this becomes popular, I suspect it'll merely turn into another useless dogma like SOLID and OOP and whatever other buzzwordy acronym-paradigms came before. Yes, but that said, if there’s gonna be a dogma I think this one is pretty good. To me, software engineering is the art of curbing complexity. I can see a couple of missteps: - simplicity can be confused with the appearance of simplicity. Yaml is a great example of this phenomenon. - simplicity is subjective, and should ideally be measured by outsiders. However, as we all know decisions and moat belong mostly to insiders, senior engineers that often want to flex and build moat. There’s a risk of curse of knowledge because you can just say “this is simple to me (and if you don’t get it you’re stupid)” - when more people can understand something, you can get more chefs in the kitchen. This is not a problem with simplicity but can be a problem of governance. - engineers can move visible complexity around to areas of less scrutiny. For instance, if there’s a “rule” that a module should be simple, you can break it into two and say they are each simple (even if they’re coupled and it’s only a cosmetic modularization) - complexity from dependencies, concurrency, memory usage etc can fly under the radar, especially for less experienced/gung ho engineers. To be clear, I still like this new trend, these are just some immediate issues that come to mind.
- sidlls 3y agoParts of it already are dogma. The “testable” and “decoupled” sections come to mind: collectively we’ve taken these to extremes. I have seen so many pointless (and more importantly at large scale, inefficient) abstractions to satisfy arbitrary testability and decoupling requirements where I work. I work at a place that isn’t quite FAANG, but it’s operating at huge scale nonetheless. I’m tired of seeing one-interface-one-impl everywhere, sad attempts at mocking dependencies, and so on.