The Two Sides Fighting Over Blockchain's Future

The year is 1992 and Andrew Tanenbaum, a computer scientist, has declared that Linux is dead.

If you’re not familiar with Linux, it’s an operating system (OS) popular among more hardcore computer users.

The reason Tanenbaum pronounced Linux dead is because of the kernel it uses. A kernel is like the engine of the OS that handles the tasks that enable your computer to work.

Linux uses a monolithic kernel, so the entire OS runs as a single, tightly-integrated unit.

But in the 1990s, Tanenbaum and others saw microkernels as a potential successor to classic monolithic kernels. In a microkernel architecture, the core kernel is kept as simple as possible, and most services that a monolithic kernel provides are implemented instead as small, independent modules.

A microkernel project called GNU Hurd aimed to supplant the Linux monolithic kernel, which was seen as a dying breed.

How’d that turn out?

Well, put it this way: If you happen to be reading this on an Android phone, you’re actually using a modified Linux kernel.

Although it’s not as popular in the retail space, with Windows and Mac dominating the scene, Linux is used by 40% of all embedded systems computers (computers designed to perform a specific task, like the ones that control a traffic signal). It’s also in 70% of smartphones and 80% of all web servers.

Oh, and the top 500 world supercomputers all run on Linux.

Meanwhile, to this day, GNU Hurd is still in development.

If this sounds familiar to you, then you know that a similar debate is currently raging in crypto. And it has implications for the future of Ethereum and other layer-1s.

Monolithic vs. Modular

When it comes to blockchain architectures, there are two major approaches. The first is a monolithic design. Similar to kernels, this is where one blockchain does everything.

We can divide a monolithic chain into four main functionalities: execution, settlement, consensus, and data availability.

Let’s review the steps of an Ethereum transaction to understand them better.

Say you buy an NFT. First comes execution, when a node processes the transaction and the NFT is transferred to your wallet.

Next, the settlement process kicks in to cement the transaction into the blockchain. A proof that the transaction happened now sits on the blockchain and cannot be tampered with.

Consensus clicks in as the decentralized network nodes agree that the transaction is valid.

Finally, the data availability stage publishes the transaction details throughout the peer-to-peer network, ensuring all nodes can access the data as needed.

Now, you have your NFT, everyone agrees that you have it, and everyone can verify this.

Most early blockchain projects like Bitcoin, Ethereum, and Solana took the monolithic path, with one system handling all these steps.

But early blockchain design was like the first pancake you cooked as a kid: a bit of a mess. Plagued with inefficiencies, compromises, and subpar design choices. Most, if not all, blockchains to date are still not able to deliver a decentralized, secure, and scalable solution at a reasonable cost for users.

That makes them less than ideal for widespread adoption.

The premier example of this is Ethereum. While revolutionary as the first general smart contract platform, Ethereum has failed to scale for mass adoption due to low transaction throughput and high fees.

Seeing Ethereum's struggles, many in crypto turned to modular blockchains as a potential solution.

Modular architectures split up responsibilities across chains tailored to specific roles.

Consensus, execution, data availability – why should one chain be forced to handle it all? Specialized modular chains can focus on doing one thing really well.

For instance, you could leave consensus and data availability to one chain, and execution and settlement to another. That’s what a sovereign rollup would look like.

Your typical Ethereum rollup (think Arbitrum or Optimism) is a type of modular chain that specializes in execution, leaving the settlement, consensus, and data availability to Ethereum.

Ethereum's endgame, enshrined by Lord Vitalik, is to become the base settlement layer for other rollups. Such a design is meant to be the pinnacle of blockchain architecture design.

Modularity fans argue that breaking blockchain into Lego-like components allows more customization and scalability.

But I would argue that favoring a modular design comes from where Ethereum is right now.

As it stands, Ethereum cannot handle significant activity. Even the most die-hard ETH-heads will agree with this.

But Ethereum is also where most of the capital, both financial and human, is concentrated. It's the chain that settles the most value, the place where most innovation happens, and the biggest talent magnet.

It's no surprise then that many are making a considerable effort to push Ethereum toward a modular future, instead of investing resources into building a better monolithic chain.

