19 ms·

Laws of Software Engineering

• IshKebab 6mo ago
  Calling these "laws" is a really really bad idea.
• milanm081 6mo ago
  For years, I kept notes on patterns I saw in software projects, architecture, planning, estimation, testing, scaling, and team design. I pulled those notes into a browsable site with 56 laws, grouped into categories, with short explanations and separate pages for each one. The goal was simple: put these ideas in one place, so when you want a quick refresher on Conway’s Law, Brooks’s Law, Gall’s Law, Hyrum’s Law, or Goodhart’s Law, you can find it fast. I’m more interested in criticism than praise. Which laws are missing, which ones feel overstated, and which ones get misused most often in real work?
• grahar64 6mo ago
  Some of these laws are like Gravity, inevitable things you can fight but will always exist e.g. increasing complexity. Some of them are laws that if you break people will yell at you or at least respect you less, e.g. leave it cleaner than when you found it.
  • stingraycharles 6mo ago
    Lots of them are also only vaguely related to software engineering, e.g. Peter Principle. It’s not a great list. The good old c2.com has many more, better ones.
  • layer8 6mo ago
    Physical laws vs human laws.
• WillAdams 6mo ago
  Visual list of well-known aphorisms and so forth. A couple are well-described/covered in books, e.g., Tesler's Law (Conservation of Complexity) is at the core of _A Philosophy of Software Design_ by John Ousterhout https://www.goodreads.com/en/book/show/39996759-a-philosophy-of-software-design https://www.goodreads.com/en/book/show/39996759-a-philosophy... (and of course Brook's Law is from _The Mythical Man Month_) Curious if folks have recommendations for books which are not as well-known which cover these, other than the _Laws of Software Engineering_ book which the site is an advertisement for.....
• tmoertel 6mo ago
  One that is missing is Ousterhout’s rule for decomposing complexity: complexity(system) = sum(complexity(component) * time_spent_working_in(component) for component in system). The rule suggests that encapsulating complexity (e.g., in stable libraries that you never have to revisit) is equivalent to eliminating that complexity.
  • stingraycharles 6mo ago
    That’s not some kind of law, though. And I’m also not sure whether it even makes sense, complexity is not a function of time spent working on something.
    • tmoertel 6mo ago
      First, few of the laws on that site are actual laws in the physics or mathematics sense. They are more guiding principles. > complexity is not a function of time spent working on something. But the complexity you observe is a function of your exposure to that complexity. The notion of complexity exists to quantify the degree of struggle required to achieve some end. Ousterhout’s observation is that if you can move complexity into components far away from where you must do your work to achieve your ends, you no longer need to struggle with that complexity, and thus it effectively is not there anymore.
      • wduquette 6mo ago
        And in addition, the time you spend making a component work properly is absolutely a function of its complexity. Once you get it right, package it up neatly with a clean interface and a nice box, and leave it alone. Where "getting it right" means getting it to a state where you can "leave it alone".
    • Brian_K_White 6mo ago
      It's showing that all the complexity in the components are someone else's problem. Your only complexity is your own top layer and your interface with the components.
• dataviz1000 6mo ago
  I did not see Boyd’s Law of Iteration [0] "In analyzing complexity, fast iteration almost always produces better results than in-depth analysis." Boyd invented the OODA loop. [0]https://blog.codinghorror.com/boyds-law-of-iteration/ https://blog.codinghorror.com/boyds-law-of-iteration/
  • devsda 5mo ago
    I think taking Boyd's law to the extreme is how some folks end up with sprints lasting 1 week or less.
  • deleted 6mo ago
    [deleted]
  • Silamoth 6mo ago
    That’s such a good one! I wish more people understood this. It seems management and business types always want some upfront plan. And I get it, to an extent. But we’ve learned this isn’t a very effective way to build software. You can’t think of all possible problems ahead of time, especially the first time around. Refactoring to solve problems with a flexible architecture it better than designing yourself into a rigid architecture that can’t adapt as you learn the problem space.
  • computerdork 5mo ago
    That is a good one, iterative development is in general superior to overly deliberate and overly careful development. And what a great and very subtle example with the fighter jet control sticks. This reminds of a build time issue I once had. Yeah, way back in college, did really poorly on a final programming project, because didn't realize you were supposed to swap out a component they had you write with a mock component that was provided for you - hard to explain, but they wanted you to write this component to show you could, but once you did, you weren't supposed to use it, because it was extremely slow to build. So they also gave you a mock version to use when working on the code of your main system. Using my full component killed my build time, as it took 10 minutes to build instead of a few seconds, and it was the one school programming project I couldn't finish before the deadline and was super stressful. Was a very painful lesson but ever since have always found ways to shorten my build times.
• ozgrakkurt 6mo ago
  For anyone reading this. Learn software engineering from people that do software engineering. Just read textbooks which are written by people that actually do things
  • ghm2180 6mo ago
    Any recommendations? I read designing data intensive applications(DDIA) which was really good. But it is by Martin Klepmann who as I understand is an academic. Reading PEPs is also nice as it allows one to understand the motivations and "Why should I care" about feature X.
    • ozgrakkurt 6mo ago
      https://www.amazon.com/Computer-Architecture-Quantitative-Approach-Kaufmann/dp/0128119055 https://www.amazon.com/Computer-Architecture-Quantitative-Ap... https://casual-effects.blogspot.com/2014/05/a-computer-science-book-reading-list.html https://casual-effects.blogspot.com/2014/05/a-computer-scien...
    • azath92 6mo ago
      the python cookbook is good. and fluent python is more from principles rather than application (obvs both python specific). I also like philosophy of software design. tiny little book that uses simple example (class that makes a text editor) to talk about complexity, not actually about making a text editor at all.
    • WillAdams 6mo ago
      Ousterhout's _A Philosophy of Software Design_ (mentioned elsethread) would be mine.
    • devgoncalo 6mo ago
      The Pragmatic Programmer https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...
    • pratikdeoghare 5mo ago
