YADA: Yet Another DeFi Application
In the summer of 1994, a simple fact about the World Wide Web blew my mind.
You see, the web has this idea of a “webpage”, a term in which the “page” is skeumorphically misleading. The word “page” makes one believe that the content of a webpage should look like pages in the real world, like a magazine, or a newspaper. And this concept of a page was reinforced by HTML, the language used to render these pages: not only did webpages look and feel like a pages in real life, even the back-end was very page-like. In 1994, almost every webpage was static. Yahoo was static. So were IMDB and Wired magazine. The famous “dynamic” websites of the 1990s, where you engaged in transactions (like Amazon and Ebay), didn’t exist yet.
When playing with my own web server one day, I was experimenting with something called the Common Gateway Interface (or CGI). CGI is designed to allow certain types of programs to run in the background on a web server. On a lark, I put a C executable (
a.out) at the back end of the web server, and it ran! What blew my mind that day was the realization that the content of a webpage could be generated from anything that can be computed. Your web server can run any code, and the output of the code could be rendered (as HTML) on someone’s browser.
So a webpage wasn’t really like a page in real life at all. You could run any computation, search any database, engage in any transaction, and as long as the output was HTML, it would work. Based on this, dynamic websites like Amazon could allow you to buy something and show you the output as a webpage, and Fedex could let you search their database for a tracking number and show you the result as a webpage.
So this was my mind-blowing realization: A webpage isn’t just HTML that is sent by a web server and rendered by a browser far away. A webpage is a Turing-complete, blank canvas that can be accessed by anyone on the network.
Fast forward to 2009. I was running my AI startup, happily working with images and video, when a friend sent me the Nakamoto paper describing bitcoin. I was fascinated with the idea of a peer-to-peer network for trustless transactions. After an abortive attempt at mining using my home computer, I went out and bought some bitcoin (from a shady guy in Queens, NY — but that’s a story for another day).
Since then, the world of blockchain has evolved. We have several dozen blockchain ecosystems with smart contracts. Each of these ecosystems has a native token, which is ownable and fungible, so behaves like a cryptocurrency. And each ecosystem has developed tools to allow investors in their tokens to maximize returns: there are decentralized exchanges, bridges, lending and borrowing sites, among many, many other Decentralized Finance (DeFi) apps.
Whenever one mentions a blockchain network, the first point of salience is their native token. “Have you seen that SOL? It’s on a tear lately!” “The ALGO token is about to take off!” “That TEZOS treasury is massive!” Even DeFi apps have their own tokens, with their own stories. “I think SUSHI is a good value for money nowadays.” “Whatever happened to CFG?”
Because there is a native token in each project, and the founding team keeps some (or a large) amount of these tokens for themselves, each team is strongly incentivised to promote their own project or ecosystem. They are all competing for investors, and for developers who can build DeFi apps to attract more investors.
Ultimately, these ecosystems are all competing with one another. They are competing for more investors, which depends on more users, which depends on more usage, which depends on more DeFi apps. All DeFi apps have the same ultimate goal: to allow investors to generate more returns, by fractionalizing their tokens, by staking, by lending, by borrowing, by leveraging. And the competition between ecosystems is fierce: they compete on speed and scalability (“our network can do a million transactions per second!”), on low fees (“our fees are so low that we give you money back!“), on funkiness of consensus mechanisms (“proof of history”, “pure proof of stake”, “partial proof of differential historical behavior”). I was once on a call with a blockchain network founder who said, in all seriousness, that his consensus mechanism was the most important thing to happen in computer science since the Nakamoto bitcoin paper. In his defence, he does own a lot of his own tokens.
Every blockchain network has a DeFi ecosystem sitting on top of it, allowing investors to generate good returns, and allowing founders and early investors to generate giant fortunes.
But all of this focus on DeFi has obscured the really important analogy of these tokens to webpages: that ultimately, a blockchain token is a Turing-complete, blank canvas that can be OWNED by anyone on the network. And this ownership can be established without any trusted third parties.
Let me restate that in another way: You can own anything that can be computed.
Anything. That. Can. Be. Computed.
But we’re barely scratching the surface of ownership. Today (March 2022), you can own fungible tokens (cryptocurrencies and such), or you can own non-fungible tokens (NFTs). But the world of NFTs is very shallow: the majority of them are digital objects that look (and behave) like objects that we already own in the real world. You can own digital art, or digital music, or some other skeumorphic objects in the metaverse.
When you looked at webpages in 1994, you could imagine the services where computation was simple: you could imagine that NY Times would publish their content, or you could imagine that FedEx would let you search their database. But you couldn’t imagine what more complex computations could generate on the webpage; you couldn’t imagine services like Facebook or Uber.
In March 2022, we find it difficult to imagine what can be owned. Because we have an ownership network, we think that the people who have historically created stuff, the “makers”, will do a lot better. Maybe they will, but I think it is reasonable to also expect a new class of things that get created that can only be computed, or can be represented by a computation.
I don’t know what that looks like. But I can hardly wait.
In the 1990s, on the TV sitcom Seinfeld, there was a character who used to say “Yada yada yada” to describe things that she didn’t want to talk about; things that she wanted to skip.
My vote: let’s leave DeFi to the traders. As technical people, we should bering our focus back to the blockchain, and back to ownership. Time to do something bigger, bolder. Like Seinfeld, DeFi apps are so Yada yada yada.