Comparing blockchains: Ethereum vs Tezos
Tags: blockchain, ethereum, tezos
Published: 2022-07-07 11:48:44

by [Jude Miracle](https://blog.openreplay.com/authors/jude-miracle)

Developing a blockchain framework might be too expensive and time-consuming. Some large companies may choose this path, and some might decide on using existing and well-established blockchain technologies as the foundation of their method. When choosing a blockchain for your project, it is good to consider some of the factors these blockchains offer. Both Ethereum and Tezos are decentralized ledgers that allow the development of DApps on top of them. However, there is a different experience when using these blockchain technologies: that is what we will cover in this article.

This article compares the developer experience between Ethereum and Tezos in building decentralized applications. In this article, you will learn the basics of Ethereum and Tezos and a detailed comparison between the two popular blockchain technologies. This article will give the reader insight into which blockchain technology they would love to learn and use for their next project.

## What is a blockchain?

[Blockchain](https://en.wikipedia.org/wiki/Blockchain) is a decentralized virtual database that is secure and distributed across multiple nodes of computer networks. Anything on the blockchain is stored electronically in a digital format, guarantees the faithfulness and security of information, and generates trust without a trusted third party.

The blockchain collects information in groups known as blocks that hold a set of data. Each block is closed and linked to the previous block forming a chain of blocks known as a blockchain. It makes the blockchain difficult to hack or modify.

## What is Ethereum?

[Ethereum](https://ethereum.org/) is a public, open-source blockchain that supports smart contracts and cryptocurrency trading. Unlike Bitcoin, which supports the transfer of Bitcoin tokens around the network, Ethereum is a more general purpose, and its native token is ETH.

Developers can build DApps ([decentralized applications](https://en.wikipedia.org/wiki/Decentralized_application)) that can be executed on the Ethereum network. DApps are built on Ethereum using its programming language, [Solidity](https://en.wikipedia.org/wiki/Solidity). You can write smart contracts using Solidity and deploy smart contracts to the Ethereum Network.

Ethereum was initially proposed in 2013 by [Vitalik Buterin](https://en.wikipedia.org/wiki/Vitalik_Buterin), a young programmer and co-founder of Bitcoin Magazine. It maintains consensus across all the computers in its network with [Proof of Work](https://en.wikipedia.org/wiki/Proof_of_work) (PoW). Soon, Ethereum will move to a [Proof of Stake](https://en.wikipedia.org/wiki/Proof_of_stake) (PoS) mechanism.

## What is Tezos?

Unlike Ethereum, [Tezos](https://tezos.com/) is a public, open-source blockchain protocol that leans on low power consumption and energy-efficient consensus.

Tezos is a self-amending governance blockchain that can upgrade itself and develop smoothly. Upgrades to the core protocol and self-amending process are decided upon by people who hold and stake some Tezos coin.

Tezos is also fundamentally designed to provide code safety through Formal Verification and evolve without requiring a hard fork. Its coins are in the marketplace under the symbol of XTZ, also known as a Tez (**ꜩ**). It maintains consensus across all computers in its network with [Liquid Proof of Stake](https://opentezos.com/tezos-basics/liquid-proof-of-stake) (LPOS).


## Differences between Ethereum and Tezos

There are several similarities between the two projects, but there are also differences.

### Consensus Mechanism

The [consensus mechanisms](https://ethereum.org/en/developers/docs/consensus-mechanisms/) are not directly related to building DApps, but understanding them will help you grasp other concepts and the fundamentals. The consensus mechanism allows all nodes on the Ethereum Network to agree on the current state of the blockchain and secure the network against attacks.

Ethereum was the first blockchain to introduce the ability to create smart contracts, to build DApps, and also one of the first to make use of the proof-of-work consensus mechanism after Bitcoin. Ethereum proof-of-work consensus mechanism relies on miners to solve complex computational problems. The miners earn rewards for the functions they perform for the network.

Tezos makes use of a liquid proof-of-stake consensus mechanism. In Tezos, validators are called bakers. Baker creates blocks, Endorsers validate them, and both earn rewards. This consensus protocol requires participants to prove that they are willing to secure the integrity of the blockchain by staking a certain amount of the coin if they don't own enough coins or don't have enough technical knowledge. He/she can delegate his coins to bakers, thereby gaining from a portion of the transaction fees. And during this period, coins are locked up. This mechanism represents a low-energy cost alternative to proof-of-work*.*

### Smart contracts

[Smart contracts](https://en.wikipedia.org/wiki/Smart_contract) are computer programs stored on a blockchain that can be automatically executed on a blockchain network once predetermined conditions are met. Once it is deployed, it becomes immutable (stored). Both blockchain protocols support smart contracts. But, they make use of different languages when coding their smart contract.

Ethereum uses [Solidity](https://soliditylang.org/) to implement smart contracts. Solidity is an object-oriented, high-level language designed to target the [Ethereum Virtual Machine](https://ethereum.org/en/developers/docs/evm/)(EVM). It is statically typed and supports features such as inheritance, custom user-defined types, and libraries.

```
// Define the compiler version you will be using
pragma solidity ^0.8.4;

// Start by creating a contract named Variables
contract Variables {

    uint256 public u = 1230; // uint is an alias for uint256
    int256 public i = -123; // int is same as int256
    address public addr = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;
    bool public defaultBoo1 = false;

    function doSomething() public {
        uint256 ui = 456;
        uint timestamp = block.timestamp; // Current block timestamp
        address sender = msg.sender; // address of the caller
    }
}
```

Solidity isn't the only language used to write smart contracts on the Ethereum blockchain. But it also allows users to partake in just about any programming language, such as Java, Python, or JavaScript.

**Tezos** uses [Michelson](https://www.michelson.org/) as its base language. Michelson is a rich, Turing-complete, stack-based, smart-contract language. Michelson doesn't use variables or named functions and offers features such as maps, sets, lists, cryptographic primitives, and arbitrary precision integers.

```
parameter uint ;
storage string ;
code {
    DROP ;
    PUSH string "Hello world" ;
    NIL operation ;
    PAIR ;
}
```

High-level languages such as SmartPy, Ligo, or Lorentz are also used to write smart contracts on the Tezos blockchain. However, they are eventually compiled down to Michelson.

### Developer community

Languages like Python and Javascript are widely used and adopted by developers. Solidity is designed to be similar to JavaScript. It is beginner-friendly and has a well-detailed document as well as a lot of tutorials and projects.

Tezos's Michelson is a bit complex. That is likely because there are not enough beginner-friendly tutorials and the rare documentation available online is technically difficult for beginners to read.

### Ease of Use

Both blockchains have a learning curve, even if you're already familiar with Javascript and Python. Ethereum has very intuitive and informative documentation with a lot of tutorials. Whereas, Tezos might be a little bit hard to understand. They are both easy to set up and integrate with front-end technology.

There are several ways to set up the Ethereum environment to build smart contracts with a front-end. One of the fastest and easiest ways to do so is with the `create-eth-app` command. It comes with a different offering of front-end frameworks and Defi templates you can choose. Refer [here](https://github.com/PaulRBerg/create-eth-app) for a complete guide on setting up the Ethereum environment.

There are also several ways to set up the Tezos environment, and I am setting it up with React app.

```
npx create-react-app my-Dapp # create project
cd my-dapp
yarn start
```

After installing `create-react-app`, there are some dependencies to install to interact with the Tezos network.

```
yarn add @temple-wallet/dapp
yarn add @taquito/taquito
yarn add constate
```

Next you’ll create a `dapp` folder into `src/`, and put the dapp.js file into it:

```
mkdir src/dapp
cd src/dapp
curl https://raw.githubusercontent.com/madfish-solutions/counter-dapp/master/src/dapp.js -O
```

Refer [here](https://github.com/PaulRBerg/create-eth-app) for a complete guide on setting up the Tezos environment.


## Open Source Session Replay

_[OpenReplay](https://github.com/openreplay/openreplay) is an open-source, session replay suite that lets you see what users do on your web app, helping you troubleshoot issues faster. OpenReplay is self-hosted for full control over your data._

![replayer.png](https://static.openreplay.com/images/banner-blog.png)

_Start enjoying your debugging experience - [start using OpenReplay for free](https://github.com/openreplay/openreplay)._


## Use cases

Both blockchain ledgers have many use cases, and it has been proven that they can be used in many ways. They are used not only to store value but also in lending platforms, DAOs, DEXs (decentralized exchange), NFTs (non-fungible tokens), etc.

Also, note that they have already made great strides in changing the world and are still evolving. What can be done with these blockchain ledgers is limitless.

## Key take-aways


- In terms of the governance process, both ledgers have different governance models. Ethereum makes use of an off-chain governance mechanism. In this case, proposals or requests for updates go through the core members, and this process causes a hard fork. Tezos uses an on-chain governance mechanism that allows itself to upgrade without splitting the network (hard fork) into two different Blockchains.
- Smart-contract code written in Michelson **language facilitates Formal verification. It performs heavy computations off-chain, leaving the smart contract to deal only with the relatively lightweight transaction logic. 
- Tezos liquid proof-of-stake (LPOS) mechanism consumes far less energy than Ethereum proof-of-stake (POS).
- They are decentralized ledgers and smart contract platforms implemented on the blockchain.


## Conclusion

In this blog post, we examined two popular blockchain technologies: Ethereum and Tezos. We compared them based on their smart contracts, consensus, use cases, developer community, and similarities. We also covered how to bootstrap a simple project with both technologies. Ethereum and Tezos offer great functionalities for building Dapp, so picking one over another depends on your project.

[![newsletter](https://blog.openreplay.com/static/e6b18eda7a327511296a2f27692f9c70/e9957/newsletter.png)](https://newsletter.openreplay.com/)