go-ethereum

yperledger/besu#readme https://github.com/ledgerwatch/erigon#readme https://github.com/ethereum/go-ethereum#readme https://github.com/NethermindEth/nethermind#readme https://github.com/status-im/nimbus-eth1#readme And there are many Open Source specs and libraries underlying those clients that have also involved non-trivial development and collaboration, e.g. libp2p.

client, commonly known as "geth". It's on their own GitHub: https://github.com/ethereum/go-ethereum But the 5 consensus clients not only have websites which aren't ethereum.org - they are in fact also hosted on different GitHub accounts: https://github.com/sigp/lighthouse https://github.com/ChainSafe/lodestar https://github.com/status-im/nimbus-eth1 (yes, this is also for eth2, see "About" at top right) https://github.com/prysmaticlabs/prysm https://github.com/Consensys/teku Further, all of these 5 institutions seem to be companies from the looks of their website, not non-profit foundations. (Please correct me and pardon me if that is not true, I don't have the time to navigate through all these websites to figure out their precise legal status.) So is it true that there is no official reference implementation to run the post-Merge, Proof of Stake Ethereum? Only 3rd party software which is somehow endorsed but which you have to choose on your own still? Sure, more choice can be nice, but it would seem advantageous to have at least one trustworthy reference client instead of the users having to decide which of 5 commercial entities they trust?

e other Beacon implementations the deployment and configuration changes required are non-trivial[2] and again, the v3 release referenced in this announcement was only released two days ago! As someone who runs Ethereum nodes I'm a little gun shy at this point deploying new releases of this stack, especially given how things have gone the past two days. Even with our relatively trivial application this gives little time for any testing or assurance process. It's amazing to me given the stakes (value of the Ethereum chain) and complexity (huge) node operators are essentially in the position of waiting until mere days (or hours) to upgrade their nodes and as noted - there are thousands of us around the world. IMO this is yet another indication that the real issue with regard to decentralization of blockchain solutions is the fact that (as pointed out by Moxie and others) the vast majority of the real users and platforms of Ethereum interact with the chain via a handful of centralized node providers (Alchemy, Infura, etc). Who can blame them given what a mess this is? I'm also not picking on Ethereum specifically, the same things could be said about most of the other chains and implementations I've interacted with. Given the hype, promise, age, and value in the blockchain ecosystem the software itself makes Apache circa 1996 look like mature, rock solid software. BTW, the Ethereum Foundation alone holds approximately $1.6B in assets[3] and investors have poured tens of billions of dollars in this ecosystem. IMO the quality and process of the fundamental software enabling all of this is inexcusable - it's not like they're wanting for resources to do this right. [0] - https://ethernodes.org/ [1] - https://github.com/ethereum/go-ethereum/releases [2] - https://docs.prylabs.network/docs/prepare-for-merge [3] - https://www.coindesk.com/business/2022/04/19/ethereum-founda...

hem existing Rust project, a lot faster than (for example) an experienced C dev would on a novel-to-them existing C project, as a large stdlib / conventional ecosystem of foundational libraries (as in the case of Rust) tends to translate well to experienced developers coming into a codebase and quickly recalling everything, because it’s a bunch of the same batteries/libraries they’ve already used in the past. The difference between a design pattern and a language feature, is that you can recall language features, while you have to recognize design patterns (i.e. grok the code in order to identify what pattern(s) it’s trying to reify.) Languages with more formalisms (either built into the language, or in common use in the ecosystem) increase the amount of recall that new maintenance programmers can do (or rather, decrease the amount of recognizing they have to do to get up-to-speed), and thus make switching a maintenance programmer between codebases “cheaper.” ————— I bring this up not from the perspective of a Rust programmer, but from the perspective of an Erlang programmer... who also doesn’t like Go very much (though I do write quite a lot of Go! As a maintenance programmer!) IMHO Erlang and Go aren’t all that fundamentally different runtime-wise. Presuming you’re using them for the same thing — writing highly-concurrent, fault-tolerant network servers — the main difference between the experiences of coding in Go and in Erlang, comes down to the fact that Go provides you with a bunch of concurrency primitives that you have to put together as design patterns — and where maintenance programmers then have to recognize those patterns; while Erlang actually has universal concurrency formalisms that everyone takes advantage of, and so those formalisms can simply be recalled on new projects. I advise anyone who thinks that “recognizing design patterns” is a cheap-and-easy thing to do, to tell me what’s going on in this file: https://github.com/ethereum/go-ethereum/blob/master/eth/down... . I’ve stared at this code on-and-off for two years, and I still don’t have a mental model for it. If this code was made out of cleanly-separated named/opaque formalisms, rather than fifty design-patterns tied into a knot, I can’t even imagine how much more productive I would have been working on it.