Actually, Ethereum wasn't my original title. The original title is there. So while I've been working on the project, my appreciation for precisely what it is has changed somewhat, evolved let's say. At the beginning, Ethereum was always kind of sold as this notion of a Bitcoin thing, but Bitcoin with maybe some features removed or some sort of added extra thing of having a virtual machine or an extended scripting language let's say. And that didn't really... it was a cool idea, but it wasn't really getting to the heart of what it was that we were making. And you know, the idea of what Ethereum was going to do was quite limited in scope. It was essentially going to be an abstraction platform for Mastercoin-style financial contracts on a blockchain.
As time went on, especially I remember in January 2014 when we all gathered in Miami, and I'd had very little sleep that week, and I was thinking, is there some better way of thinking about this other than, you know, Bitcoin but with some sort of additional richness in the scripting language? And my mind got to crypto finance, and I was thinking, well, if Bitcoin's crypto finance, what's Ethereum? And this is where the notion of crypto law came from. It's actually, well, actually it's like finance, but it's fully general. And so finance is kind of a subset of law in a way, and so maybe Ethereum could be thought of as a cryptographic version of that. This evolved further, and basically this talk is about a later sort of realization as it were of what Ethereum is.
So we can answer the 'how'—that was the first thing we answered, that was quite reasonably presented in Vitalik's white paper back in November. And we got a pretty good idea of 'why'—that kind of stems from the Bitcoin space, decentralization, why it's a good thing. But the 'what'—like what actually is it?—that's the harder question. And we get, you know, history repeating itself, people sort of they know they want it but they don't really know what it is. So for this talk, I'm going to try and avoid using much of the language that we see in this conference so far. I'm going to try and avoid using these technical terms because these technical terms help us describe how it works, but they don't really help us describe what it is.
So what is it? Well, for a long period we just didn't know. This is probably lost on most of you, but it's from a very good comedy called Look Around You, and if you get the opportunity to see it, please do. Well, actually, Ethereum is a computer. It's a computer a bit like this one. This is a computer, this is I think from around the early 50s, and this is what they thought a home computer would look like by 2004. This one runs Fortran, so it's easy to use. Ethereum is a computer. It's not a very good computer. It's really slow. It's also really, really expensive, as most of you probably know by now, at least the ones developing on it. And it's got this odd property of not always being exactly decisive about what has happened in terms of its IO, although after a minute it generally gets a bit more certain about things, but it does take that extra time. So far it's not seeming like such a good invention. Seems like we're going backwards a little bit.
But actually, it's got some really interesting properties. And what I'm going to try and show you is what these properties are when we think about Ethereum as just a computer. So the first thing to notice is that it's a global singleton, and it's possibly the first global singleton computer that's fundamentally not localized. Computers are generally either physical machines like my laptop here, or virtual machines that actually reside within a single physical machine. Whereas the Ethereum computer doesn't reside in any single machine. It's not located physically in any particular part of the world, yet there's only one of them, and that's a bit of an odd notion. It's a computer that in general, you know, there's no reset button, there's no power button, you can't turn it off. And that again is a bit of an odd sort of thing to think about. Is my mic still working? Yeah, okay.
And secondly, thirdly, it's ubiquitous. Wherever there's the internet, everyone who can use the internet actually has fair access to this resource, to this single computer. And there's more—there aren't that many computers which in terms of the hardware are actually multi-user. They're fundamentally multi-user. Every time someone uses the Ethereum computer, they're logged in, and there are as many user accounts as we need. Very kind of odd notion. As a computer, it's natively object-oriented. Object orientation is built into the computer itself. Encapsulation is built in. Code has data, and the two are inextricably linked, and yet there's encapsulation away from all the other code and data pairings. It's very accessible. There aren't many computers so accessible. This one we can interact with it just using fairly simple web primitives, JavaScript. And it's inherently auditable, verifiable, and auditable. And there are not that many computers where we can replay everything of the past and always be absolutely certain of getting the same result.
So there's my rather dodgy artist's impression of the Ethereum computer. There's the world, because actually it's a global singleton, there's the globe. And all these boxes are accounts, they're objects. On the side there, they're the external accounts, they're the objects from which messages get injected in from the outside. And in the middle there, these are all the objects that are executing in this object-oriented execution environment, or the Ethereum world computer. Once you're in there, you can't get out. So the only way of getting stuff in is by these external accounts. And it's from this, of course, that we get our cryptographic safety. So we get guarantees on code executing within this computer.
We get some really nice guarantees. We got atomicity. Atomicity, for those who do database programming or for those who don't, is that basically we don't have to think about whether a transaction fails halfway through. Either the whole thing executes as expected or it doesn't. We don't have to bother setting particular safeguards in order to roll back things. We get synchronous operations, so objects are guaranteed not to interfere with each other. We don't need to think about threading or processes or shared memory, any of that nonsense. But most importantly, we get provenance. And this is a very odd notion. All of the messages in our computer have some origin. We can check to see who sent the message to us. And we can't normally do that. There are not many object-oriented execution environments where we can do that. Hands up if you know of another object-oriented execution environment where you can check always which object sent you the message. Anyone? No, it's the first, I guess. And that allows us to build certain security constraints into the operation of our code.
Furthermore, there's permanence. An object's data is permanent. It lasts. It doesn't change when the computer sort of goes off. There is no 'off' for this. And the objects, oddly enough, are immortal. So there's no notion—if the object doesn't delete itself, there's no notion that the object is ever going to die. There's no system admin who can come along and actually delete the object. It can't log in as root and just 'rm' doesn't work. And if the object doesn't have code that actually commits suicide, then no other object can force it ever to die. It's a very, very strange notion. And finally, the code that executes is immutable, cannot be changed. This wasn't the case in some of the earlier versions of Ethereum, but in the version that we have now, the code is immutable. So you can be absolutely certain that if this object's code is X, it isn't going to be Y down the line.
So why? What's the point of having these particular attributes? What does it give us? I'm going to list a few things, a few thoughts on this. And the first is, well, Ethereum is a commons for innovation. It's a place where we can all upload code, upload ideas in terms of human interaction, and have it just work with other things transparently. We don't need to think about, you know, the worst signing partnership contracts with other businesses in the same way that Uber would have to do if it wanted to integrate its services with, let's say, Airbnb. We don't need to consider that because if we have a decentralized Uber operating on Ethereum and the same for a version of Airbnb, then they can operate with each other if they want to, and they don't have to ask for permission of the other. Compared to servers, this unleashes massive amounts of potential innovation for business. Servers provide barriers. Servers are cumbersome, and yeah, they make interoperability difficult. And these barriers basically make monopolies, and monopolies are generally bad for innovation.
And of course, we have interesting repercussions for privacy. Now, of course, the open chain doesn't really get you much in terms of privacy, quite the opposite. But what it does is it makes you think. It makes you think about what data you actually want to place in the wild and what data you want to keep safely locked away on the user's machine. What it doesn't do is it doesn't give you this false security of placing on a third-party server where only the elite hackers and those who want to pay them can get access to it. And that's kind of nice. We also get this nice authenticity. With server interactions, basically, it's the server that authenticates you, or some third-party service that you essentially have to trust. With Ethereum, you authenticate in and of being yourself, in and of having access to your private key, or if you've got two-factor stuff, then your private keys.
Ethereum is the world's first decentralized computer. That's kind of an interesting thing in of itself. Because it's decentralized, there's no single point of control or failure, or any single bottleneck in principle. In terms of where things have been going, if you look into history, you find that at the beginning there tends to be very little floating around. It's all very dispersed and not much is actually happening. Eventually, you find there's a strong player. The strong player picks up all the dispersed, they add rules, and they place their own laws of interaction with this structure in place. You generally find that there's enough development such that these initial structures are not necessary anymore.
If we look in software development, we find that originally there were sort of individual coders. Eventually, there was this notion of coders getting together into a strict hierarchy. This is the sort of thing that originally the GNU project was like, but also obviously corporate software firms. When there was a sufficient amount of development, we ended up with having this—in this case, the internet was mostly, but obviously version control systems really helped—we ended up with things like this bizarre model, as Eric Raymond mentioned in his paper. Finally, we're sort of evolving further, even more decentralized from the bazaar model into this kind of Git style, you know, everyone clones, everyone forks, and there is sort of horizontal gene transfer of all of the various ideas going on in coding.
We see the same thing happening with other aspects of the world. So in computing, we began with the mainframe, and then there was this server-client architecture, and we are indeed getting into the peer-to-peer thing now with, you know, Napster, BitTorrent, and Bitcoin, and obviously Ethereum. Same with kind of governments as well. It kind of began with an anarchy, and then eventually there was some sort of king or emperor that gathered enough strength to enforce the rule of law over a sufficiently large amount of area. And of course, eventually they had to cede power because other structures were able to be built once that rule of law was in place. We ended up with like an aristocracy or a merchant class, and eventually we end up with something that approximates democracy. Same with distance sales, you know, the examples continue. And we end up with, you know, originally there were sort of back of the magazine, and then we had the internet with Amazon, right? But still only one matchmaker, one merchant. And then we got this marketplace idea where there's still a single matchmaker, but there are lots of merchants all operating within the framework. And probably eventually we're going to see a plurality of matchmakers, where matchmaking itself is a service that can be provided by a market. Same with communication.
And there is a theme here. We begin with nothing, we centralize in order to enforce these initial rules, and then we can decentralize once that structure is in place. We decentralize because it's more efficient, it's more scalable, and it's more resilient to attack. Ethereum commoditized trust. This is something that I think The Economist discovered last week. It's a bridge, you know, to cross these sort of boundaries of these swathes of land where there's internal trust but they don't really trust each other. And that's why we're going to find the initial use cases spawning from, because that's where it can really deliver value initially. We could call it indeed a platform for zero-trust computing. And in a way, Ethereum could be the court of the internet. Sort of interesting notion, where the internet can have its own sort of place to determine what is right or wrong, or when two people over the internet have an issue with each other, there is a lack of consensus, then Ethereum can step in.
In principle, Ethereum is a crypto law platform in this sense. It's a decentralized legal system native to the internet. We can implement these arbitrary social contracts and have people operate within them with nothing more than access to the internet. It's also a pivotal part of the notion of this serverless internet, right, the notion of like, whatever you want to call it, the post-node web, Web 3. It provides the zero-trust computing part. It provides the part that actually underpins all the stuff that we'd normally go to an authority, to a database sitting on a server somewhere. And with a bunch of other technologies, it can actually provide that infrastructure for doing massively multi-user applications in a truly different manner. So yeah, that's my thoughts on what Ethereum is over and above being a scriptable blockchain environment. Any questions?
