12 ms·

Against Best Practices

• vbezhenar 2y ago
  How other engineering industries deal with this phenomena? Why those approach do not work with programming? I feel silly sometimes because software development is huge industry and we don't have consensus on basics. For example I think that strict formatting is a good thing. Since I tried to use Prettier I'm using it and similar tools everywhere and I like it. I can't do vertical alignment anymore, it eats empty lines sometimes, but that's a good compromise. May be there should be a good compromise when it comes to "best practices"? Like "DRY" is not always best, but it's always good enough, so extract common stuff every time, even if you feel it's not worth it. I often deal with this dilemma when writing Java with default Idea inspections. They highlight duplicated code and now I need to either disable this inspection in some way or extract the chunk of code that I don't really think should be extracted, but I just can do it and move on...
  • deleted 2y ago
    [deleted]
  • reverius42 2y ago
    I think we're still in the "phlogiston" era of software development.
    • ben_w 2y ago
      That good? I think we're more like Pythagoras: some useful theory about numbers, taken way too far and became an actual religion[0] listening to the Delphic[1] Oracle[2]. [0] Tabs or spaces? Vi or emacs? Is the singularity the rapture of the nerds, with Roko's Basalisk as the devil and ${insert name here according to personal taste} as the antichrist? SOLID or move fast and break things? vs. really a real religion: https://en.wikipedia.org/wiki/Pythagoreanism https://en.wikipedia.org/wiki/Pythagoreanism [1] Not https://en.wikipedia.org/wiki/Delphi_(software) https://en.wikipedia.org/wiki/Delphi_(software) but rather https://en.wikipedia.org/wiki/Delphi https://en.wikipedia.org/wiki/Delphi [2] Not https://en.wikipedia.org/wiki/Oracle_Corporation https://en.wikipedia.org/wiki/Oracle_Corporation but rather https://en.wikipedia.org/wiki/Oracle https://en.wikipedia.org/wiki/Oracle
  • grey-area 2y ago
    Other engineering disciplines have certification, codes and regulations for specific domains, which are enforced by law. DRY is a perfect example though of something which in moderation is a good idea but as the article says is vulnerable to ‘inexperienced programmers who lack the ability to judge the applicability’ and if over-eagerly applied leads to over-abstraction and premature abstraction which does more harm than good.
    • mrkeen 2y ago
      >> inexperienced programmers who lack the ability to judge the applicability In other words, the author knows better than you. The author could have put forward precedent, principles, or examples. But instead he chose to make it about the people (inexperienced), not his arguments.
      • yCombLinks 2y ago
        The point is there are not rules that are always applicable. Dry is right sometimes, and sometimes it's not.
    • HelloNurse 2y ago
      Before regulations, other engineering disciplines have far more objective decisions and calculations than software engineering. Consider a mechanical analogue of DRY: choosing between reusing identical parts to make design, assembly and repairs simpler or designing similar but different parts because they are worth optimizing (e.g. a whole IKEA cabinet with interchangeable screws or with short and long ones). Unlike next month's shifting software requirements the cost and performance of this kind of alternative can be predicted easily and accurately, without involving gut feelings or authority.
      • grey-area 2y ago
        Well I think the point is you can’t legislate on things like style, or at least it is pointless to do so and other disciplines don’t try to. DRY is a style guideline. What you can legislate/codify are procedures, safety and outcomes. So for example building designs must be signed off by a structural engineer and architect, both of whom are liable if the buildings collapses and kills someone. There are standards materials must meet and for which materials can be used. Buildings must meet standards for fire protection, air flow, heat loss etc. I’m not sure software is at the stage where we even know what to codify or what is good and what is not good.
  • f1shy 2y ago
    Some reasons I would say: - I think SW needs much more creativity than other industries. - Typically SW is not mission critical (in mission critical things, it IS pretty much regulated to uncomfortable extremes) You could regulate it to death, and would probably have some positive impact by some metric, but you would be easily overtaken by FOSS, where for sure there will be less restrictions.
  • cowl 2y ago
    other engineering industries use standards that are good for stability but bad for efficiency and innovation.
  • heavypixels 2y ago
    Those approaches do work with programming, but they don't make use of what makes programming different from other disciplines. Software is usually quick to write, update and deploy. And errors usually have pretty low impact. Sure, your website may be down for a day and people will get grumpy, but you can hack together a quick fix and have it online with the push of a button. Compare that to, say, electrical engineering, where there's often a long time between finishing a design and getting a manufactured prototype (let alone mass production.) And a fault could mean damage to equipment (or people) and the cost of having to replace everything. So you'll find that there's a lot more work done up-front and the general way of working tends to be more cautious. There's also the idea of best practices as a form of communication. This also helps for programmers, as code that looks and acts the way you expect it is easier to follow. But code is primarily shared with other programmers. Other engineering disciplines (more) frequently need to collaborate with people from other domains. For example, a civil engineer's work could be shared with architects, government bureaucrats and construction managers, and best practices often provide a common familiar standard. Compared to other engineering disciplines, software is a big unorganized mess. But it's also incredibly fast and cheap to make because of that.
    • gpderetta 2y ago
      You can destroy rockets, lethally irradiate people, fly planes upside down, or financially ruin a company because of software bugs, so avoid faults can be critical for software as well. It is just that high-velocity low-reliability web and consumer application development is a very large niche. A lot of our best-practices are about attempting to maintain high velocity (often with questionable results), more than increasing reliability.
      • LandR 2y ago
        > It is just that high-velocity low-reliability web and consumer application development is a very large niche And most of them have no care about the user experience of the end user at all. Almost every piece of software I have to interact with on a daily basis is absolute garbage. Just full of frustrating bugs that makes most of my day when I'm forced to use a computer absolutely miserable. But to each of the devs it's just a small annoyance in their particular app. Not caring to the end user it's one annoyance that leads to a death by a thousand cuts. Software is just atrocious nowadays.
  • federiconafria 2y ago
    I think one thing the industry does not do properly is applying different practices and standards depending on context. An retailer website is not the same as a trading platform, the same way that a house is not the same as a railway station. But we blindly try to apply the same "good practices" everywhere. We also have another interesting phenomenon, our products can mutate in their lifetime, and our practices should follow (they often don't) an MVP can become a critical system, a small internal project can become a client-facing application, we can re-platform, re-write, etc. That's very rare in other industries.
  • cjblomqvist 2y ago
    A nit; DRY is probably not what you think it is. DRY is basically the same as SRP, framed differently. In SRP, it's totally valid to have the code twice if it has different meaning from a user pov.
    • begueradj 2y ago
      Quoted: "You can still not repeat yourself but violate single responsibility" (https://softwareengineering.stackexchange.com/questions/220769/how-is-dry-principle-applied-at-class-level-related-to-srp https://softwareengineering.stackexchange.com/questions/2207...)
      • safetytrick 2y ago
        Quoted: "Likewise, you can repeat yourself but classes only have a single (duplicated, but subtly different) responsibility."
    • vbezhenar 2y ago
      The problem with definition is that it's subjective and cannot be checked automatically. So my definition was about mechanistic DRY, which is objective and checked by linter.
    • deathanatos 2y ago
      I think it's the same thing, but I usually postulate DRY as semantically identical code, not merely syntactically identical. "Byte for byte equivalent" doesn't necessarily mean it's a copy, if the semantics of it are different.
  • taeric 2y ago
    What makes you so sure they do? Go to the hardware store and behold how many fasteners there are. Go down the rabbet hole of pipe fittings. Consider the optimal size of lumber, someday. And then get ready for the horrors of electrical connections. Not necessarily in how many there are; the real horror is how many think there is a "one true answer" there. You can find some solace in learning of focusing effects. But, focus isn't just getting harder for individuals. :(
    • whstl 2y ago
      That's a great point. In the end, other engineering areas also have lots of "it depends" situations, where often there are multiple correct answers, depending on availability, legislation, safety, physical constraints, etc. Perhaps in software engineering people are just too quick or immature to judge. > rabbet hole Nice pun ;)
      • taeric 2y ago
        I'd love to claim the pun was intended! :)
  • randomdata 2y ago
    > How other engineering industries deal with this phenomena? They don't. CAD, the "programming languages" of most other engineering disciplines, is as much of a Wild West.
    • bigger_cheese 2y ago
      I'd say Yes and No, there are standardized ways to analyze common engineering problems, for example beam deflection equations https://en.wikipedia.org/wiki/Deflection_(engineering) https://en.wikipedia.org/wiki/Deflection_(engineering) or Heat Exchanger efficiency calculations (https://en.wikipedia.org/wiki/Logarithmic_mean_temperature_difference https://en.wikipedia.org/wiki/Logarithmic_mean_temperature_d...) etc. Often the models and equations rely on making assumptions in order to simplify the problem (cue the joke about physicist and the spherical cow). This is one of the reasons thing are designed with tolerances and safety factors. Software like CAD and particularly Computational Fluid Dynamics (CFD) packages can simulate the problem but at least with CFD you would typically perform other types of verification such as wind tunnel tests etc.
      • randomdata 2y ago
        I'm not sure that's analogous to "best practices" like "do not repeat yourself (DRY)" or "don't use GOTO". These are little more than stylistic choices that claim to offer more maintainable code. Comparable "best practices" in other engineering fields would be along the lines of "do not chamfer/fillet until the end of modelling" (one I have heard before). Analyzing a CAD model as you describe is more like running a compiler or type checker on code already written, which is the norm in software too, but is not within in the vein of the topic of discussion.
  • marcosdumay 2y ago
    "Engineering industry" is a misnomer. Other engineering areas have the same issues with best practices we have, industries apply best practices with a great amount of success (but not to totality). Usually, engineering creates best practices for the industries to follow.
  • toast0 2y ago
    > How other engineering industries deal with this phenomena? Why those approach do not work with programming? A lot of engineering discipline is a way to prevent engineered works from causing unintentional injury, physical or fiscal. Most software development is far away from physical injury. And fiscal injury from software failure is rarely assigned to any party. There's no feedback loop to push us to standardized process to cover our asses; we'd all prefer to do things our own way. It's also pretty hard to do convincing studies to determine which methods are better. Few people are convinced by any of the studies; and there's not been a lot of company X dominates the industry because of practice Y kinds of things, like you see with say Toyota's quality practices in the 80s and 90s.
• cjfd 2y ago
  The first paragraph of this is the truth. There is something wrong with people who enjoy telling other people what to do.
  • elpocko 2y ago
    >There is something wrong with people who enjoy telling other people what to do. Telling other people what to do is human's favorite thing. Give a man an opportunity to make and/or enforce rules, and you have a very happy man. People dedicate their whole lives to reaching stage after stage in their rule-making game.
  • deleted 2y ago
    [deleted]
• chris_wot 2y ago
  It occurs to me that the author is explaining his best practice is to look at someone else's best practice with a gimlet eye and take what you want from it. So I wonder how to apply his best practice to his own best practice?
• larsrc 2y ago
  Follow best practices unless you can give a reason not to. "Best practice" is a shorthand for a lot of accumulated knowledge that you don't want to go over again every time. Also following BP makes the code more consistent and thus easier to understand. But when an argument arises, go back to the underpinnings of the best practice and work from there.
  • f1shy 2y ago
    Basically if you know exactly why the best practice/rule is in place, and know for sure it does not apply, just skip it. But not before. https://en.wiktionary.org/wiki/Chesterton%27s_fence https://en.wiktionary.org/wiki/Chesterton%27s_fence
    • muro 2y ago
      That's very reasonable. ‘The reasonable man adapts himself to the world; the unreasonable man persists in trying to adapt the world to himself. Therefore all progress depends on the unreasonable man.’
      • lolinder 2y ago
        > Therefore all progress depends on the unreasonable man. The unfortunate corollary to this is that all retrogression also depends on the unreasonable man. The reasonable person (as defined here) maintains the status quo, for good or ill.
    • throw310822 2y ago
      I would reverse this: if you can explain to me exactly why your so called "best practice" applies here and now, good. Otherwise it's a nice input to have in the discussion, but nothing more.
      • nine_k 2y ago
        It depends on your risk appetite. A best practice likely keeps you away from pitfalls known to the community of the practice but not to you. It also may keep you away from crafting a solution that is optimal for your specific circumstances not known or applicable more widely. In high-reward / low-risk environment, such as building an indie turn-based retro-style game, go with your gut feeling unless you have a good reason not to. In a high-risk / dubious-reward environment, such as implementing cryptography, follow the best practices to a t, unless you know intimately how things work and maybe codified some of the practices. There is a wide gamut between these two extremes.
• TrianguloY 2y ago
  "Don't do X" is bad. "Don't do X because it's not a best practice" is less bad, but still bad. "Don't do X because Y" is good. Only in the last one you can either understand the reason, or ignore the rule because it doesn't apply to your situation.
• trm42 2y ago
  Best practices and such shouldn't be obeyed as "laws" but guidelines for general work. Once in a while there's good reason to avoid / skip them for whatever reason. The bigger issue is that developers (me included) are usually making the decisions in their own heads. Usually the reasons are quite ok but they are not really said out loud or documented. I've been stumbled upon this as both developer trying to get their code approved and when doing a code review. For the developer it feels super annoying that somebody nitpicks about things which the developer has probably gone through in their heads already and ended up with the resulting solution. Just like Martin in the post complains and reacts passive aggressively towards reviewers mentioning these things. For the code reviewer it feels like the developer is being sloppy or doesn't care about our common way of doing things thus increasing the need to nitpick and explain so that the developer understands how it should be done. The solution for this is actually quite easy: document in the comments and in the Pull Request _why_ you're breaking team's / company's guidelines and why you think it's warranted for solution for this case. This seems to remove quite a lot of friction. Oh and of course it doesn't mean that the guidelines should be broken all the time just because one thinks this kind of stuff is for "idiots|assholes". When working as a team, we need to adhere to common way of working for most of the time.
• heisenbit 2y ago
  While I guess most would agree all the cited practices have been abused what is really the alternative? Absence of practices does not make things better - history has plenty lessons there. To run medium to large scale projects one needs patterns to ease communication and integration. The real question is how do we prevent best practices to be perverted and I fear the answer is having the right people in the right places. The one best practice to rule them all: Have knowledgeable balanced people who know when to break the rules.
  • dkarl 2y ago
    The alternative is to accept that every solution has drawbacks and trade-offs. Best practices were an attempt to codify design standards that would be equivalent to "buying IBM" in the sense of the old phrase, "Nobody gets fired for buying IBM." That was always a bad idea. Often the best choice in one context would be a bad choice in other contexts. You don't want an engineer in a 20-person startup making decisions like they're at Google, or vice-versa. You have to take responsibility for deciding what's best for a particular problem in a particular context, without looking for the cover of "everybody does it this way."
• jonathanlydall 2y ago
  Perhaps it's due to the very large number of factors in a code base and/or the particular problem space. But as I got more senior, when asked by less experienced developers the best way to do something, my answers tended to increasingly start with: "Well, it depends...". And that's the thing, there is no universal best practice for everything, there are solutions which are more often than not good enough, but as all solutions tend to be a trade off favouring a particular scenario over another, sometimes they're also highly inappropriate to the particular circumstances. Another term for someone trying to blindly apply supposed best practices is "cargo culting". In summary, there is lot's nuance to software development and the particular circumstances it's being applied to meaning that you need to understand the trade offs of particular solutions to see which one makes the most sense for a particular situation.
• cadamsau 2y ago
  There are 2 main kinds of advice that get labeled best practices in an attempt at persuasion: 1. Advice which worked in one situation - “we tried Agile, everyone should use it!” 2. Proven stuff like code review, which you call best practices when begging your org to implement it: “please let’s do it, I can clearly see how this will improve our org.” These 2 examples represent locations on a spectrum: let’s call it “provenness”. The author’s problem boils down to subjectivity - everyone positions different practices in different places on the provenness axis. The upshot of that is when one person says “we should do this, it’s obvious and/or it’ll definitely help” another person hears “we tried it once, you should try it too!” and then everyone has a bad time. Then it gets confounded by everyone calling everything best practices - no matter how long ago or unproven the practices might be. What would be handy is some generally agreed-upon yardsticks for graduating practices into or out of best practices status, plus better terminology to cover the spectrum of provenness so more sophisticated discussions can be had that account for the nuance and we don’t all talk past each other.. But then analyst companies wouldn’t get to make their glossy 2x2 charts, so it probably won’t happen.
• lijok 2y ago
  Very handwavy. Just like the aforementioned zealots, idiots and assholes.
• taeric 2y ago
  Best practices are tough for practices where the foundations are not stable. And with programming, we have trouble defining the foundations. Much less stabilizing them. And note I don't mean stable as in, not crashing. I mean it as not changing. For a while, this was doable with java. For its warts, it gave a good foundation. Industry practice got caught up in start up enthusiasm, though, and that went out the window. Similar could probably be said for Windows. I was not a fan of its model, but it provided a stable base for business apps for a long time.
• eapriv 2y ago
  Software around us is quite terrible, so it’s kind of obvious that one shouldn’t follow “best practices” that led to this state of things.
  • rileymat2 2y ago
    That implies they were created with best practices in the first place.
    • resonious 2y ago
      If not, then what was created with best practices in the first place? If we can agree that most large, financially successful software projects are of questionable quality, then either - they used best practices and yet they still suck, OR - they did not use best practices, but are widely successful anyway. So no matter how you look at it, software best practices just haven't panned out.
      • a96 2y ago
        "All hardware sucks, all software sucks."
    • eapriv 2y ago
      The name “best practices” kind of implies that they actually are practiced somewhere. So it’s different from theoretical abstract ideas “how we should write software”, which maybe nobody follows.
  • NathanaelRea 2y ago
    Maybe if people didn't follow best practices their software would be terrible-er? Guardrails for hard things doesn't imply no guardrails would make it easier.
• veltas 2y ago
  "Postel's law" is an ironic name, I don't think the people who coined that term meant that it was an infallible rule of the universe, just what seemed a good rule of thumb for implementing protocols. I still like Postel's law, but don't imagine for a second it's a 'law' with the kind of authority the article implies, and didn't enjoy the article's slime about people who like it!
• tyleo 2y ago
  Best practices are a way to avoid building everything up from first principles every time. They are more, “here are rules that are generally applicable so you don’t have to waste time thinking,” vs “here are laws of god which are always applicable.” It is an error to throw out every best practice and reconsider everything just as it is to blindly follow the best practices. IMO it’s best to apply the best practices by default and question them as they are used. Essentially trust but verify. Assuming they are right most of the time you get the benefit of speed. Assuming some of them are wrong, it still leaves room to course correct.
  • HPsquared 2y ago
    Maybe "good practice" is a better term.
    • sbarre 2y ago
      I've seen (and started using) "current common practices" instead of "best practices" where it makes sense. In an always-evolving technology landscape, it feels like a better representation of what we're doing, and it helps prevent the kind of dogmatic stubbornness that forms around the word "best".
• throwaway984393 2y ago
  [dead]
• deleted 2y ago
  [deleted]
• chthonicdaemon 2y ago
  Rules travel further than reasons. The problem is that a lot of true things in the world are counter-intuitive. So insisting that all the rules "make sense" in an immediate way is clearly a non-starter. In the safety industry there are many examples of best practices that are bred from experience but end up being counter-intuitive to some. For instance, it might not make intuitive sense that a pilot who has gone through a take-off procedure thousands of times needs a checklist to remember all the steps, but we know that it actually helps. It's hard because there is usually some information loss in summarisation, but we also have limited memory, so we can't really expect people to remember every case study that led to the distilled advice. As a chemical engineer by training, though, I have constantly been amazed at how resistant software people are to the idea that their industry could benefit from the kind of standardisation that has improved my industry so much.
  • burnt-resistor 2y ago
    It will never happen outside of limited industries because it would appear to be a loss of "freedom". I think the current situation creates an illusory anarchist freedom of informality that leads to sometimes proprietary lock-in, vulnerabilities, bugs, incompatibility churn, poorly-prioritized feature development, and tyranny of chaos and tech debt. There are too many languages, too many tools, too many (conflicting) conventions (especially ones designed by committee), and too many options. Having systems, tools, and components that don't change often with respect to compatibility and are formally-verifiable far beyond the rigor of seL4 such that they are (basically) without (implementation) error would be valuable over having tools lack even basic testing or self-tests, lack digital signatures that would prove chain-of-custody, and being able to model and prove a program or library to a level such that its behavior can be completely checked far more deeply in "whitebox" and "blackbox" methods for correctness would prove that some code stand the test of time. By choosing lesser numbers of standard language(s), tool(s), and component(s) it makes it cheaper and easier to attempt to do such. Maybe in 100 years, out of necessity, there will be essentially 1 programming language that dominates all others (power law distribution) for humans, and it will be some sort of formal behavioral model specification language that an LLM will generate tests and machine code to implement, manage, and test against.
• agentultra 2y ago
  I think the rejection is too strong in this article. The idea of, “best practices,” comes from an established Body of Knowledge. There is one published for software development called the SoftWare Engineering Body of Knowledge or SWEBOK; published by the IEEE. The author seems to be arguing for nuance: that these “laws,” require context and shouldn’t be applied blindly. I agree. However they shouldn’t be rejected out of hand either and people recommending them aren’t idiots. Update: one problem with “best practices,” that I think the article might have unwittingly implied is that most software developers aren’t aware of SWEBOK and are repeating maxims and aphorisms they heard from others. Software development is often powered by folklore and hand waving.
  • javcasas 2y ago
    I'm one of the devs not aware of the SWEBOK. Searching the internet all I can find is links to "the guide to SWEBOK". https://ieeecs-media.computer.org/media/education/swebok/swebok-v4.pdf https://ieeecs-media.computer.org/media/education/swebok/swe... But, you know, I want the whole ordeal. I want the SWEBOK, not the "how to read the SWEBOK". Where can I find it?
    • desbo 2y ago
      I think that is what you want. From Wikipedia: > In 2016, the IEEE Computer Society kicked off the SWEBOK Evolution effort to develop future iterations of the body of knowledge. The SWEBOK Evolution project resulted in the publication of SWEBOK Guide version 4 in October 2024. So the thing called "SWEBOK Guide" is actually the reference text for SWEBOK.
    • GranPC 2y ago
      It looks like SWEBOK Guide, guide to the SWEBOK, and SWEBOK are all used interchangeably. I wonder if they have a chapter on naming conventions.
    • deleted 2y ago
      [deleted]
    • deleted 2y ago
      [deleted]
• revskill 2y ago
  It is artificial standards for review. You can break it, but do it if u can.
• cromulent 2y ago
  I hear the phrase "best practices" not from the best practitioners, but from Dunning-Kruger types. Recently I was told that Hungarian notation was "best practice" and I must use it.
• gspencley 2y ago
  > but because they’re mostly pounded by either 1) various types of zealots, idiots, and assholes who abuse these kind of “best practices” as an argument from authority, or 2) inexperienced programmers who lack the ability to judge the applicability, The author might go on to make other points that are worth discussing, but lays out his supporting arguments clearly in the opening paragraph. Best practices do not necessarily do harm because they offer bad advice, they do harm because they are advocated for by zealots and the inexperienced. My first reaction is how unfortunate it is that this particular developer has found himself in the presence of bad engineers and the inexperienced. But then, the argument is automatically self-defeating. Why is the rest of the article even worth reading, if he states upfront what his arguments are and those arguments are very easy to refute? It is deeply irrational to judge the merits of an idea based solely on who is advocating for that idea. My advice to the author is to reflect on the types of positions that he accepts, the ones that have him so put off by the people that he works with that he is openly writing about abandoning what he admits could be sound engineering practice, solely based on who that advice is coming from and how it is being delivered. Developing software is complicated. It is constant problem solving. When solutions to problems come about, and we abstract those solutions, it is quite easy for individuals to misapply the abstraction to an inappropriate concrete. To drop context and try to retrofit a lousy solution because that solution was appropriate to a slightly different problem. But at the end of the day, these abstractions exist to try and simplify the process. Any time you see a "best practice" or design pattern acting as a complicating force, it is not doing its job. At that point you can either be objective and exercise some professional curiosity in order to try and understand why the solution adopted is inappropriate ... or you can take the lazy way out and just assume that "best practices" are the opinions of zealots and the inexperienced who blindly follow because they don't know any better.
  • convolvatron 2y ago
    we don't have to give undue value to 'best practices', nor do we need to judge an idea based on its presenter. we just need to have a reasonable discussion about the idea in the context in which its being applied. this simple approach has been largely eclipsed in the industry by the fetishization tools, and the absurd notion that whole classes of approaches can be dismissed as being 'antipattern'. It's not very hard to weigh a suggestion. speculate about its costs, benefits and risks.
