Understanding Basics on Blockchain and use cases

Navigating in the blockchain space can be very challenging.
A large number of articles has been written on the subject, many of which are full of a large amount of hot air and hype, as well as technical technicians and other technical jargon.

In this article, we will explain the difference between the two main branches of blockchain projects (public and private) and some fundamental technical terms related to the area.
This will allow us to answer a fundamental question in the current discussion on blockchains and related solutions: what are the valid use cases for the use of a public blockchain, without trust, against a distributed private ledger? to a traditional database?

Some of the most important terms used in the blockchain space are:

• Trusted third party – A system in which certain facts (for example the identity of the participants) can not be verified except by referring to a privileged (often centralized) authority.
• Trustless – A system that does not rely on trustworthy third parties for any aspect of its operations, including transaction confirmation or identity verification.
• Proof of Work (POW) – Find the solution to a mathematical puzzle (typically a hashing problem) that does not have a shortcut algorithm and therefore must be resolved by the brute computational force.
• Non-converted transaction output (UTXO) – In some blockchains (such as Bitcoin), transactions consume inputs and leave some (the outputs) _unspent_. These unspent outputs are therefore available to become inputs for future transactions.
• Virtual machine model – Some blockchains (in particular, Ethereum) have an abstract model of how the overall state of the system is represented and how this status is updated. This model can generally be described by a formal model of a virtual state machine, such as the Ethereum Virtual Machine (EVM).
• Smart Contract: a small event-based program that can be implemented in a blockchain that supports program execution. Once implemented, the program will continue to run, using blockchain transactions as input and may take actions that cause further transactions to be performed. The program code is cryptographically protected.
• Turing-complete – A computer term that can be read as a "fully capable programming language". All mainstream languages ​​such as Java, Javascript, Python, Ruby, Go, etc. They are all complete with Turing. For technical reasons, some blockchains may choose not to make full power of Turing's full languages ​​available to intelligent contractors.

There are many more details on each of these terms, but some of the most important aspects of them are as follows:

1. Most transaction systems depend totally or partially on trusted third parties. The lack of trust, on the other hand, is a rather remarkable property, but it is not obtained at low cost – a considerable extra complexity and the effort must be spent to ensure that a system behaves without too much confidence. The key to this is the POW algorithm for consent used by many blockchains.
2. Once a solution has been found to a POW problem (essentially for large scale attempts and errors), the correctness of the solution can be immediately demonstrated by any participant. Good POW problems have statistical properties that allow any observer to reliably estimate how much computing time has been used to run into a solution. This makes them suitable for use as a consensus mechanism distributed in public blockchains (eg Bitcoin).
3. The UTXO model provides a simple path to ensure transaction integrity and to prevent the same Bitcoins from being used twice in two separate transactions (the double-expense problem). This is ensuring that any input for any transaction should appear in the output collection – the UTXO database.
4. In contrast, the virtual machine model (in particular implemented by Ethereum) offers a significant extension: the ability to store arbitrary status and the execution of simple programs within the network in a reliable and completely decentralized.

With these main definitions (and some consequences) clarified, we can now take a look at some of the major blockchain-based technologies currently in use in the world.

Bitcoin

The original cryptocurrency, which uses the unused transaction output model (UTXO) for the ledger. It uses a simple POW algorithm for mining, based on the assumption of a random string that, combined with the last transaction block, causes the SHA-256 hash of the composite to be numerically lower than a threshold value small.

The participant who guessed the answer is said to have "pulled a block" and the transactions that were contained in the block are added to the ledger.

This therefore allows a very simple method for determining consent: the participants simply agree that the longest chain should be considered the basis for the extraction of the next transaction block.

Bitcoin was not designed to accommodate smart contracts. As a result, extremely limited features are available, primarily through the novel use of lateral channels that exist within the protocol. The resulting functionality is in no way complete for Turing and instead most Bitcoin analyzes simply ignore it.

The resulting system is therefore purely that of a cryptographically secure ledger.
It does not have an identity semantics beyond the use of cryptographic signatures to verify the origin of transactions and is completely without trust.

Ethereum

This ledger is based on some Bitcoin ideas, but it models the status of a single global virtual machine instead of using the UTXO model. The key innovation is the addition of a complete Intelligent contracting capacity to Turing. This is the virtual machine Ethereum (EVM), a VM created specifically for use in the context of a ledger distributed with smart contracts.

In Ethereum, the status of the program is private and belongs to the individual addresses of the contract and is modified by a series of EVM bytecode instructions, which are the contents of the smart contracts.
The overall global state is then obtained by aggregating the program status of each contract address.

All complete nodes in the Ethereum network follow the rules of the model. They can calculate the status of the system for any contract status on their machine and as long as they use the same transactions (which constitute input data within the Ethereum model), they will come to the same result.

Because Ethereum uses a global consensus algorithm and has a more recent blocking concept globally, the overall processing speed of the transaction (that is, the actual _clock speed_) of the Ethereum virtual machine is limited by the production speed of the blocks. Adding more hardware and computing power to the Ethereum network does not make it faster or more powerful, simply more tamper-proof.

