back
2 comments
Nothing that is not as easily done with a database. Once you remove the proof of work which enables pseudonymity you are left with a kind of replicated database.
tl;dr -- private blockchains make it possible to distribute a common piece of infrastructure between businesses with competing interests. The sit between the stream of new inputs and the database.

I've built one of these types of systems (kadena.io). The key differences between a replicated DB, though let's use consul instead because it's closer to a private/permissioned blockchain (distributed) and the differences are the same, are two-fold:

#1 They are designed to run in a multi-administrative context (i.e. where you don't own all the servers). Imagine running consul where you only had direct access to 20% of the nodes. You could do it, but you'll eventually have problems as it's possible for a few misconfigured servers to slow/halt/collapse the cluster. The problem is that in multi-admin you can't directly fix the troublesome servers. The system itself needs to be robust against them -- you need BFT consensus (for this and other reasons).

#2 The killer feature of private blockchains is having a smart contract language. It allows you to write and run code that runs on my servers without me having to trust/audit your code. This is only possible because of the frankly ridiculous level of security that the system provides. It is also a fundamentally new feature. For a new language that's actually appropriate for serious work (which EVM-based langs are not) take a look at Pact on the aforementioned site.

Simply, if you want to be able to host logic and data, with the infrastructure distributed among multiple administrative units (businesses/firms) that don't completely trust each other, then you end up building a "private blockchain". You need a decentralized way to replicate new information (consensus), that is robust against bad nodes (BFT), that linearizes the new information (blockchain-like), that can execute logic on your machine written by individuals that you don't trust (smart contracts), that tracks/enforces auth at every level (PPK-Sigs everywhere!).

> The killer feature of private blockchains is having a smart contract language.

A contract language has nothing to do with blockchains. All you need is a well-defined interpreter, whose interpretation all parties agree represents "the truth", and all that's left is entering into a legally binding contract which states these terms plus the "smart contract" in question.

Ethereum showed very well what happened when people enter into a non-binding (by the legal system) smart contract: they refuse to abide by the decision by retroactively modifying the interpreter to interpret the contract in their favor. And why wouldn't they?

> A contract language has nothing to do with blockchains.

In a strict sense, you're right. All a smart contract language needs to run is a linear set of inputs. However, they have a lot less utility without the other parts of a blockchain (distributed, crypto-data structure for assurance, etc.). If you don't care about being distributed, just use an API or run the external code in a container/vm.

> they refuse to abide by the decision by retroactively modifying the interpreter to interpret the contract in their favor. And why wouldn't they?

While I don't agree with the hard-fork decision, I understand (from a biz POV) why they did it. They didn't have too many options. Either hard fork or let the "hacker" collect the prize. IMO this lack of options was a failure of the EVM and solidity language itself.

While the DAO debacle had a bunch of causes but the main problems, from a language point of view, were: (a) centralized governance (upgrading/migrating) of a live contract isn't a first class citizen in solidity, (b) there's no distributed governance mechanism at all, (c) formal verification of solidity contracts is still years away.

Pact has (a) already and we'll be upgrading it to handle (b) as well next month (via a weighted vote mechanism). Either of these would have at least been able to mitigate the impact of DAO's issues -- just upgrade the contract and migrate the table the contract is guarding. Pact also has (c): https://youtu.be/Nw1glriQYP8?t=1072

> It allows you to write and run code that runs on my servers without me having to trust/audit your code.

So basically it's a hilariously slow and wasteful equivalent of Heroku. Amazing.

If you're thinking about the EVM's take what smart contracts should look like then you're 100% right. General, replicated computation is a good first step but a poor idea long term.

Blockchains, both public and private, are really just distributed DB's. You wouldn't fold a protein or price an option in your DB, you'd use some external system and save the results to the DB. The same line of reasoning goes for blockchains.

This is why we made our own language from scratch -- Pact is a bit like regular SQL + procedural SQL + programmable auth. It's not Turing complete and can compile to Z3 for formal verification. Given that every execution is a transaction, and it's interfacing with a normal DB, it's performance bottleneck is are the underlying DB itself.

A project I'm working on at work is utilising it for confidential computing between a number of parties that want to share data between themselves, but are direct competitors and don't trust each other.