• pizlonator 2y ago
  Someone once told me something like, “rules work best when human judgement is used when applying them”. I think that’s what this article is basically saying. And I agree.
• satisfice 2y ago
  “Best practices” have nothing to do with engineering. They are a marketing concept. They are a kind marketing better known as bullying. In every case where you want to say “best practice” there is a better alternative, which is to say “practice.” The concept of best is never needed or warranted, because practices are not subject to rigorous testing and review. I have been an independent consultant and trainer since 1999 and not once have I taught or recommended a best practice. I do have many opinions. I call them: opinions. I think my opinions are the best, but I can’t think of any reason that anyone else beyond my wife and dog should think so.
• binary132 2y ago
  I can sense the hackles rising. The arcane magi of the Guidance Council have scried a rebel wizard in their orb. Every cantrip and charm must be uttered at once, with maximal urgency! Invoke the spirits of the tomes!!!
• jsbg 2y ago
  The author sounds like even though they have read extensively about various "best" practices, they did not really gain an understanding of the tradeoffs involved with each one. > “Don’t Repeat Yourself” (DRY) is basically good advice, but sometimes just copy/pasting things is just the more pragmatic thing to do, and not really a big deal. Duplicating code on purpose is not about being pragmatic, it's about recognizing when DRY would violate the single responsibility principle. The ability to weigh tradeoffs in context is what makes some engineers better than others.
  • layer8 2y ago
    The problem with DRY is that it is expressed incorrectly and misleadingly. There is little inherent benefit in avoiding code duplication, and it can do harm when done for the wrong reasons. The actual context is change management. Will the copy of the code likely have to change in the same way as the original? Only then should duplication be avoided. The rule taken literally fails to convey this important precondition and the reasoning behind it. (And so does WET.)
  • recursive 2y ago
    > The author sounds like even though they have read extensively about various "best" practices, they did not really gain an understanding of the tradeoffs involved with each one. It sounds to me like they did understand the tradeoffs. But that they were being brow-beaten to apply "best practices" that were inapplicable because of the tradeoffs.