• _dain_ 6mo ago
  I have a lot of issues with this one: https://lawsofsoftwareengineering.com/laws/premature-optimization/ https://lawsofsoftwareengineering.com/laws/premature-optimiz... It leaves out this part from Knuth: >The improvement in speed from Example 2 to Example 2a is only about 12%, and many people would pronounce that insignificant. The conventional wisdom shared by many of today’s software engineers calls for ignoring efficiency in the small; but I believe this is simply an overreaction to the abuses they see being practiced by penny-wise- and-pound-foolish programmers, who can’t debug or maintain their “optimized” programs. In established engineering disciplines a 12% improvement, easily obtained, is never considered marginal; and I believe the same viewpoint should prevail in software engineering. Of course I wouldn’t bother making such optimizations on a one-shot job, but when it’s a question of preparing quality programs, I don’t want to restrict myself to tools that deny me such efficiencies. Knuth thought an easy 12% was worth it, but most people who quote him would scoff at such efforts. Moreover: >Knuth’s Optimization Principle captures a fundamental trade-off in software engineering: performance improvements often increase complexity. Applying that trade-off before understanding where performance actually matters leads to unreadable systems. I suppose there is a fundamental tradeoff somewhere, but that doesn't mean you're actually at the Pareto frontier, or anywhere close to it. In many cases, simpler code is faster, and fast code makes for simpler systems. For example, you might write a slow program, so you buy a bunch more machines and scale horizontally. Now you have distributed systems problems, cache problems, lots more orchestration complexity. If you'd written it to be fast to begin with, you could have done it all on one box and had a much simpler architecture. Most times I hear people say the "premature optimization" quote, it's just a thought-terminating cliche.
  • Xiaoher-C 6mo ago
    [dead]
  • dgb23 6mo ago
    > In many cases, simpler code is faster, and fast code makes for simpler systems. (...) I wholeheartedly agree with you here. You mentioned a few architectural/backend issues that emerge from bad performance and introduce unnecessary complexity. But this also happens in UI: Optimistic updates, client side caching, bundling/transpiling, codesplitting etc. This is what happens when people always answer performance problems with adding stuff than removing stuff.
• mojuba 6mo ago
  > Get it working correctly first, then make it fast, then make it pretty. Or develop a skill to make it correct, fast and pretty in one or two approaches.
  • AussieWog93 6mo ago
    I recently had success with a problem I was having by basically doing the following: - Write a correct, pretty implementation - Beat Claude Code with a stick for 20 minutes until it generated a fragile, unmaintainable mess that still happened to produce the same result but in 300ms rather than 2500ms. (In this step, explicitly prompting it to test rather than just philosophising gets you really far) - Pull across the concepts and timesaves from Claude's mess into the pretty code. Seriously, these new models are actually really good at reasoning about performance and knowing alternative solutions or libraries that you might have only just discovered yourself.
    • mojuba 6mo ago
      However, a correct, pretty and fast solution may exist that neither of you have found yet. But yes, the scope and breadth of their knowledge goes far beyond what a human brain can handle. How many relevant facts can you hold in your mind when solving a problem? 5? 12? An LLM can take thousands of relevant facts into account at the same time, and that's their superhuman ability.
  • theandrewbailey 6mo ago
    Modern SaaS: make it "pretty", then make it work, then make it "pretty" again in the next release. Make fast? Never.
• conartist6 6mo ago
  Remember that these "laws" contain so many internal contradictions that when they're all listed out like this, you can just pick one that justifies what you want to justify. The hard part is knowing which law break when, and why
  • ghm2180 6mo ago
    This is doubly true in Machine Learning Engineering. Knowing what methods to avoid is just as important to know what might work well and why. Importantly a bunch of Data Science techniques — and I use data science in the sense of making critical team/org decisions — is also as important for which you should understand a bit of statistics not only data driven ML.
    • Silamoth 6mo ago
      Statistics is absolutely fundamental to data science. But I’m not sure this relates to the above idea of “laws” being internally contradictory?
  • AussieWog93 6mo ago
    DRY is my pet example of this. I've seen CompSci guys especially (I'm EEE background, we have our own problems but this ain't one of them) launch conceptual complexity into the stratosphere just so that they could avoid writing two separate functions that do similar things.
    • pydry 6mo ago
      DRY is misunderstood. It's definitely a fundamental aspect of code quality it's just one of about 4 and maximizing it to the exclusion of the others is where things go wrong. Usually it comes at the expense of loose coupling (which is equally fundamental). The goal ought to be to aim for a local minima of all of these qualities. Some people just want to toss DRY away entirely though or be uselessly vague about when to apply it ("use it when it makes sense") and thats not really much better than being a DRY fundamentalist.
• d--b 6mo ago
  It's missing: > Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp. https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule
  • tgv 6mo ago
    Shouldn't it also be able to read email? I think that was a law too. Anyway, the list seems like something AI scraped and has a strong bias towards "gotcha" comments from the likes of reddit.
• tfrancisl 6mo ago
  Remember, just because people repeated it so many times it made it to this list, does not mean its true. There may be some truth in most of these, but none of these are "Laws". They are aphorisms: punchy one liners with the intent to distill something so complex as human interaction and software design.
• r0ze-at-hn 6mo ago
  Love the details sub pages. Over 20 years I collected a little list of specific laws or really observations (https://metamagic.substack.com/p/software-laws https://metamagic.substack.com/p/software-laws) and thought about turning each into specific detailed blog posts, but it has been more fun chatting with other engineers, showing the page and watch as they scan the list and inevitably tell me a great story. For example I could do a full writeup on the math behind this one, but it is way more fun hearing the stories about the trying and failing to get second re-writes for code. 9. Most software will get at most one major rewrite in its lifetime.
• Antibabelic 6mo ago
  Software engineering is voodoo masquerading as science. Most of these "laws" are just things some guys said and people thought "sounds sensible". When will we have "laws" that have been extensively tested experimentally in controlled conditions, or "laws" that will have you in jail for violating them? Like "you WILL be held responsible for compromised user data"?
  • horsawlarway 6mo ago
    At least for your last point... ideally never. Look, I understand the intent you have, and I also understand the frustration at the lack of care with which many companies have acted with regards to personal data. I get it, I'm also frustrated. But (it's a big but)... Your suggestion is that we hold people legally responsible and culpable for losing a confrontation against another motivated, capable, and malicious party. That's... a seriously, seriously, different standard than holding someone responsible for something like not following best practices, or good policy. It's the equivalent of killing your general when he loses a battle. And the problem is that sometimes even good generals lose battles, not because they weren't making an honest effort to win, or being careless, but because they were simply outmatched. So to be really, really blunt - your proposal basically says that any software company should be legally responsible for not being able to match the resources of a nation-state that might want to compromise their data. That's not good policy, period.
    • Antibabelic 6mo ago
      Incidents happen in the meat world too. Engineers follow established standards to prevent them to the best of their ability. If they don't, they are prosecuted. Nobody has ever suggested putting people in jail for Russia using magic to get access to your emails. However, in the real world, there is no magic. The other party "outmatches" you by exploiting typical flaws in software and hardware, or, far more often, in company employees. Software engineering needs to grow up, have real certification and standards bodies and start being rigorously regulated, unless you want to rely on blind hope that your "general" has been putting an "honest effort" and showing basic competence.
• vpol 6mo ago
  Is it not the same as https://github.com/dwmkerr/hacker-laws https://github.com/dwmkerr/hacker-laws ?
• threepts 6mo ago
  I believe there should be one more law here, telling you to not believe this baloney and spend your money on Claude tokens.
