Image by Pete Linforth from Pixabay

The assessment whether blockchain could be a useful technology for a company is obscure for many decision-makers. Yet, it is possible to make this decision without being familiar with the complex techniques to implement blockchain. In this blog I describe in plain language what you gain and what you don’t gain when choosing blockchain, without diving into technology.

Blockchains are not important

The essence of blockchain technology is not the blockchain data structure, but its decentralized nature. In centralized computing, one or more computers perform a task under central coordination. In decentralized computing, two or more computers perform a task without central coordination.

 Why would you want to do decentralize computations? The traditional reason is fault-tolerance. If you control an airplane by an autopilot, you don’t want to depend on a single system but fit the airplane with two or three of them. Decisions will be made by consensus across the automated pilots.

These systems are not literally fault-tolerant. They have reduced the chance of failure considerably, but not to 0.

The architects of cryptocurrency systems have a similar reason for decentralization: lack of trust. They do not trust a bank to handle our financial transactions, and therefore cryptocurrencies do away with banks. Instead, require that (in theory) all cryptocurrency owners maintain the administration of all transactions themselves and synchronize this.

As for fault-tolerance, cryptocurrencies are not totally trustless. But they reduce the required amount of trust in other actors considerably compared to a centralized solution.

In both examples, we do not trust the correct functioning of a single actor. To reduce the risk of an actor performing a task incorrectly, we replicate the task to be performed over a network of actors without central coordinator. But when does an actor perform a task correctly?

What is “correct”?

The shortest definition is that an actor is performing a task correctly if it performs the task according to specification. An autopilot must perform exactly according to specification and do nothing else. A bank must perform transactions exactly according to specification and do nothing else. For example, it should not refuse a transaction, transfer money incorrectly, or lose any trace that the transaction has taken place.

The notion of correctness is central in decentralized computing. It assumes that there is a specification of how a task must be performed and does not assume anything about the validity of this specification. To correctly perform a task is to perform it according to specification. I return to this below.

First, I want to point out that the choice between centralized and decentralized computing is a cost-benefit-risk tradeoff. Suppose that

(1) we do not trust that the actor will always perform a task according to specification and

(2) we do not accept this risk.

In other words, the benefit to be produced by performing the task correctly is worth the additional cost incurred by reducing the risk that the task is performed incorrectly. Then we can reduce this risk by duplicating the task over two or more actors and synchronizing their task execution. This increases the cost of task performance but reduces the risk of incorrect task performance.

What are these costs? Without a central coordinator, the actors need to perform considerable work to reach consensus on a correct output. Let’s look at the extra work that results by replicating a task without central coordination.

If you decentralize, you need consensus

In decentralized computing, the actors are nodes in a network. The consensus problem in decentralized computing is that we don’t know if all nodes in the network are performing correctly. There is no magic solution to this problem. Algorithms exist that can guarantee correct task performance by the network as a whole if a certain percentage of its nodes are functioning correctly.

For example, an algorithm called Practical Byzantine Fault Tolerance guarantees correctness if at least 2/3rds of the nodes function correctly. This algorithm does not scale well beyond a few dozen nodes in the network. Another algorithm, called Proof-of-Work, is used in the Bitcoin network and guarantees correct functioning of the network if no node has more than 50% of the total computing power of the network. If we trust that these conditions are satisfied, the network as a whole will perform its task correctly.

What is it that these algorithms achieve? Three things:

  1. Termination: in each correctly functioning node, the computation will terminate.
  2. Uniqueness: If correctly functioning nodes terminate, these nodes will all terminate with the same result.
  3. Validity: The result with which correctly functioning nodes terminate, is correct (computed according to specification).

This needs some explanation. Let us start with the third property.

Validity is really non-repudiability

“Validity” is too suggestive a word for the third property. In the virtual world of cryptocurrencies, it means that the virtual coins that I transfer to you were mine, and not yours, before the transfer and are yours, and not mine, after the transfer. And in the world of databases and control systems, it means that the data is manipulated according to specification. For example, data about the location of a shipping container will be interpreted as location data and not as, say, the temperature of the container.

But the computers cannot check whether the location sensor is functioning correctly, nor whether the sensor input is mistakenly connected to the temperature sensor. The relation between data and reality is out of sight for the computer. This is the case for all computers, and so it is the case with a decentralized network of computers.

Saying that the result of a computation is “valid” does not mean that it is meaningful. The most we can say is that the output has been computed according to specification.

In terms of transactions, if a computer has registered a commercial transaction correctly, we cannot deny that it has registered the transaction. The registration is correctly stored in the computer’s state. In the cryptocurrency world, where a transaction is performed in the computer and nowhere else, this means that we cannot deny that the transaction took place. This is called non-repudiability.

These observations apply to single computers and to decentralized networks of computers that replicate a computation. Blockchains nor other decentralized systems do not change this.

Validity implies noncensorship

A desirable property in cryptocurrencies is that the network cannot refuse to perform a valid transaction. If I own the coins, and I transfer them to you, then the network will transfer them to you. Cryptocurrency networks (nearly) guarantee this, but banks do not. For example, banks can refuse transactions from terrorist organizations. Cryptocurrency networks (almost) guarantee the performance of valid transactions.

Almost, because by coordinated action of the people running the nodes of the network, they can halt the entire network and roll it back to an earlier state. This happened in the well-known DAO disaster. Also, the guarantee of noncensorship does not extend to the edges of the cryptocurrency network. Cryptocurrency exchanges are regulated and can refuse transactions.

Termination implies finality

The first property guaranteed by consensus algorithms, listed above, is termination. Correctly functioning nodes will all compute a result. They will not compute forever. And according to the second property, they will all terminate on the same result.

In terms of transactions, this implies that the next transaction must start from the agreed-on result of the previous transactions. In the financial world this is called finality. Once the transaction is performed, it is final and cannot be revised. Of course, we can perform a new transaction that compensates the earlier transaction, for example by returning the money to the original owner. But we cannot make the earlier transaction disappear.

Banks guarantee this property because they are regulated and want to maintain their reputation. Bitcoin realizes it after about 6 blocks of transactions have been processed, which takes on the average about 10 minutes.

In a nutshell

To conclude, if we do not trust a single node to perform a computation correctly, we can replicate the computation over a set of nodes and have them use a consensus algorithm. This reduces the risk of an incorrect computation but raises the cost of the computation. The benefit to be achieved by this is that we can be more confident that the computation is correct. This means the following.

Correct computations

  • take place according to specification,
  • cannot be censored (when triggered they will take place),
  • are final (after the computation produced a result, the result will not be changed), and
  • cannot be repudiated (it cannot be denied that it has been done).

Correct computations, whether done by one or replicated over more computers, do not check the quality of the input (which may be rubbish) nor of the specification to which they comply (which may be wrong).