• lkrubner 2y ago
  Dan Morena, CTO at Upright.com, made the point that every startup was unique and therefore every startup had to find out what was best for it, while ignoring whatever was considered "best practice." I wrote what he told me here: https://respectfulleadership.substack.com/p/dan-morena-is-a-genius https://respectfulleadership.substack.com/p/dan-morena-is-a-... My summary of his idea: No army has ever conquered a country. An army conquers this muddy ditch over here, that open wheat field over there and then the adjoining farm buildings. It conquers that copse of lush oak trees next to the large outcropping of granite rocks. An army seizes that grassy hill top, it digs in on the west side of this particular fast flowing river, it gains control over the 12 story gray and red brick downtown office building, fighting room to room. If you are watching from a great distance, you might think that an army has conquered a country, but if you listen to the people who are involved in the struggle, then you are aware how much "a country" is an abstraction. The real work is made up of specifics: buildings, roads, trees, ditches, rivers, bushes, rocks, fields, houses. When a person talks in abstractions, it only shows how little they know. The people who have meaningful information talk about specifics. Likewise, no one builds a startup. Instead, you build your startup, and your startup is completely unique, and possesses features that no other startup will ever have. Your success will depend on adapting to those attributes that make it unique.
  • alach11 2y ago
    Wow what a fantastic little article. Thanks for writing and sharing that.
    • fsckboy 2y ago
      my irony detector is going off, but it's feeble. do I need a better irony detector?
      • alach11 2y ago
        I was being genuine.
        • 2y ago
