Crypto Radio Podcast guest Arthur Brock, the co-founder and visionary behind Holochain, explains the ideas and values behind the platform and what makes it different from blockchains.
Read Full Transcript

Euvie: Welcome to the show Art, how are you?

Arthur: I’m doing great, actually.

Euvie: Awesome. I wanted to talk to you about how you [00:01:30] came into the world of blockchain, because you’ve been involved working with alternate currencies and computing systems for a really long time. How did that journey happen?

Arthur: Yeah, as you mentioned, I’ve been engaged in the currency space for a long time. Actually, really tried to do some different things in that space. We have the Metacurrency Project which, as the name implies, is a little bit about going beyond currency as we currently know it. We often talk about currency as current [00:02:00] flow, the ability to see flows. We look at all kinds of things as currencies – like a college degree and the credits you use to get it, the grades that make the credits valid. All these things are symbol systems, formal symbol systems that we use together to track flows. We look at that as a significant source of collective intelligence in terms of how we organize ourselves on the planet.

Obviously, money is one of those things, too. Money has caused us to scrape off mountains to get to coal [00:02:30] and gold, different things like that, precious metals and diamonds. Literally, change the phase of the planet in very important ways. In some ways, we are deep currency hackers, using currencies as a tool for reshaping social collective intelligence. For us, it’s not just a tool for getting rich and gambling on markets, that kind of thing. We often set up some different kinds of patterns than you usually see for just gambling markets or just speculation. [00:03:00] We, out of the Metacurrency Project, built a prototype platform called Ceptr, short for receptor. That was our rebuild of the computing and communications and currency stack for optimizing human collective intelligence.

It’s totally weird and nobody gets it and it’s very hard for anybody to consider adopting it, because it shifts paradigms [00:03:30] in a bunch of different ways. As blockchain started gaining more traction and awareness and that kind of thing, we actually took one little piece of Ceptr out, the way that multi-instance receptors synchronize with each other, and made a standalone version of that called Holochain. We did that basically to go directly head to head with blockchain by bringing an architecture that’s inherently scalable, because it’s built on the same kind of patterns that nature uses, like how we have trillions of cells in our body coordinate [00:04:00] on massive scale. We’re replicating those kinds of patterns in Holochain.

Euvie: Right. It’s named Holochain but it’s not really a blockchain. How is it different?

Arthur: Blockchain is in a pattern that a lot of distributed computing is, trying to manage a global state on a single pattern, a blockchain, a chain of transaction blocks, essentially, a hashchain of transaction blocks. Then everybody has to synchronize and get consensus [00:04:30] about changes and all that kind of stuff. We think that this token centric or date centric focus of trying to have an inventory of data that everybody is trying to make consensus about any changes to is a wrong-headed way to approach it.

Holochain is agent centred, it’s more like the cells in your body. The cells in your body are not synchronizing against some global ledger. They’re not trying to internalize the record keeping of every state change of every other cell. [00:05:00] That would be completely unscalable. They internalize their own state and then they have communication protocols for coordinating a global space. In Holochain, every user, or agent, or device, depending on how you want to look at it – we’ll call it a node- every node has its own hashchain, not a blockchain but a simple hashchain where any state change that you contribute to the system is signed to your own chain [00:05:30] using your private key.

Then it’s published to published to a DHT, a distributed hash table, which is the global database for being able to discover these local state changes. It’s a validating DHT. Similar to blockchain, typically always has to validate changes to make sure that they’re following the shared rules of transactions or whatever the rules are about. A Holochain application has a set of shared rules. Any node of the DHT who receives the data to store it [00:06:00] validates that the data was produced properly. That’s just a different data integrity model where we’re saying, “Actually, data doesn’t have first order existence. Data is always asserted by a source, it’s always a change that’s being made from somewhere.”

Our data integrity model actually has to do with it being bound to that provenance and signed by that source in their linear order. One of the real advantages of that is that we, in general, don’t have to [00:06:30] construct an absolute time, which is what most of the energy of blockchain is doing. It’s trying to create some absolute timeline, so we know what order change has happened in so we can, for example, prevent a double spend of a coin. In Holochain, if you implement a currency the way we suggest, which is actually as an accounting system, basically crypto accounting, instead of tokens, then I have an account and you have an account. When we do a transaction, [00:07:00] we send messages to each other to construct it.

