TE
TechEcho
Home24h TopNewestBestAskShowJobs
GitHubTwitter
Home

TechEcho

A tech news platform built with Next.js, providing global tech news and discussions.

GitHubTwitter

Home

HomeNewestBestAskShowJobs

Resources

HackerNews APIOriginal HackerNewsNext.js

© 2025 TechEcho. All rights reserved.

Distributed systems programming has stalled

287 pointsby shadaj3 months ago

36 comments

bsnnkv3 months ago
Last month I switched from a role working on a distributed system (FAANG) to a role working on embedded software which runs on cards in data center racks.<p>I was in my last role for a year, and 90%+ of my time was spent investigating things that went &quot;missing&quot; at one of many failure points between one of the many distributed components.<p>I wrote less than 200 lines of code that year and I experienced the highest level of burnout in my professional career.<p>The technical aspect that contributed the most to this burnout was both the lack of observability tooling and the lack of organizational desire to invest in it. Whenever I would bring up this gap I would be told that we can&#x27;t spend time&#x2F;money and wait for people to create &quot;magic tools&quot;.<p>So far the culture in my new embedded (Rust, fwiw) position is the complete opposite. If you&#x27;re burnt out working on distributed systems and you care about some of the same things that I do, it&#x27;s worth giving embedded software dev a shot.
评论 #43196899 未加载
评论 #43196122 未加载
评论 #43197177 未加载
评论 #43200186 未加载
评论 #43196910 未加载
评论 #43205115 未加载
评论 #43200890 未加载
评论 #43196163 未加载
评论 #43196239 未加载
评论 #43196180 未加载
评论 #43202090 未加载
评论 #43199980 未加载
评论 #43197902 未加载
评论 #43198895 未加载
评论 #43200596 未加载
评论 #43208643 未加载
评论 #43199589 未加载
评论 #43202165 未加载
评论 #43200725 未加载
评论 #43196674 未加载
评论 #43199169 未加载
评论 #43199688 未加载
评论 #43196159 未加载
评论 #43196931 未加载
gklitt3 months ago
This is outside my area of expertise, but the post sounds like it’s asking for “choreographic programming”, where you can write an algorithm in a single function while reasoning explicitly about how it gets distributed:<p><a href="https:&#x2F;&#x2F;en.m.wikipedia.org&#x2F;wiki&#x2F;Choreographic_programming" rel="nofollow">https:&#x2F;&#x2F;en.m.wikipedia.org&#x2F;wiki&#x2F;Choreographic_programming</a><p>I’m curious to what extent the work in that area meets the need.
评论 #43196643 未加载
评论 #43202190 未加载
rectang3 months ago
Ten years ago, I had lunch with Patricia Shanahan, who worked for Sun on multi-core CPUs several decades ago (before taking a post-career turn volunteering at the ASF which is where I met her). There was a striking similarity between the problems that Sun had been concerned with back then and the problems of the distributed systems that power so much the world today.<p>Some time has passed since then — and yet, most people still develop software using sequential programming models, thinking about concurrency occasionally.<p>It is a durable paradigm. There has been no revolution of the sort that the author of this post yearns for. If &quot;Distributed Systems Programming Has Stalled&quot;, it stalled a long time ago, and perhaps for good reasons.
评论 #43196377 未加载
评论 #43196635 未加载
评论 #43197661 未加载
评论 #43197344 未加载
评论 #43196213 未加载
hinkley3 months ago
I don’t think there’s anyone in the Elixir community who wouldn’t love it if companies would figure out that everyone is writing software that contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Erlang, and start hiring Elixir or Gleam devs.<p>The future is here, but it is not evenly distributed.
评论 #43197396 未加载
评论 #43207679 未加载
评论 #43197702 未加载
评论 #43197600 未加载
评论 #43197011 未加载
评论 #43200061 未加载
bigmutant3 months ago
Good resources for understanding Distributed Systems:<p>- MIT course with Robert Morris (of Morris Worm fame): <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=cQP8WApzIQQ&amp;list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=cQP8WApzIQQ&amp;list=PLrw6a1wE39...</a><p>- Martin Kleppmann (author of DDIA): <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=UEAMfLPZZhE&amp;list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=UEAMfLPZZhE&amp;list=PLeKd45zvjc...</a><p>If you can work through the above (and DDIA), you&#x27;ll have a solid understanding of the issues in Distributed System, like Consensus, Causality, Split Brain, etc. You&#x27;ll also gain a critical eye of Cloud Services and be able to articulate their drawbacks (ex: did you know that replication to DynamoDB Secondary Indexes is eventually consistent? What effects can that have on your applications?)
评论 #43197425 未加载
dingnuts3 months ago
&gt;The static-location model seems like the right place to start, since it is at least capable of expressing all the types of distributed systems we might want to implement, even if the programming model offers us little help in reasoning about the distribution. We were missing two things that the arbitrary-location model offered:<p>&gt; Writing logic that spans several machines right next to each other, in a single function<p>&gt; Surfacing semantic information on distributed behavior such as message reordering, retries, and serialization formats across network boundaries<p>Aren&#x27;t these features offered by Erlang?
评论 #43196290 未加载
评论 #43197389 未加载
评论 #43196275 未加载
评论 #43196826 未加载
tracnar3 months ago
The unison programming language does foray into a truly distributed programming language: <a href="https:&#x2F;&#x2F;www.unison-lang.org&#x2F;" rel="nofollow">https:&#x2F;&#x2F;www.unison-lang.org&#x2F;</a>
评论 #43197020 未加载
KaiserPro3 months ago
Distributed systems are hard, as well all know.<p>However the number of people that actually need a distributed system is pretty small. With the rise of kubernetes, the number of people who&#x27;ve not been burnt by going distributed when they didn&#x27;t need to has rapidly dropped.<p>You go distributed either because you are desperate, or because you think it would be fun. K8s takes the fun out of most things.<p>Moreover, with machines suddenly getting vast IO improvements, the need for going distributed is much less than it was 10 years. (yes i know there is fault tolerance, but that adds another dimension of pain.)
评论 #43197498 未加载
评论 #43200311 未加载
margorczynski3 months ago
Distributed systems are cool but most people don&#x27;t really get how much complexity it introduces which leads them to fad-driven decisions like using Event Sourcing where there is no fundamental need to use it. I&#x27;ve seen projects getting burned because of the complexity and overhead it introduces where &quot;simpler&quot; approaches worked well and were easy to extend&#x2F;fix. Hard to find and fix bugs, much slower feature addition and lots of more goodies the blogs with toy examples don&#x27;t speak about.
评论 #43196997 未加载
评论 #43197027 未加载
评论 #43204750 未加载
sanity3 months ago
The article makes great points about why distributed programming has stalled, but I think there&#x27;s still room for innovation—especially in how we handle state consistency in decentralized systems.<p>In Freenet[1], we’ve been exploring a novel approach to consistency that avoids the usual trade-offs between strong consistency and availability. Instead of treating state as a single evolving object, we model updates as summarizable deltas—each a commutative monoid—allowing peers to merge state independently in any order while achieving eventual consistency.<p>This eliminates the need for heavyweight consensus protocols while still ensuring nodes converge on a consistent view of the data. More details here: <a href="https:&#x2F;&#x2F;freenet.org&#x2F;news&#x2F;summary-delta-sync&#x2F;" rel="nofollow">https:&#x2F;&#x2F;freenet.org&#x2F;news&#x2F;summary-delta-sync&#x2F;</a><p>Would love to hear thoughts from others working on similar problems!<p>[1] <a href="https:&#x2F;&#x2F;freenet.org&#x2F;" rel="nofollow">https:&#x2F;&#x2F;freenet.org&#x2F;</a>
评论 #43197405 未加载
herval3 months ago
Throwing in my two cents on the LLM impact - I&#x27;ve been seeing an increasing number of systems where core part of the functionality is either LLMs or LLM-generated code (sometimes on the fly, sometimes cached for reuse). If you think distributed systems were difficult before, try to imagine a system where the code being executed _isn&#x27;t even debuggable or repeatable_.<p>It feels like we&#x27;re racing towards a level of complexity in software that&#x27;s just impossible for humans to grasp.
评论 #43196642 未加载
synergy203 months ago
I saw comments about embedded development, which I have been doing that for a long time, just want to make a point here: the pay has upper limits, you will be paid fine but will reach the pay limit very fast, and it will stay there for the rest of your career. they can swap someone in with that price tag to do whatever you are working on, because, after all, embedded devel is not rocket science.
评论 #43197662 未加载
sn93 months ago
It sounds like they&#x27;re looking for the Rust project Hydro [0].<p>EDIT: Lol nvm the author is one of the authors of Hydro [1].<p>[0] <a href="https:&#x2F;&#x2F;github.com&#x2F;hydro-project&#x2F;hydro">https:&#x2F;&#x2F;github.com&#x2F;hydro-project&#x2F;hydro</a><p>[1] <a href="https:&#x2F;&#x2F;hydro.run&#x2F;people" rel="nofollow">https:&#x2F;&#x2F;hydro.run&#x2F;people</a>
评论 #43200089 未加载
jderick3 months ago
Distributed systems are hard. I like the idea of &quot;semantic locality.&quot; I think it can be achieved to some degree via abstraction. The code that runs across many machines does a lot of stuff but only a small fraction of that is actually involved in coordination. If you can abstract away those details you should end up with a much simpler protocol that can be modeled in a succinct way. Then you can verify your protocol much more easily. Formal methods have used tools such as spin (promela) or guarded commands (murphi) for modeling these kinds of systems. I&#x27;m sure you could do something similar with the lean theorem prover. The tricky part is mapping back and forth between your abstract system and the real one. Perhaps LLMs could help here.<p>I work on hardware and concurrency is a constant problem even at that low level. We use model checking tools which can help.
MisterTea3 months ago
This has been an issue for quite some time. Rob Pike wrote about it going back - <a href="https:&#x2F;&#x2F;doc.cat-v.org&#x2F;bell_labs&#x2F;utah2000&#x2F;" rel="nofollow">https:&#x2F;&#x2F;doc.cat-v.org&#x2F;bell_labs&#x2F;utah2000&#x2F;</a>
cmrdporcupine3 months ago
Two things:<p>Distributed systems are difficult to reason about.<p>Computer hardware today is very powerful.<p>There is a yo-yo process in our industry over the last 50 years between centralization and distribution. We necessarily distribute when we hit the limits of what centralization can accomplish because in general centralization is easier to reason about.<p>When we hit those junctures, there&#x27;s a flush of effort into distributed systems. The last major example of this I can think of was the 2000-2010 period, when MapReduce, &quot;NoSQL&quot; databases, Google&#x27;s massive arrays of supposedly identical commodity grey boxes (not the case anymore), the High Scalability blog, etc. were the flavour of the time.<p>But then, frankly, mass adoption of SSDs, much more powerful computers, etc. made a lot of those things less necessary. The stuff that <i>most</i> people are doing doesn&#x27;t require a high level of distributed systems sophistication.<p>Distributed systems are an interesting intellectual puzzle. But they should be a means to an end not an end in themselves.
评论 #43198508 未加载
评论 #43197204 未加载
评论 #43196814 未加载
Karrot_Kream3 months ago
When I was graduating from my Masters (failed PhD :) this overview of various programming models is generally how I thought of things.<p>I&#x27;ve been writing distributed code now in industry for a long time and in practice, having worked at a some pretty high-scale tech companies over the years, most shops tend to favor static-location style models. As the post states, it&#x27;s due largely to control and performance. Scaling external-distribution systems has been difficult everywhere I&#x27;ve seen it tried and usually ends up creating a few knowledgeable owners of a system with high bus-factor. Scaling tends to work fine until it doesn&#x27;t and these discontinuous, sharp edges are very very painful as they&#x27;re hard to predict and allocate resourcing for.<p>Are external-distribution systems dead ends then? Even if they can achieve high theoretical performance, operation of these systems tends to be very difficult. Another problem I find with external-distribution systems is that there&#x27;s a lot of hidden complexity in just connecting, reading, and writing to them. So you want to talk to a distributed relational DB, okay, but are you using a threaded concurrency model or an async concurrency model? You probably want a connection pool so that TCP HOL blocking doesn&#x27;t tank your throughput. But if you&#x27;re using threads, how do you map your threads to the connections in the pool? The pool itself represents a bottleneck as well. How do you monitor the status of this pool? Tools like Istio strive to standardize this a little bit but fundamentally we&#x27;re working with 3 domains here <i>just</i> to write to the external-distribution system itself: the runtime&#x2F;language&#x27;s concurrency model, the underlying RPC stack, and the ingress point for the external-distribution system.<p>Does anyone have strong stories of scaling an external-distribution system that worked well? I&#x27;d be very curious. I agree that progress here has stalled significantly. But I find myself designing big distributed architecture after big distributed architecture continuing to use my deep experience of architecting these systems to build static-location systems because if I&#x27;m already dealing with scaling pains and cross-domain concerns, I may as well rip off the band-aid and be explicit about crossing execution domains.
kodablah3 months ago
&gt; Just like the external-distribution model, arbitrary-location architectures often come with a performance cost. Durable execution systems typically snapshot their state to a persistent store between every step.<p>This is not true by most definitions of &quot;snapshot&quot;. Most (all?) durable execution systems use event sourcing and therefore it&#x27;s effectively an immutable event log. And it&#x27;s only events that have external side effects enough to rebuild the state, not all state. While technically this is not free, it&#x27;s much more optimal than the traditional definition of capturing and storing a &quot;snapshot&quot;.<p>&gt; But this simplicity comes at a significant cost: control. By letting the runtime decide how the code is distributed [...] we don’t want to give up: Explicit control over placement of logic on machines, with the ability to perform local, atomic computations<p>Not all durable execution systems require you to give this up completely. Temporal (disclaimer: my employer) allows grouping of logical work by task queue which many users use to pick locations of work, even so far as a task queue per physical resource which is very common for those wanting that explicit control. Also there are primitives for executing short, local operations within workflows assuming that&#x27;s what is meant there.
nchammas3 months ago
There is an old project out of Berkeley called BOOM [1] that developed a language for distributed programming called Bloom [2].<p>I don&#x27;t know enough about it to map it to the author&#x27;s distributed programming paradigms, but the Bloom features page [3] is interesting:<p>&gt; disorderly programming: Traditional languages like Java and C are based on the von Neumann model, where a program counter steps through individual instructions in order. Distributed systems don’t work like that. Much of the pain in traditional distributed programming comes from this mismatch: programmers are expected to bridge from an ordered programming model into a disordered reality that executes their code. Bloom was designed to match–and exploit–the disorderly reality of distributed systems. Bloom programmers write programs made up of unordered collections of statements, and are given constructs to impose order when needed.<p>[1]: <a href="https:&#x2F;&#x2F;boom.cs.berkeley.edu" rel="nofollow">https:&#x2F;&#x2F;boom.cs.berkeley.edu</a><p>[2]: <a href="http:&#x2F;&#x2F;bloom-lang.net&#x2F;index.html" rel="nofollow">http:&#x2F;&#x2F;bloom-lang.net&#x2F;index.html</a><p>[3]: <a href="http:&#x2F;&#x2F;bloom-lang.net&#x2F;features&#x2F;" rel="nofollow">http:&#x2F;&#x2F;bloom-lang.net&#x2F;features&#x2F;</a>
评论 #43202047 未加载
th0ma53 months ago
Since multicore processing a ton of software you use or create is distributed you have to ask if you want to be in control of how it is distributed or not. If you want it easy and let the library figure it out then you have to accept the topological ideas it has. For instance H2O is a great machine learning package that even has its own transparent multi core processing. If you want to go across machines it has its own cluster built in. You can also install it into Hadoop, Spark, etc but once you start going that direction you&#x27;re more and more on the hook for what that means and if it even is more effective for your problem and what your distributed strategy should be.<p>Things like re-entrant idempotence, software transactional memory, copy on write, CRDTs etc are going to have waste and overhead but can vastly simplify conceptually the ongoing development and maintenance of even non-distributed efforts in my opinion, and we keep having the room to eat the overhead.<p>There&#x27;s a ton of bias against this for good reasons that the non distributed concepts still just work without any hassle but we&#x27;d be less in the mud in a fundamental way of we learned to let go of non-eventual consistency.
gregw23 months ago
What I noticed missing in this analysis of distributed systems programming was a recognition&#x2F;discussion of how distributed databases (or datalakes) decoupling storage from compute have changed the art of the possible.<p>In the old days of databases, if you put all your data in one place, you could scale up (SMP) but scaling out (MPP) really was challenging. Nowdays, you (iceberg), or a DB vendor (Snowflake, Databricks, BigQuery, even BigTable, etc), put all your data on S3&#x2F;GCS&#x2F;ADLS and you can scale out compute to read traffic as much as you want (as long as you accept something like a snapshot isolation read level and traffic is largely read-only or writes are distributed across your tables and not all to one big table.)<p>You can now share data across your different compute nodes or applications&#x2F;systems by managing permissions pointers managed via a cloud metadata&#x2F;catalog service. You can get microservice databases without each having completely separate datastores in a way.
hintymad3 months ago
This reminds me of Rob Pike&#x27;s article &quot;Systems Software Research is Irrelevant,&quot; written about 15 years ago. Perhaps many systems have matured to a point where any improvement appears incremental to engineers, so the conviction to develop a new programming model isn&#x27;t strong enough. Or perhaps we&#x27;re in a temporary plateau, and a groundbreaking tool will emerge in a few years.<p>Regarding Laddad&#x27;s point, building tools native to distributed systems programming might be intrinsically difficult. It&#x27;s not for lack of trying. We&#x27;ve invented numerous algebras, calculi, programming models, and experimental programming languages over the past decades, yet somehow none has really taken off. If anything, I&#x27;d venture to assert that object storage, perhaps including Amazon DynamoDB, has changed the landscape of programming distributed systems. These two systems, which optimize for throughput and reliability, make programming distributed systems much easier. Want a queue system? Build on top of S3. Want a database? Focus on query engines and outsource storage to S3. Want a task queue? Just poll DDB tables. Want to exchange states en masse? Use S3. The list goes on.<p>Internally to S3, I think the biggest achievement is that S3 can use scalability to its advantage. Adding a new machine makes S3 cheaper, faster, and more reliable. Unfortunately, this involves multiple moving parts and is therefore difficult to abstract into a tool. Perhaps an arbitrarily scalable metadata service is what everyone could benefit from? Case in point, Meta&#x27;s warm storage can scale to multiple exabytes with a flat namespace. Reading the paper, I realized that many designs in the warm storage are standard, and the real magic lies in its metadata management, which happens to be outsourced to Meta&#x27;s ZippyDB. Meanwhile, open-source solutions often boast about their scalability, but in reality, all known ones have certain limits, usually no more than 100PBs or a few thousand nodes.
评论 #43199228 未加载
nyrikki3 months ago
&gt; Distributed SQL Engines<p>This is what I see holding some applications back.<p>The relational model is flexible and sufficient for many needs but the ACID model is responsible for much of the complexity in some more recent solutions.<p>While only usable for one-to-many relationships, the hierarchical model would significantly help in some of the common areas like financial transactions.<p>Think IBM IMS fastpath, and the related channel model.<p>But it seems every neo paradime either initially hampers itself, or grows to be constrained by Codd&#x27;s normalization rules, which result in transitive closure a the cost of independence.<p>As we have examples like Ceph&#x27;s radios, Kafka etc...if you view the hierarchical file path model as being intrinsic to that parent child relationship we could be distributed.<p>Perhaps materialized views could be leveraged to allow for SQL queries without turning the fast path into a distributed monolith.<p>SQL is a multi tool, and sometimes you just need to use a specific tool.
taeric3 months ago
I&#x27;m not clear what the proposal here is? It specifically eschews tooling as a driver in the solution, but why? Wouldn&#x27;t tooling be one of the most likely areas to get solid progress, as you could make tooling and point it at existing products.<p>Would be interesting to see comparisons to other domains. Surely you could look at things like water processing plants to see how they build and maintain massive structures that do coordinated work between parts of it? Power generation plants. Assembly factories. Do we not have good artifacts for how these things are designed and reasoned about?
mgraczyk3 months ago
The author is missing information about LLMs. In the &quot;Obligatory LLM Section&quot; he focuses on distributed systems that use LLMs.<p>But almost all of the new innovation I&#x27;m familiar with in distributed systems is about training LLMs. I wouldn&#x27;t say the programming techniques are &quot;new&quot; in the way this post is describing them, but the specifics are pretty different from building a database or data pipeline engine (less message oriented, more heavily pipelined, more low level programming, etc)
评论 #43198020 未加载
sriram_malhar3 months ago
The X10 language captures the notion of location of computation as a language primitive (&quot;place&quot;)<p><a href="http:&#x2F;&#x2F;x10-lang.org" rel="nofollow">http:&#x2F;&#x2F;x10-lang.org</a>
tayo423 months ago
I agreee it has stalled, I think for almost everyone what the author considers bandaid is practical enough that isn&#x27;t a need for innovation. Distributed systems is more or less solved imo.<p>Agree with another commenter, observability tools do suck. I think that&#x27;s true in general for software beyond a certain amount of complexity. Storing large amounts of data for observability is expensive.
评论 #43196546 未加载
sakesun3 months ago
I have been told and believed that we are getting very close to the ultimate answer throughout my career since CORBA&#x2F;DCOM.<p>Just learn that there is another discontinued attempt <a href="https:&#x2F;&#x2F;serviceweaver.dev&#x2F;" rel="nofollow">https:&#x2F;&#x2F;serviceweaver.dev&#x2F;</a>
anonymousDan3 months ago
This article is just word salad. In what way does Redis &#x27;abstract distribution&#x27; for example?
anacrolix3 months ago
I&#x27;ve been trying to explain this to people for 8 years. All of our existing languages side step the problem. Developers are writing distributed systems every day but seem oblivious to the fact their tools aren&#x27;t helping at all.
hinkley3 months ago
I am so appalled every time I ask a group of devs and get the same answer that I’ve just stopped asking. How many of you took a distributed programming class in college? And it turns out yet again that not only am I the only one, but that none of them recollect it even being in the course catalog.<p>For me it was a required elective (you must take at least one of these 2-3 classes). And I went to college while web browsers were being invented.<p>When Cloud this and Cloud that started every university should have added it to the program. What the fuck is going on with colleges?
评论 #43196729 未加载
评论 #43196651 未加载
评论 #43196974 未加载
lifeisstillgood3 months ago
This is a massive coming issue - I am not sure “distributed” can be exactly replaced with “parallel processing” but it’s close<p>So to simplify, from 1985 to 2005 ish you could keep sequential software exactly the same and it just ran faster each new hardware generation. One CPU but transistors got smaller and (hand wavy, on chip ram, pipelining )<p>Then roughly around 2010 single CPUs just stopped magically doubling. You got more cores, but that meant parallel or distributed programming - your software that in 1995 served 100 people was the same serving 10,000 people in 2000. But in 2015 we needed new coding - we got NOSQL and map reduce and facebook data centres.<p>But the hardware kept growing<p>TSMC now has wafer scale chips with 900,000 cores - but my non parallel, on distributed code won’t run 1 million times faster - Amdahls law just won’t let me<p>So yeah - no one wants to buy new chips with a million cores because you aren’t going to get the speed ups - why buy an expensive data centre full of 100x cores if you can’t sell them at 100x usage.
rstuart41333 months ago
&gt; Although static-location architectures offer developers the most low-level control over their system, in practice they are difficult to implement robustly without distributed systems expertise.<p>This is the understatement of the article. There are two insanely difficult things to get right in computers. One is cryptography, and other is distributed systems. I&#x27;d argue the latter is harder.<p>The reason simple enough to understand. In any program the programmer has to carry in his head every piece of state that is accessible at any given point, the invariants that apply to that state, and the code responsible for modifying that state while preserving the invariants. In sequential programs the code that can modify the shared state is restricted to inner loops and functions you call, and you have to verify every modification preserves the invariants. It&#x27;s a lot. The hidden enemy is aliasing, and you&#x27;ll find entire books written on the counter measures like immutable objects, function programming, and locks. Coordinating all this is so hard only a small percentage of the population can program large systems. I guess you are thinking &quot;but of a lot of people here can do that&quot;. True, but we are a tiny percentage.<p>In distributed systems those blessed restrictions a single execution thread gives us on what code can access shared state goes out the window. Every line that could read or write the shared state has to be considered, whether its adjacent or not, whether you called it here or not. The state interactions explode in the same way interactions between qubits explode. Both explode beyond the capability of human minds to assemble them all in one place. You have to start forming theorems and formulating proofs.<p>That worst part is newbie programmers are not usually aware this explosion has taken place. That&#x27;s why experienced software engineers give the following advice on threads: just don&#x27;t. You don&#x27;t have a feel for what will happen, your code will appear to work when you test it while being rabbit warren of disastrous bugs that will likely never be fixed. It&#x27;s why Linux RCU author Paul McKenney is still not confident his code is correct, despite being one of the greatest concurrent programming minds on the planet. It&#x27;s why Paxos is hard to understand despite being relatively simple.<p>Expecting an above average programmer to work on a distributed system and not introduce bugs without leaning on one of one of the &quot;but it is inefficient&quot; tools he lists is an impossible dream. A merely experienced average has no hope. It&#x27;s hard. Only a tiny, tiny fraction of the programmers on the planet can pull it off kind of hard.
ConanRus3 months ago
No Erlang mention? Sad.
cruelmathlord3 months ago
it has been a while since I&#x27;ve seen innovation in this arena. My guess is that other domains of programming have eaten its lunch
thway152690373 months ago
Oh god, even this article has AI and LLM section in it. When I thought distributed system design could not get any worse, someone actually pitched AI slop in it.<p>God I want to dig a cave and live in it.
评论 #43199360 未加载