• 123sereusername 2y ago
  [dead]
• eichi 2y ago
  I want engineers to think about the best for the project but I let engineers talk about the best of implementation because it's better than doing irrevant things.
• dkarl 2y ago
  Living through the 2000s was enough to give me a permanent aversion to "best practices." So many things that we look back on in horror were smugly and haughtily justified using those words. There was a culture of best practices zealots that had an uncanny resemblance to organized religion. All the answers have been written down for us, and everything that goes wrong is because of arrogant, misguided people who decided to trust their own fallible thoughts instead. Their faith was strong enough to survive any project, no matter the outcome.
• betenoire 2y ago
  Only software engineers pretend best practices exist outside of any useful context. - small localized team vs big distributed team - bug fixes and incremental improvements vs green field poc - saas vs system scripts Context matters, and if people aren't giving you the context in which they deem practices to be "best", they are myopically wrong
  • davorak 2y ago
    So outside of coworkers that have a hard time collaborating in general, is it a problem for others that their coworkers will not apply context? That has not been my experience.
    • betenoire 2y ago
      I don't understand the question... If someone has a strong opinion, and they have arguments for their opinion, but don't recognize the significance of the context in which they've formed their opinions, they have blind spots they aren't aware of. Is that a problem? I dunno, that's up to you and your environment.
      • davorak 2y ago
        > Only software engineers pretend best practices exist outside of any useful context. I am not seeing this issue with programmers in general or with my coworkers, with the exception of those who in general have a hard time collaborating with others. So my question was/is if you discount the above exception are people seeing a problem with programmers/coworkers not taking context in to account? I have not noticed a wide spread issue and I am interested in how prevalent you, and others, perceive the issue to be.
        • betenoire 2y ago
          Aren't these discussions the evidence? The fact that the author wrote a blog post and we are here discussing it. I might be missing the point of your question. This is everywhere around us in the development world. Anytime people compare react to htmx, redis to postgres, TDD vs BDD. I'd like to point out I never called it a problem. I said that was a judgement call for you to make. We all have harmless biases. But yeah, it can be a problem. If I have an engineer derailing my team because of his insistence for svelte, and can't read the room: ie can't take any of the context of the business, stack, domain, team, into his consideration, then yeah, it becomes a problem. Time is money (svelte isn't a good example, it's not a best practice per se. s/svelte/TDD/)