The use of Intelligent comprehensive contracts with Turing allows you to add additional features on the network without all participants having to be aware of such problems. This allows, for example, the Ethereum network to issue software tokens that are considered as additional status within the Ethereum virtual machine. This forms the basis of the so-called Initial Coin Offerings (ICOs).

The EVM is superficially similar to the JVM and similar environments, but creates different designs in some important areas. In particular, the design of EVM bytecode makes static analysis of compiled code much more difficult than established alternatives. This is not a point of sale for an execution environment that requires a high degree of transparency and verifiability.

The low-level EVM environment is also not a particularly environmentally friendly programming environment. As a result, several higher-level languages ​​have been created that are compiled into EVM bytecode. Of these, the best known is Solidity.

Inspired by other mainstream programming languages, such as Javascript and Java, the Solidity language also incorporates new features to interact with the Ethereum blockchain.

In some respects, Ethereum is a victim of its own success. Its appearance as a platform of choice for ICOs led to a high price for ETH (the Ethereum token) at the start of 2018. The amount of this cryptocurrency held by the Ethereum team led to a situation where many of the major players have a large share of interest in the status quo and wanting to make the profits of the card.

Rope

R3 Corda uses the UTXO model (like Bitcoin) but also includes the complete Smart Turing contracts as part of the project. These contracts are represented as JVM bytecodes, with optional additional determinism that limits the semantics of the contract.

The approach does not use a single global block (block height) to control the progress of the ledger status, but instead allows non-conflicting transactions to proceed in parallel. This effectively refines the lock, at the cost of requiring a more complex and subtle notion of time and clocks. In the Corda model – the simple rule of the "longest chain wins" is no longer sufficient as a consent algorithm.

The participants are known and reliable, as the verification of the identity of third parties is a natural part of the Corda architecture.

As a side effect of the desire to remove the global ledger lock, Corda includes exit / entry semantics to untangle the transactions from the main chain and prevent all transactions from intertwining over time. This is possible because the architecture strongly depends on the trusted third-party model.

As a result, the authority of some participants to withdraw the accounting items (the equivalent of coins in cryptocurrencies) and replace them with coined equivalents that do not have transaction history can be guaranteed by the identity authorities.

The creators of Corda do not see it as similar to a cryptocurrency.
Instead, they consider technology to be the basis of a shared infrastructure at the level of the whole market, rather than at the level of a single company. [link to panel part 2]

This places Rope as a corporate blockchain intended to be used by organizations that can benefit from a common infrastructure and a shared vision of the state of the world, rather than maintaining separate versions of records, which inevitably leads to reconciliation problems.

HyperLedger

The HyperLedger project, initiated by IBM, is another of the leading blockchain enterprise solutions.
Hyperledger Fabric is an implementation of blockchain frameworks and one of the Hyperledger projects hosted by the Linux Foundation.
The main design goals of IBM for the project include confidentiality, resilience, flexibility and scalability.
Like Rope, Hyperledger uses an authorized architecture.
Implement a deterministic algorithm Practical Byzantine tolerant algorithm (PBFT), which ensures that, once a completed transaction notification is received, it is actually performed.

IBM has invested in the solid Docker integration, including in-container testing.
Smart contracts for Hyperledger can be written in Java, with an available SDK (Go contracts are also possible).
Hyperledger separates nodes based on roles, including full peers, certification authority nodes (required for authorization), and orders that group transactions into chunks.

The blockchain status of Hyperledger is modeled as an archive of key-values ​​version (KVS), where keys are names (strings) and values ​​are arbitrary blobs.
This is a low-level interface, above which Hyperledger provides a layer called Ledger, which provides a verifiable history of all successful state changes.

The code and architecture of Hyperledger are still evolving rapidly, but actual production trials are starting to appear and it is joining Corda as one of the most likely solutions used by companies.

Cases of use

The cases of use for blockchain are still the subject of heated debates.
This is the obvious example of censorship-resistant digital currencies.
However, the volatility and fragmentation observed in the cryptocurrency market in 2018 seem to suggest that the effective applicability of digital currencies without trust is limited.

From a business standpoint, it is becoming clear that they can also be used to create systems or networks that are implemented as a construct shared between multiple entities that do not necessarily trust one another, but want to share data and maintain a form of consensus on concerns that affect all parties.

These use cases, in which a centralized authority is unacceptable to the participants, or too expensive to set up, are still emerging.
This despite the time, efforts and venture capital that have lined up in the wide range of blockchain projects created to date.

As more projects enter the market in 2019, it remains to be seen if the promise of blockchain will ever be equal to the greater impact that its supporters have promised for some time.

About the author

Ben Evans is a co-founder of jClarity, a JVM performance optimization company. He is an organizer of the LJC (London & # 39; s JUG) and a member of the executive committee of JCP, which helps to define the standards for the Java ecosystem. Ben is a sample of Java; 3-time JavaOne Rockstar Speaker; author of "The Well-Grounded Java Developer", the new edition of "Java in a Nutshell" and "Optimizing Java", he is a regular speaker on the Java platform, performance, architecture, competition, startup and related topics. Ben is sometimes available for language, teaching, writing and consulting – please contact for further details.