A high-level overview.

Webshit interfaces or browser extensions (Metamask) use web3.js, which JSON-RPC-es a node (geth), which “talks to the network” (by implementing the current revision of the protocols), maintains a stateful storage (which may include a local copy of the entire blockchain) and calls evm to run the code associated with addresses.

There is also web3.py which, basically, is translation from Javascript to bad Python. All the “clients” use web3.py.

Everything stateful imperative huge-class OO “all the way down”.

The point of using Python is availability of a whole ecosystem of high-quality “scientific” and ML libraries, which can be easily hooked in for some quick “exploration”, testing or rapid prototyping.

The ecosystem is already “too big to fail” (or “have crossed the threshold of immortality”), and just like PHP or Java will “stagnate forever”.

Any “ETH killer” thus is just a meme, because the amount of man-hours spent on ETH is orders of magnitude higher, and it continue of begin developed at a high rate of changes by an enthusiastic internet community.

It short, just like PHP, it stabilized, and it “works”, however crappy.

The inevitable conceptual complexity and redundancy is already slowing it down, and also rises an entry-barrier both for developers and competitors. It will become (already became?) sort of Enterprise Java (J2EE, JavaEE) shitfest, which is vastly complex, badly “designed” crap no one really wants to touch even for a salary.

This, again, proves the emergent social principle, that a huge enthusiastic amateur community beats everything, not in quality but in quantity (look at these node_modules, try not to puke).

One more important principle is that due to inherent low quality it will never be the only choice or a preferred choice (nowadays it is) when a real demand (beyond amateur enthusiasts) arise (seems unlikely), and then a way better (in quality) corporate solution, from Google-like shop, will quickly hit the marker.

Just as PHP long ceased to be “the default choice” for any webshit development, but still is out there (and will be there for a long time, thank to Wordpress and what not), ETH will be there too for a long, long time.

The history not repeats itself but spirals to a new level.

Just exactly like PHP3+ we have a whole ecosystem, made by unqualified, uneducated, incompetent but over-zealous amateurs right from the start.

The EVM and its bytecode is one big embarrassment. Contracts call each other’s methods without any restrictions (imagine “desinging” an RPC system in such a way!).

The code is “imperative commands” which modify the “global state”. So, the order is crucial and the code in NON-reenterable. The same fundamental problem as with early C library code.

The classic attack exploited these properties. There are no fixes to this “technical debt”.

Solidity, which is supposed to be a high-level language is another embarrassment of an imperative “like an OO” but not OO amateur language, which has “methods” and “events” but no well-defined OO-semantics.

A contract is a sort of an “Object” (as in Java), but is not instantiated from a class “template”, but defined as a set of methods which access both its internal mutable state, and the global mutable state.

Getters and setters, “views” as “generated getters”, “events” are just implicit method-class in disguise, and all the other great design choices.

It uses some sort of static typing, but also a duck-typing, with no standard mechanism to define and type-check. An ERC-20 token is just a set of required (to be implemented) “methods” and “events”, but there is not way to typecheck these.

At the “client level” everything is still imperative, stateful with lame large imperative OO classes in Python or Javascript on top of it. Even the small benefits of OOP has been thrown out of the window – the code is badly structured.

The “provider” exposes an imperative, stateful (with access to the global mutable state of the node) JSON-RPC API. REST APIs are supposed to be stateless.

Of course, the “client libraries” (wrappers) (like web3.py) and nodes (like geth) are out of sync (as at the time of writing) and one has to know the exact versions which supposedly works together (the APIs are matched).

The abstractions and their names are literally idiotic – both concepts and in data-fields, and this tells everything about the state of the whole “project”.

It is literally a fucking mess of lowest quality amateur crap, both at the conceptual level an implementations.

Inconsistent and stupid naming reveals sloppy thinking and lack of any unification and minimization attempts, which is the direct result of a total lack of mathematical maturity.

All the APIs are stateful, over-structured (because it seems so cool to them), full of unnecessary, redundant abstractions, thrown in at a whim without much thinking. I have already mention the idiotic naming.

And, of course, the worst possible kind of JSON everywhere.

It could have been as clean and well-researched as Erlang, but these “architects” and “developers” never read a single book on the subject in their whole life

Anyway, we have to extract actual (and useful for us) high-level concepts, hiding all the ugly details and inconsistencies within.

For last 10 years they have managed to put ad-hook fixes and make it usable. So, by just using current solutions (geth and solc) very carefully one can use the ecosystem for some simple tasks.

The obvious ones are to collect transaction fees, just like Uniswap did.