• uludag 2y ago
  > “Don’t use globals” is obviously good, but “never use globals under any circumstances” is just silly I'm actually not even convinced that this is a good rule. When it's explained it makes sense on the surface. I also think that since beginners to programming use global variables, they come to the conclusion that it must be universally bad since that's what their beginner self did. Having work on codebases with most state being being stored as global variables (in a single namespace at that) is manageable at worst and easy to develop on at best, assuming certain conventions are followed.
• kthejoker2 2y ago
  IME "best practices" is a demand problem, not a supply problem. IE far more people want best practices than there are actual best practices. Prospects and customers desperately want to know our "best practices" and then complain when we say "it depends" or something experimentation is required, as if we are hiding secret teachings from them. For me this is more a personality test: people who just want solutions on a silver platter vs DIYers who want to tinker and distrust black boxes.
  • bobbruno 2y ago
    That's an interesting point, which leads me to my main reason for coming to these comments and leaving my 2 cents: there are way less best practices of there than one would believe by looking at all the places, people and firms offering some set of "best practices". One thing I learned after many years working in consulting is that, more often than one would believe, best practices are just a compilation of whatever could be found (hopefully at least common practices, more often "things I could find that were minimally documented to be reusable"), with no serious analysis of their claim of superiority other than them being common. So, first thing: learn to challenge the claim of "best". Best for whom? Under what context? What other not-so-good practices are out there, and why is this the best? Second:if it's documented and evident enough to be treated as a best practice, it's probably fairly common knowledge already. Barring the commonality of really bad things being done out there, don't expect that you'll become much more than mediocre by adopting best practices. By the time they get to be called there, they are no longer any competitive advantage, more a basic thing you should be doing already - assuming they are indeed best practices (as per my previous point). It's not that I'm against best practices as a concept, or compiled bodies of knowledge. Just don't expect them to do more than keep you somewhere in the middle. True leadership and innovation lies where best practices have not been established yet - together with all the dangers and mistakes you can make on uncharted waters.
