Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

  • Hacker News
  • Do people actually believe these dot points or are they just out of scope for most applications to tackle beyond letting the user try again?
  • I have had a developer with anger issues expect 100% success with FTP file transfers, and anything that failed was 100% my fault as a Linux/Oracle administrator.

    These FTP sessions were running over WANs connecting Pennsylvania, Iowa, and Tennessee.

    I ended up writing him an "until curl ftp://...; do echo it failed again; done" loop which calmed that particular issue down.

    I don't miss that guy, not even 1%. Good riddance.

  • Perfect demonstration of the fallacies in action! If you were used to developing applications on a self contained platform you would think something like “sure, if it fails the user can try again”

    On a distributed system the user can only try again if the platform has remained stable, the failure is transient (*) and they have (crucially) have been given the information to retry.

    The platform that provides a stable environment for the user to just try again has been built on these principles.

    (*) there is one administrator assumes it is within the user’s power to resolve the issue

    by rusk
  • When I worked with high end networking equipment latency, bandwidth, jitter and bursty traffic was just a never ending conversation…
  • There needs to be a distinction - because people are making an honest conflation - between distributed computing and cloud computing. The list in the article applies to both, but the limits and performance variability can apply quicker - and with more effect - in the cloud.
  • This is highly relevant to the recent craze over microservices, which has settled down now (after un-neccasarily complicating systems at multiple companies).
  • Micoserices or Monolith. It’s like being caught between the devil and the deep blue see. It’s a pity domain sockets never took off but I guess TCP/IP is the only truly cross platform IPC mechanism …
    by rusk
  • On the one hand, the list isn't wrong.

    On the other hand, more fortunes have been made by assuming that physics will catch up (closely enough, anyway) to computational needs, than by assuming that every byte and every cycle and every nanosecond matters.

  • That's like saying money is only spent on sw/hw systems which rely on ever-growing compute capacity.

    Reality: embedded systems are a thing. And there's (lots of!) money in that business too. There's maaaany applications where some (fixed) amount of compute does the job, and the simplest/cheapest device that does it wins out.

  • Making money and being highly available are different goals.
  • In 2026 Moore's law has mostly stopped. My computer from 10 years ago still has acceptable performance today. My computer from 15 years ago would struggle a bit but still get the job done. This is nothing like the 90s where you actually could wait two years for all of that year's conceivable performance problems to be solved.
  • In this instance latency must’ve been 10 years, per my memory this paper came out in 1994
  • According to Wikipedia it was first shown to Scott McNeally, but according to Deutsch himself it was more like 92…
    by rusk
  • This article reiterates a lot of the Wikipedia stuff, while contradicting the main extant source which is Deutsch himself (https://se-radio.net/2021/07/episode-470-l-peter-deutsch-on-...). Nobody really knows who wrote the first four fallacies. They were just floating around it is Deutsch who pinned them down and it was Gosling’s endorsement that made them into the shibboleth that they are.
    by rusk
  • Deutsch speculated it was "either Bill or Dick Lyon" (sic) (https://web.archive.org/web/20040203202935/http://www.aladdi...) but there has been speculation he meant Tom Lyon, who worked there at the time. Gosling had them hosted on his website for a long time (https://web.archive.org/web/20021206065457/http://java.sun.c...)
  • Also, the four fallacies of local computing:

    - The CPU is infinitely fast.

    - RAM is infinite.

    - CPU caches don't exist.

    - Cache lines don't exist.

  • Disk never gets filled up.
  • It's more niche but also underestimating the impact of using SIMD in places where it makes sense. Especially in higher level, interpreted programming languages where the overhead for each iteration is much larger than the few assembly instructions it would take to perform that iteration without vectorization in a low level language.
  • Today even tiny CPUs are really fast. Locally you have to mess up badly to run into trouble. But of course people will do exactly that...

    Most real world problems still can be solved with 32-bit software, so the last ~20 years running out of RAM always counted as "using defective hardware". AI workloads now make things interesting again, but it's not that easy to hit the ceiling with real world workload.

    Cache is indeed very important. Optimisations like that are gone when you go for distributed computing. Sometimes adding a single nop can do wonders. I wonder how many percent of developers have something in their toolbox to profile for that.

  • - The computer is plugged to an infinite source of unlimited power

    This was big before the mobile era and is true to this day to an extent. Many mainstream languages created in the 1990s (I call them "the children of the 1990s") were designed with this fallacy plus the ones you listed as a basis: JavaScript, Python, Ruby, Java, etc.

  • A couple more that don't seem to be represented there. No mention of cause and effect, or the order in which different nodes perceive things happening? Anyway here's three which I think might be more relevant to designing and building software:

    * Your system is not a distributed system

    Multiple users connect, disconnect, and use your system at the same time, some of the code is running on your servers, some of it's in your partners' servers, some of it's in your storage layer, and some of it's running on your users' computers

    * Your DB's ACID transactions are sufficient for distributed thinking

    An ACID transaction lets you addUser() to your storage, either succeeding completely or failing completely, with no observable intermediate state. It does not let both your frontend and your storage layer addUser(), same with both your storage and your partner's storage.

    * Your DB's transactions are ACID

    Your DB vendors cannot build databases that are acceptably fast while running ACID. Therefore isolation is relaxed and transactions can commit through each other. Even if the DB itself was ACID, your ORM and/or programming style is likely breaking ACID independently of the DB configuration.

  • * You will have logs

    Always gets me

  • > No mention of cause and effect, or the order in which different nodes perceive things happening?

    8. The network is homogeneous

    Often misconstrued as a recapitulation of “there is one administrator”

    A homogenous system, such as a single node Java application, for instance usually provides very clear semantics for this.

    by rusk
  • Another one from my experience:

    * Hardware is cheap.

    So many services and daemons are running on your system and most of them believe that they have all the hardware for themselves, while the opposite is true. Designing to capitalize whole hardware while they are other processes which are fighting to do the same never ends well.

    OTOH, being a good citizen on a crowded system makes life for everyone better. Both maintenance and performance-wise.