We each sign it to our chains and we hand each other the header with our signature of where we signed it into our chain as proof that we had agreement between us, that we both agreed to the transaction. It’s a double sign, not a single sign spend. We are the only two accounts in the whole system whose status changed. That means we don’t need anybody’s consensus. You never need consensus to change your own state. However, you will be held to account [00:07:30] for the state changes you make. If we hack our nodes to change the rules and do some fraudulent transaction that others wouldn’t validate.

We’ve forked ourself off into a different reality where nobody will play by our rules anymore. We’ve just basically cut ourselves off from everybody else’s validations. It’s actually a very strong validation model that doesn’t need consensus to produce timelines, because we know exactly in what sequence the transaction occurred for the only two people whose state was affected.

Euvie: [00:08:00] How do you prevent, let’s say, fraudulent nodes or malicious nodes from doing that kind of thing on purpose and splitting off, let’s say, a group of nodes split off in social terms, they would say, “Let’s start a cult. We’re going to split off and make our own set of rules and we’re going to validate all these transactions. Screw you guys.”

Arthur: What’s interesting is we’re not exactly trying to prevent forking like that. We actually think that forking in that manner could be healthy. [00:08:30] If a different people want to play it by a different set of rules, let them play by that set of rules. It’s no longer compatible with the other people playing by the original set of rules. One of the differences is you could say that, from some of the kind of anarch or crypto roots of blockchain, that designers of that architecture were trying to free themselves from constraints. Constraints of the government and that kind of stuff. A little bit what we’re trying to do is actually give us a capacity to constrain ourselves to operate inside of a chosen [00:09:00] set of constraints, like driving on the right-hand side of the road in countries where you drive on the right-hand, and driving on the left-hand side of the road in countries…

That’s a really useful constraint. It’s very helpful for helping us get to places faster and safer. We should be able to adopt constraints like that but they shouldn’t be able to be enforced by a third party, it should be the people opting in and co-creating and mutually validating that everybody is operating by the agreed upon constraints.

Euvie: [00:09:30] How do those constraints get decided?