• dblohm7 2y ago
  The real problem is dogma and cargo culting.
• antirez 2y ago
  I agree with the sentiment of the article, but Postel law is a good idea that has very little to do with the context. Of course the real problem is that it's a very small advice that needs to be put into context each time, and here is the failure of all the types of advices: they are not substitutes for intelligence and good design tastes.
• layer8 2y ago
  The advantage of best practices is that you have something you can follow without having to analyze the situation in depth. The disadvantage of best practices is that you may have to analyze the situation in depth to notice that they maybe aren’t the best choice in the specific situation. The harm that best practices can do are lessened by viewing them as a rule of thumb conditioned on certain premises rather than as a dogma.
  • nativeit 2y ago
    “Dogma” is the key word in this situation, I believe (and in a lot of similar situations). There are very few examples for when dogmatic obedience is healthy, helpful, or appropriate. Sadly, the trends seem to be heading the wrong way, with more tribalism than pragmatism.
    • safetytrick 2y ago
      I'm proud of my little joke on dogmas: "The only dogma I believe is that all dogmas are wrong".
  • malfist 2y ago
    I like to use the term "golden path" instead of best practices. In a golden path, lots of others have gone before you and figured out all the nuance. But this doesn't mean the path is the best one for you, but does mean you should have a good reason for starying from it
    • hinkley 2y ago
      To which they will respond with something from their VC deck, like, “because we’re Uber for <whatever>” Buddy that’s not a reason, that’s a rationalization.
  • baxtr 2y ago
    That’s why I think Best Practice is a bad term. I rather call it something like Best Toolkit or Best Elements.
• eterm 2y ago
  Following "Best practice" isn't about doing what is "best", it's about being predictable. In many cases, being predictable is better for future maintenance than forging your own path, even if the custom solution is "better" against all (current) metrics.