• RivieraKid 6mo ago
  Not a law but a a design principle that I've found to be one of the most useful ones and also unknown: Structure code so that in an ideal case, removing a functionality should be as simple as deleting a directory or file.
  • kijin 6mo ago
    What's the smallest unit of functionality to which your principle applies? For example, each comment on HN has a line on top that contains buttons like "parent", "prev", "next", "flag", "favorite", etc. depending on context. Suppose I might one day want to remove the "flag" functionality. Should each button be its own file? What about the "comment header" template file that references each of those button files?
    • sverhagen 6mo ago
      Maybe the buttons shouldn't be their own files, but the backend functionality certainly could be. I don't do this, but I like the idea.
    • jpitz 6mo ago
      I think that if you continue along the logical progression of the parent poster, then maybe the smaller units of functionality would be represented by simple ranges of lines of text. Given that, deleting a single button would ideally mean a single contiguous deletion from a file, versus deleting many disparate lines.
    • balamatom 5mo ago
      The `comment_header` template would iterate over the files in `comment_header.d/*`, which would, admittedly, need forced sorted naming: 100_parent.template 150_context.template 200_prev_next.template 300_flag.template 350_favorite.template Looks odd with the numbering, no? But then you get the added benefit of being able to refer to them by numbers, just "100" or "300" without having to glue humanlang inflection, declension, punctuation onto identifiers that happen to be words... Some places where you can see this pattern: BASIC's explicit line numbering; non-systemd init systems.
  • 6mo ago
• serious_angel 6mo ago
  Great! Do principles fit? If so, considering presence of "Bus Factor", I believe "Chesterton's Fence" should be listed, too.
• bronlund 6mo ago
  Pure gold :) I'm missing one though; "You can never underestimate an end user.".
• Symmetry 6mo ago
  On my laptop I have a yin-yang with DRY and YAGNI replacing the dots.
  • someguyiguess 5mo ago
    That is exactly what I would expect from someone with your username. Bravo.
• fenomas 6mo ago
  Nice to have these all collected nicely and sharable. For the amusement of HN let me add one I've become known for at my current work, for saying to juniors who are overly worried about DRY: > Fen's law: copy-paste is free; abstractions are expensive. edit: I should add, this is aimed at situations like when you need a new function that's very similar to one you already have, and juniors often assume it's bad to copy-paste so they add a parameter to the existing function so it abstracts both cases. And my point is: wait, consider the cost of the abstraction, are the two use cases likely to diverge later, do they have the same business owner, etc.
  • ndr 6mo ago
    Same vibe, different angle: > 11. Abstractions don’t remove complexity. They move it to the day you’re on call. Source: https://addyosmani.com/blog/21-lessons/ https://addyosmani.com/blog/21-lessons/
  • Xiaoher-C 6mo ago
    [dead]
  • Symmetry 5mo ago
    "Any problem in computer science can be solved with another level of indirection...except for the problem of too many levels of indirection."
• dassh 6mo ago
  Calling them 'laws' is always a bit of a stretch. They are more like useful heuristics. The real engineering part is knowing exactly when to break them.
  • someguyiguess 5mo ago
    Especially since a lot of them are written in a tongue-in-cheek way. And many are contradictory.
• Sergey777 6mo ago
  A lot of these “laws” seem obvious individually, but what’s interesting is how often we still ignore them in practice. Especially things like “every system grows more complex over time” — you can see it in almost any project after a few iterations. I think the real challenge isn’t knowing these laws, but designing systems that remain usable despite them.
• James_K 6mo ago
  I feel that Postel's law probably holds up the worst out of these. While being liberal with the data you accept can seem good for the functioning of your own application, the broader social effect is negative. It promotes misconceptions about the standard into informal standards of their own to which new apps may be forced to conform. Ultimately being strict with the input data allowed can turn out better in the long run, not to mention be more secure.
• wesselbindt 6mo ago
  Two of my main CAP theorem pet peeves happen on this page: - Not realizing it's a very concrete theorem applicable in a very narrow theoretical situation, and that its value lies not in the statement itself but in the way of thinking that goes into the proof. - Stating it as "pick any two". You cannot pick CA. Under the conditions of the CAP theorem it is immediately obvious that CA implies you have exactly one node. And guess what, then you have P too, because there's no way to partition a single node. A much more usable statement (which is not a theorem but a rule of thumb) is: there is often a tradeoff between consistency and availability.
  • urxvtcd 6mo ago
    Well, ackchyually, you can not pick P, it's just not cheap. You could imagine a network behaving like a motherboard really.
  • traderj0e 5mo ago
    In practice a quorum mechanism gets you close enough to picking all three in CAP, doesn't it? But it's still useful to teach.
• Aaargh20318 6mo ago
  I’m missing Curly’s Law: https://blog.codinghorror.com/curlys-law-do-one-thing/ https://blog.codinghorror.com/curlys-law-do-one-thing/ “A variable should mean one thing, and one thing only. It should not mean one thing in one circumstance, and carry a different value from a different domain some other time. It should not mean two things at once. It must not be both a floor polish and a dessert topping. It should mean One Thing, and should mean it all of the time.”
  • ipnon 6mo ago
    I usually invoke this by naming with POSIWID.
  • huflungdung 6mo ago
    [dead]
  • inetknght 6mo ago
    > It must not be both a floor polish and a dessert topping. I worked as a janitor for four years near a restaurant, so I know a little bit about floor polishing and dessert toppings. This law might be a little less universal than you think. There are plenty of people who would happily try out floor polish as a dessert topping if they're told it'll get them high.
    • rapnie 5mo ago
      Borax is an example of a substance that is simultaneously used for skin care, household cleaning, as soldiering flux, and ant killer. But I guess it is a constant with variable effects. Hard to be found in local shops anymore.
      • m463 5mo ago
        reminds me of WD-40 (water displacer formula 40). not used that often to displace water.
      • otterley 5mo ago
        Really? It's at practically every hardware store I've been to (US, things may be different elsewhere).
• duc_minh 6mo ago
  Is it just me seeing the following? Site not available This site was paused as it reached its usage limits. Please contact the site owner for more information.
  • rtrigoso 6mo ago
    not just you, I am getting the same error
• netdevphoenix 6mo ago
  "This site was paused as it reached its usage limits. Please contact the site owner for more information." I wish AWS/Azure had this functionality.
  • milanm081 6mo ago
    Fixed
• bpavuk 6mo ago
  > This site was paused as it reached its usage limits. Please contact the site owner for more information. ha, someone needs to email Netlify...