Ethereum proponents will have you believe that this is a settled debate and that modular blockchains are simply better than monolithic ones. That monolithic chains are inherently unsuited for running a high-performing, decentralized, and secure chain.

However, as we'll see next, modular architectures have their own hidden costs and may fail to deliver on their promises.

The Central Flaw of Modular Chains

For starters, monolithic blockchains are more performant than modular ones.

There, I said it.

I know this might go against the grain, but there is not a single indication that modular chains would perform better than monolithic ones.

As we’ve mentioned, the most performant computers all run on monolithic kernels. Blockchains are basically no different. And if you look at the most performant live chains right now (Solana, Sui, Aptos), they are all monolithic.

This higher performance is in part due to the fact that all transactions on a monolithic chain are executed on one integrated chain. Transactions can flow smoothly through internal pipelines without waiting for data from different chains. The lack of fragmentation allows for efficient transaction processing.

Monolithic chains are also simpler. Simple is good. Especially when it comes to highly complex systems.

Users and developers only need to interact with one system rather than coordinating across many complex modular components.

Monolithic chains are inherently more secure, too. By keeping validators on one network, there are fewer weak points for hackers to attack than on modular ones. And don’t get me started on how unsafe bridges are.

Finally, monolithic chains lower communication overhead by avoiding excessive inter-chain messaging. Modular systems require substantial message passing between components to coordinate activity, which creates bandwidth, latency, and monetary costs.

So in summary, monolithic integration can improve performance, simplicity, security, liquidity, and overhead costs.

Simply splitting functions into modular chains doesn't automatically make the system better.

Plus, modular chains (at least the current vision for Ethereum and its rollups) have one big drawback that monolithic chains overcome, as Anatoly Yakovenko, co-founder of Solana, explains:

The goal of the solana design from the get go was handling concurrent programs with different demand without them impacting each other. [...]

Imho, modularity doesn’t address dealing with concurrent usecases, each L2 is one single threaded runtime that will hit the same problems as eth L1 today.

Anatoly is referring to the fact that Ethereum, specifically the Ethereum Virtual Machine (EVM), handles transactions sequentially, that is, one after the other. If it were to validate and settle transactions coming from L2s, it would still do so sequentially.

This severely limits throughput and scalability, even with better hardware.

So to boost performance, a blockchain needs to adopt parallelization, or the ability to process multiple transactions at the same time.

Most computers today, and definitely the most performant ones, have this capability.

Blockchains are no different. The chains able to handle parallel transactions (Solana, Sui, Aptos) are much more performant than Ethereum.

And even if a Layer 2 rollup was able to handle parallel transactions, it could then potentially capture most or all activity, making other rollups, and even Ethereum, redundant.

The EVM Is Dead. Long Live the EVM

Monad, a newly announced chain that builds on and improves the EVM, seems to agree with Anatoly’s Solana thesis.

By enabling parallel transaction processing, Monad solves what probably might be the greatest drawback in the design of the EVM.

But that’s not all.

Monad also implements a revamped storage backend called MonadDB to accelerate contract and state access. Every time a transaction is executed, the chain needs to access data from storage in order to process that transaction. The way storage works in the EVM right now, accessing that stored is a slow process.

MonadDB allows for more efficient storage. And since Monad can handle parallel execution, it can also implement asynchronous input/output (I/O), by which the chain can continue executing transactions while reading and writing data to storage.

Additionally, Monad separates the consensus and execution layers. This allows consensus to run ahead of execution in parallel rather than bottlenecking processing transactions.

Oh, and Monad also implements a new consensus algorithm. Now, nodes can achieve consensus in a faster, more efficient manner.

With these and other optimizations, Monad makes substantial improvements to the EVM.

Of course, this is all just on paper. We haven’t seen Monad run live.

And who knows, maybe Monad does not deliver on its promise. Nonetheless, by challenging prevailing architectural dogmas, projects like Monad further collective blockchain progress.

Maybe modular chains win in the end. Maybe monolithic architectures prove to be a better design.

But neither camp has a monopoly on wisdom. True breakthroughs require open exploration beyond trendy buzzwords or siloed thinking.

Pragmatism and empirical evidence, not dogma, must guide architecture decisions if crypto is to deliver on its promise.

Well, today we put our serious hat on. I'll be back next time with the fun.

Kodi