Arthur: The constraints are decided essentially by the application developer and then by whatever update rules that they apply, which could be a single signature, benevolent dictator of that application developer updates the new rules or it could be an [inaudible [0:09:49] signatures, like a tech committee approves a new set of rules. It could be put to a vote. You can bridge between applications in all the chains. You can bridge to a voting app that contains [00:10:00] the update procedure, so you can make it as involved as you want for how to accept an official update. It basically has to do with making updates in the code, just like when you have new versions of Bitcoin software with new things that are validated in the code.

Euvie: Is there a single consensus mechanism in the network, or is it different for each app that is created and is that decided by the creator of the app?

Arthur: Holochain itself, there’s a couple [00:10:30] things that are very different about blockchain, other than the agents centredness. One is it doesn’t have its own token. We suggest it doesn’t need to. The other is it doesn’t have a consensus algorithm, a hard consensus algorithm. It has a little bit of a soft consensus algorithm in the form of DHT gossip, that when all the holders of a piece of data have signed that piece of data, you could say that they’ve reached consensus, that that data is valid. If you need to code something [00:11:00] that requires consensus, or for rival data, which we would assert for distributed applications, most of the data is non-rival data and you don’t need consensus on it.

What you need is validation. I think validation is underemphasized a lot in the crypto space. You can run different versions of Bitcoin software to mine Bitcoin, but everybody runs Bitcoin Core so that they’re doing the same validation rules. That’s actually the part that matters, because if they aren’t validating in the same way [00:11:30] then they risk forking themselves off into a different reality that others don’t accept. That’s the stronger part of the equation here. The reason that they have to do consensus is because they’ve created a token-centred or data-centred model and they also need absolute time for all state changes on it. When you are doing things in the Holochain, agent-centric manner, you don’t need consensus almost ever. In the few cases where you have rival data, let’s say, for example, when you download Holochain [00:12:00] it comes with a peer to peer Twitter.

In part, we just wanted to show that you can basically rebuild all the functionality of Twitter in a couple hundred lines of JavaScript on Holochain. It’s a very powerful, adaptive platform. The only rival data is your username. Anything else, it doesn’t matter if people happen to Tweet the same thing, “It’s a beautiful morning,” or whatever. Great. That’s not a problem that different people might tweet that at different times. We don’t have to have one winner who ones the, “It’s a beautiful morning,” tweet. We do need to have one winner who owns the username. Just because we [00:12:30] use the username as, basically, an anchor that we can attach links to all of the other data associated with that – where their posts are, who’s following them, who they’re following. That lets you retrieve by knowing somebody’s username, retrieve all the data that you need.

One of the weird things is if you were running Twitter on Twitter scale, of 330 million users across the whole planet, you could somehow create a massive partition between the hemispheres or something, between the [00:13:00] Americas and Europe and Asia, and keep running it for a week with the Transatlantic and Pacific pipelines down, satellites down. It would still keep running. Both continents would basically feel like they have Twitter, they just wouldn’t be hearing from people on the other hemisphere. They couldn’t directly message people on the hemisphere. If the partition was healed, everything would resynchronize across that partition and the only collisions you would have were new name registrations of conflicting usernames.

[00:13:30] The question is, “Do you need a hard-coded consensus algorithm?” What’s interesting is in blockchain, for most of the blockchains, they have an algorithm where the longest chain wins. If blockchain had been partitioned like that for a week, everybody would have moved forward as if life was good. Then when they reknit, whichever one of those chains had more transactions in it would become the real one and the other one would just disappear, would no longer be real. [00:14:00] All those trades that you thought were complete and you shipped out your goods or whatever, are now erased, they’re not part of reality anymore.

In Holochain, you would have these conflicting usernames and you could set different methods in the application for resolving that consensus, like do we want to put them up to auction and let the two people compete for the highest price? Do we want to give them each a release code, where they can sort it out with each other and release it to the other? Do we want to have a [00:14:30] reputation currency and the one with the highest reputation wins? Do we want to take the median time stamp from the network validations and try to come up with a ‘who did it first’ timestamp? You can do that type of stuff and it’s not hard to do in your application. We’re suggesting that that is a social function. That’s a function about the kind of culture of agreement that you want to make and it shouldn’t be hard-coded into the data integrity layer. Holochain is a distributed data integrity engine.

Euvie: That’s really, really interesting. Yeah, it makes sense. [00:15:00] What you’re saying is that we don’t need to enforce some sort of system wide consensus algorithm that it could be resolved individually if there are disagreements. I guess in that system you’re assuming that disagreements or these kinds of system going out of synch or pockets going out of synch, that is more an exception to the rule rather than the rule. Whereas, the blockchain seems to assume that would be the rule. If it has such a hard-coded consensus algorithm [00:15:30] it assumes that disagreements are going to happen all the time, right?

Arthur: Exactly. I feel like blockchain almost missed the point of its own architecture. What I mean by that is what is exciting about blockchain is separating data integrity from data access. Everybody wants to login to their banks website and change their ballots. If they could login and change their banks database, many people would want to do that. [00:16:00] The bank has their stuff all walled off. They have the access of that, the right access of that completely walled off. And the read access, you have to get it from the bank. You don’t hold your own data, you aren’t an authority for your own data. What blockchain and other distributed apps of Holochain is that they actually make it so that we can hold data collectively and have it be tamper free. We no longer need a centralized party in the middle.

That’s actually what’s, I think, the exciting thing about this, or allows us to create all kinds of new [00:16:30] patterns of collaboration and of software and of holding things together. We can literally rebuild Facebook without a corporation in the middle. On Holochain I think we will be able to get it to operate at that scale. We’re not quite ready for that just yet, we need to do some optimizations and more scale testing. I think it really actually can operate at that scale because of the structure of its architecture. What you’re saying is right, that if you’re looking at it as a platform for distributed applications and coordination, then it’s not all competitive data. [00:17:00] When you build a token into it that is a coin, then you’ve basically made the first application of this data system a competitive piece of data – a token that we have to manage consensus about. It’s focus has all been about the consensus and the competition over who holds these things. That doesn’t have to be the orientation.

Euvie: I watched one of your talks where you were talking about the different kinds of data and the different kinds of information [00:17:30] or states that a system can be in that are non-fungible, and actually that there are so many more of those than the fungible ones. That the fungible, or spendable, or competitive set of data is so tiny and often economics and cryptocurrency focuses on just this one tiny set of data and ignores everything else. Your example was with blood, for example, that in a human organism [00:18:00] blood is something that we produce an abundance of, to the degree that we can donate it or sell it, but that doesn’t take into account the whole human organism.

You don’t have other organs for sale necessarily, because you can’t regenerate another heart if you give it away. In this system, it’s not included because it’s not a fungible thing, but it should be included and should be taken into account. That was a really interesting way to put it. Can you elaborate on that a bit?

Arthur: [00:18:30] Yeah. You’re talking about the meta currency deep wealth model or living systems model of wealth we sometimes call it. We have a nice little diagram that talks about all these dimensions of wealth inside of a living system. Part of what we’re getting at with the imperative for increasing our collective intelligence is that we, at our current levels, are causing a lot of problems. We have planetary collapse happening in a lot of different layers, whether that’s [00:19:00] radioactive oceans, or soil depletion, or climate change. We can go on with a list of things and, in part, that’s because so much of our decision-making system, in terms of the feedback loops at the level of our social structures – our governments, corporations, and institutions – they’re driven by money and money is basically only operating at this speculative wealth or, at best, tradable wealth level. That tends to create an extractive relationship [00:19:30] to all the deeper layers.

It doesn’t contain enough information to actually manage the integrity of those deeper layers. What’s interesting is there are current seas, if you think about the way that I said that earlier in the podcast, that do operate at those deeper layers. I remember when food was just food, it wasn’t BO, or organic, or GMO free, or cage free, or grass fed, or hormone free, or fair trade. All of these different things that are [00:20:00] certifications to make a certain type of flows visible, like were pesticide sprayed to produce this thing – does it have poison on it, does it have poison built into its genes. There’s all kinds of things where if we don’t have the capacity of looking at the apple to know whether slave labour was used to pick it or whatever.

We’ve made these currencies to make those deeper levels of value visible. Part of what we are suggesting is that we need to do that and we need to [00:20:30] not just turn the whole world into gambling chips, because that creates an extractive relationship. Your first question was about how did we get into this. What I didn’t say is that one of the reasons that we got into it was actually to plot an intercept course with blockchain, because what we saw was that blockchain really only has one killer app and it’s tokenization. It turns everything into tokens and I don’t think we’re going to solve most of our large-scale problems by turning the world [00:21:00] into gambling chips.

I think that actually only perpetuates and accelerates the pattern of extraction, that is what is damaging these deeper levels, deeper layers of wealth in living systems. Smart contracts start to get at this, that there’s some rules or things that you could have be dependent on some of these deeper layers. When everybody’s incentivized just about how quickly we can extract, make some money on some exchange market for a token and you just tokenize stuff, [00:21:30] then I think it brings things down to the lowest common denominator which continue the pattern. It’s a little disappointing, right? Ethereum, there were these really beautiful, great promises about global computer and people were excited about, “We’re going to make a driver owned Uber that’s going to put Uber out of business.”

Then you figure out that it’s too expensive and too slow, you can’t put that computing on the blockchain. What it’s devolved to is, “We’re going to make Driver Coin and do an [00:22:00] ICO for our new centralized Uber alternative and somehow make a token that’s going to solve the problem.” I think we need deeper patterns of design behind that.

Euvie: How are you guys making your system scalable? Like you just mentioned, what people recognized with blockchain is that, in practice, a lot of those applications are simply too expensive to run and they’re not scalable and they’re slow. How are you guys tackling that?

Arthur: First of all, because [00:22:30] you’re the only one that can write to your chain, you can write to it as fast as you want. Then you share any public entries. We also have public and private entries, by the way, that you write to your chain. Public means it’s published to the DHT, the shared data lookup space for that application. DHTs are asynchronist with no botte necks. They gossip the data to other peers but your data was already signed to your chain. If you follow the rules, it’s valid and everybody else will eventually validate it. Not everybody, because you can shard it. [00:23:00] When I mentioned 330 million user’s Twitter, but if you only need 100 copies of every tweet out there on the DHT and there’s only 100 nodes that to hold it.

They don’t need 330 million holding it to have enough redundancy and resiliency to make sure that that tweet can be retrieved from the shared data space. DHTs are the kind of stuff behind most of the file sharing systems out there. BitTorrent is the first one that brought that into the popular domain. It’s actually a more mature technology than blockchain. [00:23:30] We already know how to shard them, we already know how to do things like prevent hot spots in the DHT, with certain cashing algorithms. You can do distributed sloppy hash tables they’re called, which basically says if it takes too long to reach a node that has it then you have to store it and it makes cashing patterns. You can do a lot of things for performance optimization, but there’s no single bottle neck. You don’t have to wait for anybody else.

Euvie: Right. Yeah, again, it goes back to that point that there are certain kinds of data that you just don’t need [00:24:00] a million other people to validate, because nobody else is trying to dispute that you tweeted, “Good morning.”

Arthur: Right, exactly. What’s interesting is there’s been about 50 or 60 apps built on Holochain, largely in the Hackathons that we’ve hosted around the world over the last year and a half. What’s fun is some of the different use cases. Actually, our student interns this last summer – not student, just interns, a lot of them were older… We actually had a very experienced intern group this year. [00:24:30] Our interns this summer built a Miner Sweeper game, which is like Mine Sweeper but has miner coin variants in there that have icons for Bitcoin and Ethereum and stuff that are the bombs that blow up.

Anyway, you can do a multiplayer Miner Sweeper game and have an almost real time play experience, where you can see other people’s actions happening. There’s a little bit of lag and sometimes it can be disappointing if you’ve marked a mine and you see your marker on it and then it changes to somebody else’s marker because they beat you to [00:25:00] it and then the minute synchronizes and changes back. There’s some times where you can actually see some of the effects of the lag by a few seconds. I’ve yet to see a blockchain app that can give you a real timeish gameplay experience. It’s interesting for us to provide something like that, so that people can actually see how fast Holochain can be.

Often, people talk about blockchain technologies in terms of transactions per second. With Holochain, there’s literally no [00:25:30] finite number. If you’re doing monetary transactions, then it’s the number of users you have divided by two is the max that you can have in any simultaneous moment doing a transaction, because you have to be doing a transaction with some other party. You can have that many simultaneous ones happening. If you have a billion years, then you have up to a half a billion simultaneous transactions that can be happening. The question is just if you’re outstripping the speed of gossip, how long it takes for the distributed [00:26:00] hash table to catch up with the information about the transactions. That we have not enough performance data on to give an answer about.

Euvie: Also, you guys have Holochain, which is the base layer that doesn’t have a currency and then you have Holo, which is a for-profit entity and an application for hosting. Can you explain the difference beyond what I just said?

Arthur: Yeah, exactly. I apologize about the branding confusion that sometimes comes out of that, because the names are so similar. Often, people [00:26:30] think that they’re the same thing. Holochain doesn’t have a token. Holo does have a currency. Holo is basically our way of trying to bridge Holochain applications to mainstream users. What I mean by that is if you built an Air BnB alternative on Holochain as a peer-to-peer app, well, off Holochain everybody actually has to run their own node and they write to themselves and they host themselves. If you build a web UI and you literally open it up pointing at [00:27:00] local hosts and you are your own server, right.

With Holo, this lets you take your Fair BnB app and bridge it to grandma who is searching for a vacation and wants to find a place to stay who just wants to type an address into a web browser. She’s not going to install some next gen crypto app. It builds a bridge between mainstream web users and next gen crypto apps by allowing some bodes to carry more than their share by extending virtual Holochain space to others. That’s basically performing [00:27:30] hosting services. We think that we can scale this massively, given the architecture of Holochain, such that we could really become the Air BnB of the cloud hosting space where, in the same way Air BnB sells more bed nights than the largest hotel chains but has never built a hotel, we think we could actually compete with volumes of hosting of the Amazons and Googles, that kind of thing, without ever building a data centre by actually tapping into existing computing power.

[00:28:00] We also had an Indiegogo campaign where we sold some little hosting boxes that you could plug into your internet router. We had a nice stable foundation of boxes to start with that were always on. Holo has a currency and it’s the bridge to the mainstream, and it’s semi-centralized because we have to do things like resolve DNS. There are points of centralization to this, because there are points of centralization to the old web – like domain name resolution. But Holochain is completely peer-to-peer, completely decentralized, and Holochains are [00:28:30] non-profit, which is the whole owner of hope. In some way, also, Holo is the revenue model for this open source infrastructure project2 that is Holochain.

Euvie: Does Holo have APIs and the ability to connect other distributed systems to the old systems, or is it only for Holochain?

Arthur: Holo is for Holochain apps. If you have an app that you’ve built for a centralized platform or even for another blockchain, [00:29:00] you would probably have to rearchitect it to an agent-centred approach to run it on Holochain. However, the UI may not need to change at all. One of the things that we’ve encouraged people to do, in fact, is to use a middleware layer. We have a lot of different UIs people have built on Holochain using react-redux or using vue.js or jQuery or vanilla java script, or just whatever framework you want to use for your new eyes, do that. Then have a middleware piece that makes the calls to the back end [00:29:30] and that decouples, so you could even have been calling a centralized database before but now you’re going to be calling a completely peer-to-peer mutual validating data engine. You’re going to have to rewrite that data engine with the validation logic for peers to validate each other, that kind of stuff.

Euvie: The reason why I ask that is because it seems that with a lot of these new applications and new systems, it’s like a cell, the more dendrites it has that can connect it to other types of cells the more [00:30:00] likely it’s going to survive because it can interface with other things that are already there. Even if you guys aren’t building the APIs for Holo to connect with other types of distributed systems, are there other people maybe building them? Is that part of the open source structure of Holochain? Is that something that people are thinking about at all?

Arthur: There’s a couple things about that. One thing is that we have tried to make this as accessible as possible to existing developers [00:30:30] by using existing languages, like java script. The new version of Holochain built in Rust – the old version was built in Go – the new version is using web assembly and there’s a bunch of different languages that compile to web assembly. Instead of needing special smart contract language like Solidity or something like that, you can program in a familiar language and compile it into web assembly to run on Holochain. What that also allows us to do is to run it in web browsers and also, the [00:31:00] new version of Holochain on Rust compiles to run on mobile devices and tablets.

We are going mainstream I think, or targeted going mainstream, in a way that I think most blockchain systems aren’t and can’t. For one thing, it’s very lightweight. We’ve tested running up to 100 nodes on a single raspberry pie with two gig of ram. You can do things on a scale that you can’t do in most blockchain apps, even Iota, which claims to be an [00:31:30] internet of things chain takes 64 gig of ram to sink with the tangle, to connect with the tangle. I don’t know of any internet of things devices that have 64 gig of ram, that’s not really a scale that they can run these things on. What that means is it’s very easy to run a Holochain node on your Ethereum node because it’s super lightweight.

If you want to make API bridges and calls in between, you can do that with just writing a [00:32:00] little java script API type thing in Holochain. We think that that’s going to create some advantages for Holochain apps being able to bridge easily. We already have a few different groups that are starting to build decentralized exchanges on Holochain, because of the performance and the fact that you can actually just make a node that can run on whatever other chain system, the node of another chain, so that it can directly bridge things between those two worlds, if you will. The thing that I think you’re talking about is [00:32:30] really what Ceptr was designed for, because Ceptr is focused on this receptive capacity exactly for composability.

One of the things that it has is a self-describing protocol stack. We have made a universal power surfer protocols that allows protocols to be plugable, chainable, nestable, you can really compose with protocols very easily and make things talk to each other very easily. Holochain doesn’t have that and probably can’t exactly have that but we’re trying to, at least, make it as accessible as possible.

Euvie: [00:33:00] What is the current technical relationship between Ceptr and Holochain? Are they one inside of the other, are they in parallel, or is one more still in an envision stage? How does it work?

Arthur: Yeah. Ceptr, we did a lot of prototyping of the components of it. It’s shelved at the moment while we work on getting Holochain out there, because we think Holochain actually is ripe for adoption and Ceptr’s not. We view in our longer-term strategic path [00:33:30] Holochain as a bit of an onramp to Ceptr. If people see, “These guys were thinking in a different pattern and it really worked, this is really valuable. Maybe it’s worth learning some of these other patterns of crazy things that they’re saying how we should change computing.” I think people need to have some real reasons to consider the kind of changes that we’re talking about in Ceptr. I also think that the benefits are totally worth it, like composable protocols. Protocols right now, the greater adoption they get the harder they [00:34:00] are to change.

IP v4 – internet protocol version 4 – we knew shortly after it came out that we needed to replace it, that it had insecurities, that it didn’t have enough addresses and that kind of stuff. Meanwhile, still, the bulk of internet traffic, 30 years later is on IP v4 because it’s just hard to change these things. Being able to have protocol changes be plugable is a very different world. I think it’s part of what we need for the kind of collective intelligence that we need, [00:34:30] instead of the brittle world of, “Make one change to your API and everything breaks.”

Euvie: Yeah. Actually, in blockchain it’s even more rigid, where changing that protocol is extremely difficult once it’s out there.

Arthur: Yes, exactly. In fact, part of the intention behind smart contracts and stuff like that is a permanent, immutable, unchangeable pattern. It can’t be changed.

Euvie: What kinds of applications is Holochain best suited for? What kinds of systems currently?

Arthur: [00:35:00] I think the sweet spot for Holochain, in the early stages, are social media and communication collaboration type things. We already have a bunch of groups creating social media networks, Facebook alternatives, that are targeting different niche communities. I already mentioned we have a peer-to-peer Twitter. We’re not trying to market that as a serious app, we’d love somebody else to take that on. We just wanted to have a sample that was easy for people to understand. LinkedIn type thing, referral networks, that kind of stuff. Basically, any app [00:35:30] where the users are the source of contribution. The real advantage there is users still get to own and control their data, then publish it to a shared space.

They also get to control their identity. As we have these Facebook breaches and abuses of power of these centralized systems, people are getting increased incentive to be in a system where they have more control of their stuff. I think that’s a real sweet spot, even Wikis, which are largely user contributed content. [00:36:00] We have a couple Wikis that people have built on Holochain. I think that’s some of the early stuff. I think we’re going to see more things as people believe in the security model in that kind of thing, where we can do value chain, supply chain accounting and things like that.

The way that we recommend implementing currencies on Holochain is really crypto accounting. I think there’s a bunch of advantages to that, because accounting is legal everywhere. I think we can navigate regulatory climates very differently by having there be [00:36:30] basically an immutable, cryptographically signed record of accounting. You’re only increasing accountability and auditability, you’re not creating some crazy, new, risky token security blah blah blah, right? Anything that can be a unit of account, whether that’s kilowatts or pounds of food, whatever, can become a currency in that context. You have shared validation rules for managing it.

Euvie: What would you like to say to wrap up? What are you guys working towards right now in Holochain and how can [00:37:00] other people get involved if they want to?

Arthur: We are working on relaunching Holochain. We did a few alpha releases in Go and then we rebuilt in Rust for a few different reasons. I’m not going to go into all of the strategic reasons at the moment, because some of those deals aren’t inked. We’re looking for Rust developers, we’re looking for app developers, if you can write java script or if you like building UIs. It’s really quite easy to build on Holochain. We’ve made some rapid application development tools, scaffolding tools that basically it’s almost [00:37:30] like a wizard. You can answer some questions and it generates your files and directories for you that you then can go in and tweak the code. It gets you up and running pretty quickly. It even generates tests for you and generates a UI for you, that kind of thing, really basic stuff. An ugly UI, not an end-user UI, a developer UI.

It really is easy to bootstrap. We are probably going to also be setting up funding for some of these projects at some point, because we need to [00:38:00] grow the whole app ecosystem on Holo and Holochain. Our focus has really been just having our heads down, getting to launch on that. People who want to build, we support developers and builders. Right now, we need builders.

Euvie: Awesome. I think that’s what the whole distributed system space needs right now.

Arthur Brock, the co-founder and visionary behind Holochain, explains the ideas and values behind the platform and what makes it different from blockchains.

We also explore his background and work before Holochain, with Ceptr and Metacurrency projects.

Holochain is a peer-to-peer scalable application platform. The unique thing about Holochain is that its architecture is designed to mimic living organisms. Each user on the network has his own ledger, which can operate independently or interact with other users.

What we cover in this episode:

  • Looking at currencies as symbols that track the flow of processes
  • Using currency as a tool for reshaping collective intelligence
  • Understanding Ceptr project, which was a prototype for Holochain
  • How nature inspires the architecture of Holochain
  • The main differences between blockchains and Holochain
  • What is DHT – Distributed Hash Table and what is DHT “gossip”
  • Why Holochain chose not to use tokens in its architecture
  • Consensus mechanisms and creating rules on Holochain
  • The Metacurrency Project and the Deep Wealth model
  • How scalability works of Holochain, and its main applications
  • The difference between Holo and Holochain

Mentions and Resources:

This episode is hosted by:

 

13 Shares

Log in with your credentials

Forgot your details?