• bakkerinho 6mo ago
  > This site was paused as it reached its usage limits. Please contact the site owner for more information. Law 0: Fix infra.
  • andrerpena 6mo ago
    This looks like a static website that could be served for free from Cloudflare Pages or Vercel, with a nearly unlimited quota. And still... It's been hugged to death, which is ironic, considering it's a software engineering website :).
    • mghackerlady 6mo ago
      Hell, something like this probably doesn't even need that. Throw it on a debian box running nginx or apache and you'll probably be set (though, with how hard bots have been scraping recently it might be harder than that)
  • asdfasgasdgasdg 6mo ago
    Law 1: caching is 90-99% of performance.
    • arnorhs 6mo ago
      are you saying performance is 90-99% caching? If so that is so obviously untrue. If you are saying you _can_ fix 90-99% of performance bottlenecks eventually with caching, that may be true, but doesn't sound as nice
  • the_arun 6mo ago
    Laws are there to be broken.
  • esafak 6mo ago
    "Performance doesn't matter!"
  • hermaine 6mo ago
    Waybackmachine to the rescue :D https://web.archive.org/web/20260421113202/https://lawsofsoftwareengineering.com/ https://web.archive.org/web/20260421113202/https://lawsofsof...
• dgb23 6mo ago
  I like this collection. It's nicely presented and at least at a glance it adds some useful context to each item. While browsing it, I of course found one that I disagree with: Testing Pyramid: https://lawsofsoftwareengineering.com/laws/testing-pyramid/ https://lawsofsoftwareengineering.com/laws/testing-pyramid/ I think this is backwards. Another commenter WillAdams has mentioned A Philosophy of Software Design (which should really be called A Set of Heuristics for Software Design) and one of the key concepts there are small (general) interfaces and deep implementations. A similar heuristic also comes up in Elements of Clojure (Zachary Tellman) as well, where he talks about "principled components and adaptive systems". The general idea: You should greatly care about the interfaces, where your stuff connects together and is used by others. The leverage of a component is inversely proportional to the size of that interface and proportional to the size of its implementation. I think the way that connects to testing is that architecturally granular tests (down the stack) is a bit like pouring molasses into the implementation, rather than focusing on what actually matters, which is what users care about: the interface. Now of course we as developers are the users of our own code, and we produce building blocks that we then use to compose entire programs. Having example tests for those building blocks is convenient and necessary to some degree. However, what I want to push back on is the implied idea of having to hack apart or keep apart pieces so we can test them with small tests (per method, function etc.) instead of taking the time to figure out what the surface areas should be and then testing those. If you need hyper granular tests while you're assembling pieces, then write them (or better: use a REPL if you can), but you don't need to keep them around once your code comes together and you start to design contracts and surface areas that can be used by you or others.
  • nazgul17 6mo ago
    I think the general wisdom in that scenario is to keep them around until they get in the way. Let them provide a bit of value until they start being a cost.
• arnorhs 6mo ago
  Since the site is down, you can use the archive.org link: https://web.archive.org/web/20260421113202/https://lawsofsoftwareengineering.com/ https://web.archive.org/web/20260421113202/https://lawsofsof...
  • milanm081 6mo ago
    Fixed
• andreygrehov 6mo ago
  `Copy as markdown` please.
• Waterluvian 6mo ago
  I think it would be cool to have these shown at random as my phone’s “screensaver”
• noduerme 6mo ago
  I'd like to propose a corollary to Gall's Law. Actually it's a self-proving tautology already contained with the term "lifecycle." Any system that lasts longer than a single lifecycle oscillates between (reducing to) simplicity and (adding) complexity. My bet is on the long arc of the universe trending toward complexity... but in spite of all this, I don't think all this complexity arises from a simple set of rules, and I don't think Gall's law holds true. The further we look at the rule-set for the universe, the less it appears to be reducible to three or four predictable mechanics.
  • jt2190 5mo ago
    I think this site doesn’t capture Gall’s Law correctly, and your observations are closer to the original. Gall notes that the universe naturally trends toward complexity and unintended consequences and therefore complex designs should be assumed to already be full of these unintended consequence “bugs”. He proposes that systems should be designed: - with less scope to reduce unintended consequences, - with less rigidity to allow for workarounds when unintended consequences arise, and - to take advantage of “momentum” to reduce the required energy to use the system correctly. In other words make the right thing the easy thing, remembering that the easiest thing to do is nothing, thus systems will halt if operators get too busy with other tasks.)
• JensRantil 5mo ago
  There is also https://hacker-laws.com https://hacker-laws.com.
• herodotus 5mo ago
  Knuth's Optimization Principle: The computer scientist Rod Burstall had a pithy way of saying this: "Efficiency is the enemy of clarity"
• ebonnafoux 5mo ago
  There is a small typos in The Ninety-Ninety Rule > The first 90% of the code accounts for the first 90% of development time; the remaining 10% accounts for the other 90%. It should be 90% code - 10% time / 10% code - 90% time
  • Edman274 5mo ago
    It sounds like you are unfamiliar with the idea that software engineering efforts can be underestimated at the outset. The humorous observation here is that the total is 180 percent, which mean that it took longer than expected, which is very common.
    • ebonnafoux 5mo ago
      Oh OK, that is something I learn today.
• cogman10 5mo ago
  Uhh, I knew I wasn't going to like this one when I read it. > Premature Optimization (Knuth's Optimization Principle) > Another example is prematurely choosing a complex data structure for theoretical efficiency (say, a custom tree for log(N) lookups) when the simpler approach (like a linear search) would have been acceptable for the data sizes involved. This example is the exact example I'd choose where people wrongly and almost obstinately apply the "premature optimization" principles. I'm not saying that you should write a custom hash table whenever you need to search. However, I am saying that there's a 99% chance your language has an inbuilt and standard datastructure in it's standard library for doing hash table lookups. The code to use that datastructure vs using an array is nearly identical and not the least bit hard to read or understand. And the reason you should just do the optimization is because when I've had to fix performance problems, it's almost always been because people put in nested linear searches turning what could have been O(n) into O(n^3). But further, when Knuth was talking about actual premature optimization, he was not talking about algorithmic complexity. In fact, that would have been exactly the sort of thing he wrapped into "good design". When knuth wrote about not doing premature optimizations, he was living in an era where compilers were incredibly dumb. A premature optimization would be, for example, hand unrolling a loop to avoid a branch instruction. Or hand inlining functions to avoid method call overhead. That does make code more nasty and harder to deal with. That is to say, the specific optimizations knuth was talking about are the optimizations compilers today do by default. I really hate that people have taken this to mean "Never consider algorithmic complexity". It's a big reason so much software is so slow and kludgy.
  • bigfishrunning 5mo ago
    Yeah, for every Knuth there are 10000 copies of schlemiel the painter
  • krust 5mo ago
    > Another example is prematurely choosing a complex data structure for theoretical efficiency (say, a custom tree for log(N) lookups) when the simpler approach (like a linear search) would have been acceptable for the data sizes involved. To be fair, a linear search through an array is, most of the time, faster than a hash table for sufficiently small data sizes.
