QUEST LOG · May 20, 2025· UPDATED October 29, 2026
The Greatest Truths Are the Simplest: Was KISS Right All Along?
Keep It Simple, Stupid
The line above is a core principle of Linux kernel design, and it's easy to forget amid today's trendy frameworks and designs. Lately, especially in the DHT and blockchain projects I've been working with a lot, I keep running into all kinds of over-engineering. Blockchain, as a fancy new technology, makes it far too easy to lose focus. Not long ago I fell into this trap myself, so I'm writing it down as the first post on the new site, as a reminder to myself.
# The DHT foundation trap
I've been suffering from this lately because of a DHT project I'm working on, so let me tell you the whole story.
When most blockchain projects are designed, they come with a fairly complete DHT, i.e. a distributed store, where the whole table is made up of many users. Everyone starts from this table and then goes on to pick their own consensus algorithm and design how nodes communicate. And that's exactly where the trap is. Why?
The trap is that everyone's design uses formats that were never unified. It might also be about where the P2P nodes come from, or the underlying data being written in some very new format that gets abandoned very quickly (a special flavor of protobuf or something; just an example, not picking on it XD). These traps are very easy to step on right when a project kicks off.
A while back I read an article, Smaller is Better , explaining how their design had fallen into a want-everything situation. To quote one line from it: "Nobody wants the nginx team to ship postgres." That's why they focused on designing the transport layer of their DHT and on building reliable sync, because piling on complex features actually makes things hard to be compatible with and hard to plug into. Massive beasts are made up of simple designs.
It reminded me of a GitHub interview with Linus I watched recently. In it, Linus describes Git as just a script he designed to solve the problem of replacing CVS, and the core functionality was written in a few weeks. Looking back over many years, he says he has mostly only used a few core commands like git blame and git log. The main idea was to use the sha1 design to solve the problem of patch merges taking forever. The entire core was designed around solving that one problem, then the basic features of version control were built out, and it even uses its inherent properties to give you a local git tree. I think it's the tool the distributed world should look up to most right now.
After reading about Git's design philosophy, it was a total epiphany. This is the problem most designers today need to solve: just focus on designing a tool that solves the problem. The tool can even be a script, no problem. As long as it's useful enough, it'll quickly become a wheel everyone reuses.
# Every blockchain project is reinventing the wheel, and nobody is working on compatibility
Lots of people online are bashing the Ethereum Foundation right now. Personally, I think the sentiment does lean toward users feeling Ethereum is incompetent, because the recent upgrades, EIP-4844 for blobs and EIP-1559 for gas, haven't, in my view, made a big difference to user experience overall. If anything, they've made the overall EVM ecosystem more fragmented.
Before getting into that, let's think about why the Ethereum Foundation is like this. Personally, I think it's because they focus more on core EVM development overall. After all, on the blockchain food chain of snobbery, the people building the base layer get to look down their noses at everyone else (just kidding, most core developers are really nice). So we've ended up in a place where people feel the application layer hasn't really progressed since Ethereum first came out. That's pretty sad, because 6-7 years ago people on-chain were using UniswapV2, and today they're still using the same model, just with a different food name or whatever in front of "Swap."
And most of the projects that get close to core developers want to build their own blockchain, without caring about compatibility. That has turned Ethereum into the one effectively building compatibility layers for these projects, which is how we've ended up with more L2s than DeFi projects anyone can name.
Whether it's P2P projects or blockchain projects, what I see is one ever-more-complicated algorithm after another, plus a cross-chain bridge to Ethereum to soak up ETH liquidity. Half-joking here: Ethereum's biggest application right now is that pile of blockchains that look exactly like it. And most of the new DHT systems are walking the same road everyone walked 10 years ago: hurry up and spin up a gimmicky blockchain before the ICO. Now that blockchains may not be fancy anymore, you probably have to invent some special method and claim you're super fast and Ethereum-compatible.
All that said, I still really like Ethereum. This post is just about what I currently see as a small problem in the ecosystem. Most people's design philosophy is to find a customer's problem and solve it, but they often end up stepping into the same holes others already fell into. That's led to way too many look-alike DHT and blockchain products, especially during the stretch when you could launch a chain in one click, which turned a lot of problems from simple into extremely complicated ones that are still with us.
# Cutting from complex down to simple
So what do I think good design is? Everyone looks at Git today and marvels at how great it is. Nginx and Postgre are also beautifully designed products. If you focus on what they actually did, it's providing a tool that's stable, simple, and pleasant to use compared to other similar products.
I've now fallen down the DHT rabbit hole myself, and I'm deep in the urge to design a P2P system to solve my own special-spec problems. But really, a blockchain is already a great kind of DHT. Would using an existing chain like Sui or EVM plus ZK be better than designing a new self-hosted node model from scratch? From the user's point of view, I think absolutely yes, because the one thing web3 is never short of is complicated programs; at a lot of events they'll even pay you to learn them. So from a user's perspective, not running your own nodes saves not only your own hassle, but your users' hassle too.
What I still haven't figured out is a solution that's simple yet disruptive the way Git is. But I think a simple core is a really important principle. After all, if what users face is a complicated tool, I imagine the audience will get more and more complicated and weirder too. Let this be a lesson to me; I hope I don't end up building a massive beast.
Just venting some personal thoughts. It's also because earlier this year I built an entire DHT system, even brought WASM over so the P2P could easily run anywhere. But the complicated type validation, message handling, and sync problems drove me to look for similar products, and I found that plain webRTC could do 90% of my work, and handle it quite elegantly. That was pretty embarrassing; months of effort basically went up in smoke. I guess that's part of growing, too!
Apps I ship
Free on iOS and Android.