• MantisShrimp90 2y ago
  The longer I program the more I agree with this take. I have seen too much power and dominance from people who wield it as a cudgel against everyone else in the room who doesn't care enough to double-check the practice. Put another way, knowledge is knowing best-practices, but wisdom is knowing where and when to apply them. Unfortunately, most building software have only the knowledge and there is too little consideration for the fact that structure is not free, and considerations must be made for when velocity is the primary objective vs safety and adherence to best-practices. It all comes down to architecture design in the end.
• js2 2y ago
  Ralph Waldo Emerson: "A foolish consistency is the hobgoblin of little minds, adored by little statesmen and philosophers and divines. With consistency a great soul has simply nothing to do. He may as well concern himself with his shadow on the wall. Speak what you think now in hard words, and to-morrow speak what to-morrow thinks in hard words again, though it contradict every thing you said to-day. — 'Ah, so you shall be sure to be misunderstood.' — Is it so bad, then, to be misunderstood? Pythagoras was misunderstood, and Socrates, and Jesus, and Luther, and Copernicus, and Galileo, and Newton, and every pure and wise spirit that ever took flesh. To be great is to be misunderstood." https://en.wikipedia.org/wiki/Wikipedia:Emerson_and_Wilde_on_consistency https://en.wikipedia.org/wiki/Wikipedia:Emerson_and_Wilde_on... (This is relevant to the extent that programming is as much art as science/engineering.)
• ssrc 2y ago
  Like any other discussion of this kind[1] I think this one will go nowhere because 1) the question doesn't have a black and white answer, it's a sliding scale. 2) almost no one is giving examples of what they mean; if they were, they could find that they agree with the person they are replying to. And 3) most people will discard the experiences of people they disagree with "you didn't even try! maybe the problem is you!", and this is easy because this is the internet and the other person can be (is probably?) making it up. [1]https://www.joelonsoftware.com/2009/09/23/the-duct-tape-programmer/ https://www.joelonsoftware.com/2009/09/23/the-duct-tape-prog...
• bongodongobob 2y ago
  Ragebait post unless you enjoy playing semantics games with verysmarts. If you don't understand the purpose of the term "best practices", they were probably made for someone like you.
  • recursive 2y ago
    The problem is when one does understand, but is being subjected to them by someone who doesn't.
• worik 2y ago
  No. I've worked too often with people who think they know better They do not Straw men do not change the fact that "best practices" , especially the ones quoted, are very good. No sensible person is saying "never use globals". We caution you to think very carefully before you do, only for truly global state. I am suffering from inherited code, written by a very good programmer, who got lazy with globals and comments. Too many of the former, too few of the later. What a nightmare This article is arrant nonsense
  • recursive 2y ago
    > No sensible person is saying "never use globals". Maybe so, but still, plenty of people are saying it.
  • akvadrako 2y ago
    I've been on a team where most comments I added where deleted because they believed it was best practice to avoid them getting out of sync with the code. So even your comment disagrees with your claim that "best practices" are very good.
• syngrog66 2y ago
  yikes
• srmatto 2y ago
  The author sort of goes against his own advice but not diving into the specifics of why he doesn't like certain things. I get that such a piece would be longer, take more time and effort, and would draw more argumentation but that's what he's asking for in the piece itself.
• mediumsmart 2y ago
  Best Practice is to not care about the stupid asshole who came up with a brilliant method that works. I tried to have the grammar checked by chatgpt but it was too challenging
• graypegg 2y ago
  I have an on-going topic with friends at work about what accessibility "means". It annoys me to no end when devs talk about some specific technical change "increasing accessibility". The accessibility best practices are used as a checklist where more checks = more accessibility points = better. It results in people gaming the score with meaningless repetitive metadata or low-impact tweaks, rather than actually improving the descriptive/alternative/touch/visual interface. Usually never even trying any alternative method of interacting with an interface. The best practice is "always include metadata", but it leaves off "... that adds context about the element rather than noise, and integrates with a surrounding application that uses consistent metadata labelling. Remember, this is a portion of a complete descriptive interface someone has to use." These best practices being driven into people's brains verbatim means conversations devolve into inane on-or-off taxonomy discussions like "is this colour accessible?" or "have we added accessibility? Do you need a ticket for that?" where pushing back isn't seen as caring about users, it's seen as being "against accessibility". https://graypegg.com/2023/11/25/the-private-definition-of-accessible.html https://graypegg.com/2023/11/25/the-private-definition-of-ac...
• munificent 2y ago
  It took me way too long to realize this, but my experience is that "zealots, idiots, and assholes" (as the author says) are going to abuse something and wield it as a bludgeon against other people. This appears to be a fixed, immutable property of the universe. If you take it as a given that some number of people are going to get an idea lodged in their head, treat it like gospel, and beat as many other people in the head with it as they can... the best strategy you can adopt is to have the ideas in their head be at least somewhat useful. Yes, reasonable people understand that "best practices" come with all sorts of context and caveats that need to be taken into account. But you won't always be dealing with reasonable people, and if you're dealing with an asshole, zealot, or idiot, I'd sure as hell prefer one who blindly believes in, say, test-first development versus believing that "test code isn't real code, you should spend all of your time writing code that ships to users" or some other even worse nonsense.
  • rileymat2 2y ago
    The one thing that gives me pause, is that I have seen stages of mastery where the base stage is repetition and adherence to rules to internalize them before understanding them and knowing when to break them. If much of our industry is new, evangelizing these rules as harder and faster than they are makes a lot of sense to bring people to get people ready for the next stage. Then they learn the context and caveats over time.
    • a96 2y ago
      That made me want to look up some link about Shu Ha Ri. Turns out that's actually been made popular in some corners of sw dev already. E.g. https://martinfowler.com/bliki/ShuHaRi.html https://martinfowler.com/bliki/ShuHaRi.html
  • ToucanLoucan 2y ago
    In any given culture (software development) you will have a set of traditions that may be used by the members of that culture to signify status, experience, pedigree and authority, and often some combination of all these and other descriptors. And, by virtue of creating a culture, you will also necessarily create a counter-culture, which rejects those things (performatively or otherwise) in an effort to do the exact same thing, but in the other direction. If you decide that proper software is developed with command-line in mind first, and UI second, you will in that effort necessarily create software devs who believe the exact opposite. This is core to our being as humans. In my mind, this author is merely signaling software counter-culture, some of which I agree with, others I don't. And the people whom you describe above are signaling software culture, in a hostile and domineering way. And of course, these two sides are not impermeable, forever persistent: culture and counter-culture shift constantly, often outright reversing from one another on a roughly 30 year timeline. And, they both have important things to offer. Best practices are best practices for a reason, and also telling stuffy people to chill out when they're focused so hard on best practices that they lose the plot of what the org is actually attempting to accomplish is also important.