• macintux 5mo ago
  Some similarly-titled (but less tidily-presented) posts that have appeared on HN in the past, none of which generated any discussion: * https://martynassubonis.substack.com/p/5-empirical-laws-of-software-engineering https://martynassubonis.substack.com/p/5-empirical-laws-of-s... * https://newsletter.manager.dev/p/the-unwritten-laws-of-software-engineering https://newsletter.manager.dev/p/the-unwritten-laws-of-softw..., which linked to: * https://newsletter.manager.dev/p/the-13-software-engineering-laws https://newsletter.manager.dev/p/the-13-software-engineering...
• deleted 5mo ago
  [deleted]
• austin-cheney 5mo ago
  My own personal law is: When it comes to frameworks (any framework) any jargon not explicitly pointing to numbers always eventually reduces down to some highly personalized interpretation of easy. It is more impactful than it sounds because it implicitly points to the distinction of ultimate goal: the selfish developer or the product they are developing. It is also important to point out that before software frameworks were a thing the term framework just identifies a defined set of overlapping abstract business principles to achieve a desired state. Software frameworks, on the other hand, provide a library to determine a design convention rather than the desired operating state.
  • nashashmi 5mo ago
    Yii frameworks were full of that jargon. I had a hard time learning the whole mvc concept
• superxpro12 5mo ago
  The wadsworth constant is missing :| https://www.reddit.com/r/reddit.com/comments/kxtzp/and_so_the_wadsworth_constant_was_born/ https://www.reddit.com/r/reddit.com/comments/kxtzp/and_so_th...
  • compiler-guy 5mo ago
    As true and amusing as the wadsworth constant is, it has very little to do with software engineering.
• Kinrany 5mo ago
  SOLID being included immediately makes me have zero expectation of the list being curated by someone with good taste.
  • detectivestory 5mo ago
    I'm seeing some hate for SOLID in these comments and I am a little surprised. While I don't think it should ever be used religiously, I would much rather work on a team that understood the principles than one that didn't.
    • causal 5mo ago
      I think it's probably pointing toward the general harm that thinking only in objects has done to programming as a practice
    • AtNightWeCode 5mo ago
      I think the baseline is that code can be trash and still comply with SOLID. Therefor people get frustrated over it. Getting PR:s rejected and so on. I think it is better to have real requirements like: The code needs to be testable in a simple way.
  • heap_perms 5mo ago
    That's interesting, what makes you think that? Not long ago, I was working on my degree in Computer Science (Software Engineering), and we were heavily drilled on this principle. Even then, I found it amusing how all the professors were huge fanboys of SOLID. It was very dogmatic.
    • zelphirkalt 5mo ago
      Professors ... They are likely knowledgeable about the abstract things in computer science, but when it comes to actually writing code and guidance on that, I would only trust the ones, that have a background of getting deep into the code and actually making things. For example when I was studying I experienced a variety of professors: One who was a Python core developer and who knew many languages and could "compile in his head" what the result of some code will be in assembly. I would trust this one. One, who criticized my C code for having multiple procedures, because that would make it look after more pointers and told me it would be better all in one long procedure, lol, without ever even considering the readability. That one was likely also simply wrong because of the compiler probably inlining things anyway. That one taught a math lecture and used C. Needless to say I wouldn't trust that one when it comes to writing good code. Then I had a math physics guy, who wrote Java 5 or earlier code when it was Java 8 times. That one didn't use generics at all, and cast to Object instead and whatever else. He also explained, that he uses bit shift in a for loop variable update, because that was faster than *2. Yeah, also wouldn't trust that one to give any advice on how to write good code. It taught me to be very skeptical of mathematicians writing code, unless they have a proven track record of software development skills. This kind of person is the reason why mathematicians and physicists should be supported by an actual software developer, to write their code, and not be too ignorant or arrogant to consider hiring one. I also had one professor, who taught a math lecture in such a bad way, that it was hard to follow and even his writing on the blackboard was illegible. That one also had another lecture which was mostly talk about Internet and web concepts in one of the most grating accents imaginable, almost comical. I wouldn't trust that one to give advice on writing good code.
• GuB-42 5mo ago
  > Premature optimization is the root of all evil. There are few principle of software engineering that I hate more than this one, though SOLID is close. It is important to understand that it is from a 1974 paper, computing was very different back then, and so was the idea of optimization. Back then, optimizing meant writing assembly code and counting cycles. It is still done today in very specific applications, but today, performance is mostly about architectural choices, and it has to be given consideration right from the start. In 1974, these architectural choices weren't choices, the hardware didn't let you do it differently. Focusing on the "critical 3%" (which imply profiling) is still good advice, but it will mostly help you fix "performance bugs", like an accidentally quadratic algorithms, stuff that is done in loop but doesn't need to be, etc... But once you have dealt with this problem, that's when you notice that you spend 90% of the time in abstractions and it is too late to change it now, so you add caching, parallelism, etc... making your code more complicated and still slower than if you thought about performance at the start. Today, late optimization is just as bad as premature optimization, if not more so.
  • firemelt 5mo ago
    lol I never seen it that way its my favorit quotes premature optimization nowadays looks like choosing microservice when monolith can works just fine
  • tananaev 5mo ago
    With modern tools it should be pretty easy to build scalable solutions. I take premature optimization as going out of your way to optimize something that's already reasonable. Not that you should write really bad code as a starting point.
    • Sammi 5mo ago
      The problem is that that this term gets misused to say the opposite of what it was intended for. It's particularly the kind of people who like to say "hur hur don't prematurely optimize" that don't bother writing decent software to begin with and use the term as an excuse to write poor performing code. Instead of optimizing their code, these people end up making excuses so they can pessimize it instead.
• jdw64 5mo ago
  [dead]
• sigma5 5mo ago
  I would add also Little's law for throughput calculation https://en.wikipedia.org/wiki/Little%27s_law https://en.wikipedia.org/wiki/Little%27s_law
  • renticulous 5mo ago
    Linus's Law : "Given enough eyeballs, all bugs are shallow". Applies to opensource. But it also means that code reviews are a good thing. Seniors can guide juniors to coax them to write better code.
• meken 5mo ago
  I love Kernighan’s Law: > "Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it"
  • zelphirkalt 5mo ago
    Hm, I find this one to be very dubious. When you make an effort to write correct code, you think hard. When you debug, it's more like just looking at the execution of what you have thought of before and thinking "OK where did I go wrong this time? Show me in the process." and it is usually much easier to see why something is wrong or at least at which step it breaks.
• lenerdenator 5mo ago
  "No matter how adept and talented you are at your craft with respect to both technical and business matters, people involved in finance will think they know better." That one's free.
• davery22 5mo ago
  A few extra from my own notes- - Shirky Principle: Institutions will try to preserve the problem to which they are the solution - Chesterton's Fence: Changes should not be made until the reasoning behind the current state of affairs is understood - Rule of Three: Refactoring given only two instances of similar code risks selecting a poor abstraction that becomes harder to maintain than the initial duplication
• 0xbadcafebee 5mo ago
  A law of physics is inviolable.... A law of software engineering is a hot take. Here's another law: the law of Vibe Engineering. Whatever you feel like, as long as you vibe with it, is software engineering.
• rapatel0 5mo ago
  The list is great but the explanation are clearly AI slop. "Before SpaceX, launching rockets was costly because industry practice used expensive materials and discarded rockets after one use. Elon Musk applied first-principles thinking: What is a rocket made of? Mainly aluminum, titanium, copper, and carbon fiber. Raw material costs were a fraction of finished rocket prices. From that insight, SpaceX decided to build rockets from scratch and make them reusable." Everything including humans are made of cheap materials but that doesn't convey the value. The AI got close to the answer with it's first sentence (re-usability) but it clearly missed the mark.
• ChrisMarshallNY 5mo ago
  Great stuff! Where's Chesterton's Fence? https://en.wiktionary.org/wiki/Chesterton%27s_fence https://en.wiktionary.org/wiki/Chesterton%27s_fence [EDIT: Ninja'd a couple of times. +1 for Shirky's principle]
• smikhanov 5mo ago
  Oh dear, not again: https://lawsofsoftwareengineering.com/laws/brooks-law/ https://lawsofsoftwareengineering.com/laws/brooks-law/ This one belongs to history books, not to the list of contemporary best practices.
• lqstuart 5mo ago
  What do you call the law that you violate when you vibe code an entire website for "List of 'laws' of software engineering" instead of just creating a Wikipedia page for it
  • tjohnell 5mo ago
    Slop’s Law If it can be slopped, it will be slopped.
  • Bratmon 5mo ago
    "Creating a Wikipedia page" is a weird suggestion. In 2026, it's actually not possible to create a Wikipedia page unless you're already a deep expert in Wikipedia culture. (Wikipedia nerds often say "No, anyone can create a page as long as they follow the 137 guidelines!" This is a prank- Wikipedia admins will delete your article no matter how many guidelines it follows)
    • zelphirkalt 5mo ago
      Even some 15y ago it was impossible to add web links to communities, even though other web links to similar communities were already in the web links section, because some people weaponized wiki as a moat.
  • niccl 5mo ago
    Sturgeon's Law (2026): 99% of everything is crap or slop
• biscuits1 5mo ago
  Today, I was presented with Claude's decision to include numerous goto statements in a new implementation. I thought deeply about their manual removal; years of software laws went against what I saw. But then, I realized it wouldn't matter anymore. Then I committed the code and let the second AI review it. It too had no problem with goto's. Claude's Law: The code that is written by the agent is the most correct way to write it.
  • voiceofunreason 5mo ago
    Render therefore unto Caesar the things which are Caesar's; and unto Claude the things that are Claude's.
    • biscuits1 5mo ago
      And so, it is written: https://dev.to/solidi/claudes-law-1da7 https://dev.to/solidi/claudes-law-1da7
• pkasting 5mo ago
  This list is missing my personal law, Kasting's Law: Asking "who wrote this stupid code?" will retroactively travel back in time and cause it to have been you.
  • omoikane 5mo ago
    "I'm casting around in my head for someone to blame, and it's just... me, keeps coming back at me." - Jeremy Clarkson (Top Gear, series 14 episode 5)
    • pkasting 5mo ago
      (Tangent: What a pleasure to see your username again; will always think of your readability help fondly!)
      • omoikane 5mo ago
        Great to see you too, it has been a pleasure working with you :)
• cientifico 5mo ago
  There is one missing that i am using as primary for the last 5 years. The UX pyramid but applied to DX. It basically states that you should not focus in making something significant enjoyable or convenient if you don't have something that is usable, reliable or remotely functional. https://www.google.com/search?q=ux+pyramid https://www.google.com/search?q=ux+pyramid
• Lapsa 5mo ago
  reminder - there's tech out there capable of reading your mind remotely
• pcblues 5mo ago
  In the 25 odd years I developed software, I learnt all the rules the hard way. Relax. You will make all the mistakes because the laws don't make sense until you trip over them :) Comment your code? Yep. Helped me ten years later working on the same codebase. You can't read a book about best practises and then apply them as if wisdom is something you can be told :) It is like telling kids, "If you do this you will hurt yourself" YMMV but it won't :)
• hatsix 5mo ago
  I know it's not software-engineering-only, but Chesterton's Fence is often the first 'law' I teach interns and new hires: https://fs.blog/chestertons-fence/ https://fs.blog/chestertons-fence/
  • computerdork 5mo ago
    This is one of my biggest principles too, "think before you do."
  • ericmcer 5mo ago
    They have "Law of Unintended Consequences" on this list which describes the same phenomena. I always liked the fence story better though.
  • sltr 5mo ago
    the corollary of Chesterton's Fence is also valuable: don't go putting up unnecessary fences, because others won't be able to take them down
  • jrmiii 5mo ago
    Found your comment by searching to see if anyone mentioned it. Really key in legacy systems.
• deaux 5mo ago
  Laws of Software Engineering (2026 Update) - Every website will be vibecoded using Claude Opus This will result in the following: - The background color will be a shade of cream, to properly represent Anthropic - There will be excessive use of different fonts and weights on the same page, as if a freshman design student who just learned about typography - There will be an excess of cards in different styles, a noteworthy amount of which has a colored, round border either on hover or by default on exactly one side of the card
  • dabedee 5mo ago
    - The domain will be a long title with a dot com at the end.
  • shimman 5mo ago
    Yeah, the dude vibe coding the site also likely vibe coded the book. Instant pass. Also looking up this person's coding history (mostly cheat sheets and road maps), zero confidence that anything is worthy of note in the book.
  • ai_fry_ur_brain 5mo ago
    If I think you vibe coded your website im not using your product, reading your blog and will bad mouth you at every opportunity.
    • komi013 5mo ago
      user name checks out
• yesitcan 5mo ago
  None of these things matter anymore. All you need is vibe.
  • serious_angel 5mo ago
    Sorry, sometimes, I do wish Hacker News would have a down-vote button...
    • datadrivenangel 5mo ago
      Come back after 500 karma.
  • Divergence42 5mo ago
    Looks a lot different in a 1 person agent based company.
• hintymad 5mo ago
  With the current AI wave, a fun question to ask is: which of these laws do people think no longer apply.
• exiguus 5mo ago
  This website should be a json file
  • serious_angel 5mo ago
    Have you checked out?: https://lawsofsoftwareengineering.com/api.json https://lawsofsoftwareengineering.com/api.json
    • exiguus 5mo ago
      Love it :)
• samuelknight 5mo ago
  I like the website. Simple and snappy.