• safetytrick 2y ago
  I like to phrase this kind of thought as: "The only dogma I believe, is that all dogmas are wrong".
• miguelbemartin 2y ago
  "Best practices" is a tool that you need to know how to use it. Same as any other tool. If you do use the same tool for everything, this is when a tool becomes a bad thing. "Best practices" is a really good tool if you use it in the correct context.
  • miguelbemartin 2y ago
    "Because it's best practices" can not be used as an argument.
• roncesvalles 2y ago
  I see "best practices" as just case studies. Here's one possible way to do it. If it intrigues you, you can do the same. Most of these "best practices" have valid opposing camps anyway. There's DRY, but there's also "a little copying is better than a little dependency". Both are valid in different contexts.
• langsoul-com 2y ago
  Best practices for a Google scale company, where most best practices come from, is NOT the best practice for everyone else.
  • kridsdale1 2y ago
    As someone at Google, I hardly believe they deserve to be used at Google. We have like 20% the efficiency we could have if we were more selective about procedure.
• lvturner 2y ago
  I once put in an e-mail the following "best practice applied for the sake of best practice, is bad practice" to consultant who chalked up an awful decision to "applying best practices"
• ChrisMarshallNY 2y ago
  That's some weird ligature, on that font... I don't think that the issue is with "best practices," or any other type of dogma. I think the main issue, is that companies tend to hire folks that aren't especially skilled at what they do, and rely on excessive structure, to compensate, or that they don't stay around, long enough, to get comfortable with the structure. This can apply to both newer folks, who don't understand the system well enough to effectively deviate, and ones with a lot of experience, who have allowed themselves to get so hidebound, they are afraid to deviate. As I have gotten older, wiser, and more battle-scarred (often, from self-inflicted injuries), I have learned that "It Depends™" is the only true mantra for my work. Usually, best practices/dogma/structure becomes important, when the codebase is being worked on by a team, and when there's the need to coordinate work between teams. There's some type of work that just can't be done, without structure. I've done that type of work. Other work can be killed by too much structure. I've done that kind of work, as well.
• YZF 2y ago
  So we shouldn't: - Use source control? - Have build automation? - (at least some) automated testing? - Protect data structures accessed concurrently with a mutex? - Have backups? I wouldn't say there isn't some imaginary situation where you'd do something different, but it's safer to fall back to doing the above in most situations. That said many people make up "best practices" or use them without understanding the circumstances to which they apply.
• tonymet 2y ago
  most "best practices" are just trends that got way out of hand. Microservices, long variable names, XML, TDD, SCRUM, OOP were just marketing concepts that turned into a cult. Books like Code Complete are useful tools but not bibles. Just like everything on the internet: it's just another person's opinion. What matters is what works (i.e. makes you money).
• m463 2y ago
  I think the problem is that the definition of "best practices" is a little muddy. for example: - use source control - don't put spaces in file names - camelcase is better than underscores in variables - vi not emacs some are really best practices, some are controversial choices someone is pushing. Some places I've worked with good policies deliberately left some open. And made choices earlier on troublesome ones like spaces not tabs. I think the choosing or defining vs not choosing is what companies should do to define themselves.
• richrichie 2y ago
  There is a whole book on this topic. I think it is called Street Coder.
• bitwize 2y ago
  I've found that "best practice" generally means "what you will not get fired for doing". Sometimes it is a good practice. Sometimes it's something the higher-ups read about in CTO magazine and decided that everybody now must do. I'd say use your individual judgement, but depending on your role and the company, using your own judgement may be beyond your pay grade.
• srkiNZ 2y ago
  Great article! I feel like I am dealing with so much of this behaviour at my job recently. It feels like most of the people espousing Best Practice never learned that "appeal to authority" was not a reasonable argument.
• yazantapuz 2y ago
  Teaching threads on a operating systems course, i have witnessed some of the more convoluted code ever by students so afraid on global variables that they turned simple exercises into monstrosities. So yes, f*ck the rigid rules. They have to unlearn best practices guidelines, to which they were "blood-written sacred rules".
  • a96 2y ago
    Well, in class environment, they've probably figured out that it's not a sane or correct answer that gets the points. It's the answer that follows all the rules that have been set in the material for that class. It's extremely typical for teachers to grade based on the "best practices" and "sacred rules" that the classes teach. Showing ideas, outside knowledge or solutions that are simpler than the course material just gets a student punished.
• timrobinson33 2y ago
  For me I will always try to seek out best practice as an inspiration - to find out what the most knowledgeable people in this field do. But if I can't understand why I should do that instead of something else I've thought of, then I'll do it my way thank you.
• legulere 2y ago
  > “use single point of exit”, and that kind of absolute insane bollocks As always it's a matter of context. If you have a low level language like C without any automatic cleanup having an out label to goto which cleans up in all cases makes a lot of sense. There's always some reasoning behind those rules, sadly rarely talked about directly. You should check if that reasoning applies to you and weigh the benefits against the costs. A lot of time it's just doing what everyone else is doing, which is a very fine reason, as it makes onboarding new developers easier.