• computerdork 5mo ago
  Don't see a really important one in my opinion: Refactor legacy code, don't rewrite it. All that cruft you see are bug fixes. Because rewriting old complex code is way more time consuming that you think it'll be. You have to add not only in the same features, but all the corner cases that your system ran into in the past. Have seen this myself. A large team spent an entire year of wasted effort on a clean rewrite of an key system (shopping cart at a high-volume website) that never worked... ...although, in the age of AI, wonder if a rewrite would be easier than in the past. Still, guessing even then, it'd be better if the AI refactored it first as a basis for reworking the code, as opposed to the AI doing a clean rewrite of code from the start.
  • namenotrequired 5mo ago
    The “second system effect” page more or less covers this
    • computerdork 5mo ago
      Ah, think there is overlap, but still not the same in my opinion. Having read this just now, the second system effect seems to be more about not getting overly ambitious in the redesign. What the guideline I mentioned is saying is "don't rewrite, refactor."" As you probably know, there is a tendency when new developers join a team to hate the old legacy code - one of the toughest skills is being able to read someone else's code - so they ask their managers to throw it away and rewrite it. This is rarely worth it and often results in a lot of time being spent recreating fixes for old bugs and corner cases. Much better use of time to try refactoring the existing code first. Although, can see why you mentioned it from the initial example that I gave (on that rewrite of the shopping cart) which is also covered by the "second system effect." Yeah, thinking back, have seen this too. Overdesign can get really out of hand and becomes really annoying to wade through all that unnecessary complexity whenever you need to make a change.
• jaggederest 5mo ago
  TANSTAAFL was always one of my favorites - there ain't no such thing as a free lunch
• deleted 5mo ago
  [deleted]
• garff 5mo ago
  Mad AI slop..
• regular_trash 5mo ago
  Hot take - I hate YAGNI. My personal pet peeve is when someone says YAGNI to a structure in the code they perceive as "more complex than they would have done it". Sure, don't add hooks for things you don't immediately need. But if you are reasonably sure a feature is going to be required at some point, it doesn't hurt to organize and structure your code in a way that makes those hooks easy to add later on. Worst case scenario, you are wrong and have to refactor significantly to accommodate some other feature you didn't envision. But odds are you have to do that anyway if you abide by YAGNI as dogma. The amount of times I've heard YAGNI as reasoning to not modularize code is insane. There needs to be a law that well-intentioned developers will constantly misuse and misunderstand the ideas behind these heuristics in surprising ways.
  • AtNightWeCode 5mo ago
    It is misused if anything. YAGNI is about functionality. What to add or not. But it has become an excuse for being lazy. Same people that interpreted the line “Working software over comprehensive documentation” as no need for documentation.
    • traderj0e 5mo ago
      YAGNI is usually about modularization, often in response to Java-style OOP obsession. Like you don't need to define some big protocol that's only ever going to have one implementation.
      • regular_trash 5mo ago
        Well this is not the context I had in mind. I'm thinking of the many times I've had to break apart 3kloc react components to reuse some part just because someone decided modularity didn't matter
        • traderj0e 5mo ago
          I mean YAGNI is usually about modularization in general, so yeah a React component would be included in that, it's not limited to just OOP. 3K loc is probably well beyond the point where it should've been split up.
• TheGRS 5mo ago
  You know, I mention this stuff all the time in various meetings and discussions. I read a lot of stuff on Hacker News and just have years of accumulated knowledge from the various colleagues I've worked with. Its nice to have a little reference sheet.
• blauditore 5mo ago
  Many of the "teams" laws are BS, especially the ones about promotions and management. I've never been a manager or high-level executive, but it's not that all of them are either non-technical or bad managers. It's just that the combination of both skills is rare.
• Divergence42 5mo ago
  fascinating and agree with many of the laws. In a 1 person agent only company this hits a bit different.
• asmodeuslucifer 5mo ago
  I learned about Dunbar’s number (~150) is the size of a community in which everyone knows each other’s identities and roles. In anthropology class. You can ask someone to write down the name of everyone they can think of, real or fictional, live or dead and most people will not make it to 250. Some individuals like professional gossip columnists or some politicians can remember as many as 1,000 people.
  • OkayPhysicist 5mo ago
    Dunbar's number is largely psuedoscience. Dunbar just took the group size of gorillas, scaled up to humans based on brain size, and then published, without bothering with silly little details like actually testing human group sizes.
• HoldOnAMinute 5mo ago
  I like it, but this could have been a tab delimited text file.
• lifeisstillgood 5mo ago
  Just throwing one of my favourites in: As JFK never said: “””We do these things, not because they are easy, But because we thought they would be easy”””
• kittikitti 5mo ago
  This is really good and comprehensive, thanks for sharing!
• eranation 5mo ago
  Good list. Missing for me - NIH - GIGO - Rule of 3
• contingencies 5mo ago
  Better list https://github.com/globalcitizen/taoup https://github.com/globalcitizen/taoup
• asdfman123 5mo ago
  > Leave the code better than you found it In most places, people don't follow this rule, as it ensures either you're working an extra 10-20 hours a week to keep things clean, or stuck at mid-level for not making enough impact. I choose the second option. But I see people who utterly trash the codebase get ahead.
• darccio 5mo ago
  I wonder if it's usual for other professions/fields to have this tendency to create laws/aphorisms so ingrained. I'm biased as software engineer but it seems to me that is more common in computer science than others.
• 4dregress 5mo ago
  I like to replace the bus factor with the Lottery Factor. I actually had a college run over by a bus on the way to work in London, was very lucky and made a full recovery. Head poking out under the main exit of the bus.
• bofia 5mo ago
  It would be nice to see what overlaps
• t43562 5mo ago
  The conservation of Complexity (Tesler) seems immediately insightful to me just as a sentence: "Every application has an inherent amount of irreducible complexity that can only be shifted, not eliminated." But then in the explanation seems to me to devolve down to a trite suggestion not to burden your users. This doesn't interest me because users need the level of complexity they need and no more whatever you're doing and making it less causes your application to be an unflexible toy. So this is all, to a degree, obvious. I think it's more useful to remember when you're refactoring that if you try to make one bit of a system simpler then you often just make another part more complex. Why write something twice to end up with it being just as bad the other way round?
• Steinmark 5mo ago
  [dead]
• alsetmusic 5mo ago
  Their statement of Dunning-Kruger is overly simplified such as to misdefine it: > The less you know about something, the more confident you tend to be. From the first line on the wiki article: > systematic tendency of people with low ability in a specific area to give overly positive assessments of this ability. Or, said another way, the more you know about something the more complexities you're aware of and the better assessment you can make about topics involving such. At least, that's how I understand it in a nutshell without explaining the experiments run and the observations that led to the findings.
• toolslive 5mo ago
  maybe add: "the universe is winning" (in the design department). Full quote: "software engineers try to build "idiot-proof" systems, while the universe creates "bigger and better idiots" to break them. So far, the universe is winning"
• ryanshrott 5mo ago
  People use the premature optimization principle in exactly the wrong way these days. Knuth's full quote is, "We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%." That 97%/3% split is the whole point. People bring it up to argue for never thinking about performance, which flips the intent on its head. The real takeaway is that you need to spot that critical 3% early enough to build around it, and that means doing some optimization thinking up front, not none at all.
• amelius 5mo ago
  No laws related to AI?
• xorcist 5mo ago
  It's strange to see many non-software related "laws" here, such as the Dilbert Principle, but not Internet cornerstones such as Godwin's Law.
• deleted 5mo ago
  [deleted]
• nopointttt 5mo ago
  The one I keep coming back to is "code you didn't write is code you can't debug." Every fancy dep I grabbed to save an afternoon ended up costing me weeks later when something upstream broke in some way I had no mental model for. LLM generated code has the same problem now. Looks fine until you hit a case it doesn't cover and you're trying to reverse engineer what you let it write.
• AtNightWeCode 5mo ago
  "Polishing a turd" is missing. Making something slightly better when it should be removed. Like running Flash apps in 2026.
• matt765 5mo ago
  I love this
• deleted 5mo ago
  [deleted]
• hunterpayne 5mo ago
  This is the best comment on this article but it was deleted for some reason. "The meta-law of software engineering: All laws of software engineering will be immediately misinterpreted and mindlessly applied in a way that would horrify their originators. Now that we can observe the behaviour of LLMs that are missing key context, we can understand why." Or, you can't boil down decades of wisdom and experience into a pithy, 1 sentence quote.
• traderj0e 5mo ago
  Any time someone quotes a law named after some random person, it looks like a stuffy "I know something you don't." Amdahl is probably the only name here that deserves it, and it's a real law. I'd be fine if Eric Brewer put his name on CAP too, also a real law. YAGNI and "you will ship the org chart" are the two most commonly useful things to remember, but they aren't laws.
• galaxyLogic 5mo ago
  The Law of Leaky Abstractions. What is a "leaky" abstraction? How does it "leak"? I wonder if it should be called "Law of Leaky Metaphors" instead. Metaphor is not the same thing as Abstraction. I can understand a "leaky metaphor" as something that does not quite make it, at least not in all aspects. But what would be a good EXAMPLE of a Leaky Abstraction?
• nextlsj 5mo ago
  [flagged]
• invalidSyntax 5mo ago
  I just wish if this was a requirement to get a job. Everyone needs to know this.
• quantum_state 5mo ago
  Unfortunately, violation of any of these laws don't seem to have immediate consequences. That's why the IT industry is in ruin.
• merge_software 5mo ago
  > YAGNI (You Aren't Gonna Need It) This one is listed as design, but it could just as easily count as architecture. Guessing a lot developers have worked on scaling with lambda functions or a complex IAC setup when a simple API running on a small VPS would have done the trick, at least until enough people are using the application for it to be considered profitable.
  • hinkley 5mo ago
    When we dockerized a service the p95 time in testing notched up a noticeable amount. I was already juggling so much other work at that point that for shits and giggles I tried vertically scaling - reducing the cluster size by half and the cores per server by 2x. Zeroed out the p95 delta. OPS gave me shit about it, and I was like kiss my ass, the cluster costs EXACTLY the same and deployments are 25% faster. I think people forget that in the cloud, bigger servers don't really cost more until you get crazy about it.
• hpincket 5mo ago
  Time to mention my tongue-in-cheek law: > When describing phenomena in the social world > Software Engineers gravitate towards eponymous 'laws'. https://pincketslaw.com/ https://pincketslaw.com/
• EverMemory 5mo ago
  [dead]
• sunkeeh 5mo ago
  Good luck following the Dilbert Principle xD Just because some things were observed frequently during a certain period, doesn't mean it's a "Law" or even a "Principle"; it's merely a trend.
• emmelaich 5mo ago
  Not sure that Linus would actually agree with Linus' law. So it's a bad name. Call it the ESR observation or something else. Separately, I'd add Rust's API design principles, though it's more of a adjunct with things in common. https://gist.github.com/mjball/9cd028ac793ae8b351df1379f1e721f9 https://gist.github.com/mjball/9cd028ac793ae8b351df1379f1e72...
• 0xpgm 5mo ago
  An extension to Zawinski's Law, every web service attempts to expand until it becomes a social network.
  • bogomog 5mo ago
    A modernization, really.
• mchl-mumo 5mo ago
  I find myself guilty of giving over ambitious timelines even when I try to take that into account.
• clauderx 5mo ago
  Ah yes my favorite - Conway's Law is just a fancy way of saying "your architecture is whatever your political mess of a org chart accidentally produced, and everyone calls it 'design' afterward to avoid fixing it."
• satansdeer 5mo ago
  It's proverbs, not laws
• satansdeer 5mo ago
  It's proverbs, not laws Most of them are also wrong
• voidifremoved 5mo ago
  Nice site, but missing the Law of Conservation of Misery.
• kwar13 5mo ago
  Half of these are not about software engineering and just general management principles.
• g051051 5mo ago
  > When I first started, I was enamored with technology and programming and computer science. I’m over it. Wow, that is incredibly sad to hear. I'm 40+ years in, and still love all of that.
• sreitshamer 5mo ago
  My favorite is "Software development isn't a code production activity, it's a knowledge acquisition activity."
• fomosocial 5mo ago
  Been in Software Engineering for over 2 years now and I'm only hearing most of these named laws for the first time. Am I cooked?
• yodsanklai 5mo ago
  Many of these laws are trade-offs to be assessed on a case by case basis. Everybody has a different subjective view and you need to be willing to compromise otherwise you'll be very sad working with other people.
• milanm081 5mo ago
  Thank you all for the valuable feedback! I'll review each comment and improve what I can on the website.
• CGMthrowaway 5mo ago
  This website seems heavily inspired by https://lawsofux.com/ https://lawsofux.com/
• brendaninnis 5mo ago
  The Dunning-Kruger Effect card is so bad here. The effect is not that your perceived ability is higher the less skilled you are, but that the gap between your actual ability and perceived ability is larger the less skilled you are (and becomes negative when highly skilled). This is so commonly misstated this way that I think most people have this misunderstanding. Also they used the graph for the Gartner Hype Cycle as the icon, not the Dunning-Kruger graph.
• darthwalsh 5mo ago
  I couldn't find the source on GitHub, but somebody has helpfully scraped them a few hours ago: https://github.com/pascalandy/dotfiles/blob/main/docs/references/ideas/references/2026-04-23-software-engineering-laws/md_pages/TOC.md https://github.com/pascalandy/dotfiles/blob/main/docs/refere...
• Lawsofpm 5mo ago
  [dead]
• theRealEros 5mo ago
  Check this out! https://github.com/theElandor/lose_law https://github.com/theElandor/lose_law
• timkofu 5mo ago
  How is this different from SWEBOK? https://www.computer.org/education/bodies-of-knowledge/software-engineering https://www.computer.org/education/bodies-of-knowledge/softw...