Share and get +16 +16

Ethereum and Tezos are two exciting projects that are worth looking into. Both of them are smart contract platforms and are aiming to enrich the dApp ecosystem by bringing in as many developers as possible to create high-quality dApps. So, in Tezos VS Ethererum we take a more in-depth look into both these platforms, in particular, their differences.

Ethereum at a Glance

Key Highlights

November 2013: Vitalik Buterin publishes the Ethereum whitepaper.

January 2014: The development of the Ethereum platform was publicly announced. The original Ethereum development team consisted of Vitalik Buterin, Mihai Alisie, Anthony Di Iorio, and Charles Hoskinson.

August 2014: Ethereum ends their ICO and raises $18.4 million.

May 2015: “Olympic” the Ethereum testnet releases.

July 30, 2015: The first stage of Ethereum’s development, “Frontier” was released.

March 14, 2016: Homestead, the first “stable” Ethereum release, went out on block 1,150,000.

June 2016: The DAO hack happens and the $50 million worth of Ether, which was 15% of the total Ether in circulation back at the time.

October 25, 2016: Ethereum Classic forks away from the original Ethereum protocol.

October 16, 2017: The Metropolis Byzantium hardfork update.

February 28, 2019: The Metropolis Constantinople hardfork update.

If you want a simple way to easily buy Ether by just using your credit card then click here.

Tezos at a Glance

Key Highlights

2014: Arthur Breitman publishes two whitepapers pointing out Bitcoin ’s defects and outlining Tezos

August 2015: Arthur and Kathleen Breitman register a company in Delaware called Dynamic Ledger Solutions, Inc (DLS) to take care of Tezos’ source code.

2016: The Tezos Foundation foundation is established and Johann Gevers, a South African entrepreneur, becomes the president of the foundation.

July 1, 2017: The Tezos ICO starts and lasts for 13 days and raises $232 million

Post-ICO: The relationship between Gevers and the Breitmans get soured.

September 2018: Tezos beta version launches after a long wait.

Tezos VS Ethereum : A Comparison

We will be focussing on the following points of difference:

#1 Tezos VS Etheruum: Governance – Off-chain vs On-chain

Ethereum – Off-chain governance

Ethereum utilizes off-chain governance via Ethereum Improvement Proposals (EIP). EIPs are improvement proposals for the Ethereum blockchain which is worked on off-chain. They are usually detailed design documents which provide suggestions on improving the Ethereum blockchain. These processes are not presented, recorded, passed or voted for on the blockchain itself.

According to Ethereum guidelines, the following needs to be kept in mind when it comes to EIPs:

EIPs have to be backed by technical knowledge and specifications.

The EIP author needs to have influence or gather enough support to get EIP passed without causing a rift in the community.

The most important part of the process is that all the views are required to be heard and considered.

You can see the EIP documentation and all the discussions surrounding it to see the progress comprehensively.

EIPs can also originate from Ethereum Request for Comments (ERCs). In that case, the same procedure is followed as well.

What are ERCs?

ERCs are suggestions for improvement proposals which are submitted for peer review through Ethereum. The ERC-20 token standard came about as a result of an ERC. Once an ERC shows enough promise to improve the Ethereum ecosystem, they are discussed further within the community and later changed into EIPs.

The EIP Discussion Phase

In this stage, the developers working on Ethereum will hold exhaustive discussions and meetings on whether the EIP in question is sound enough for real-world implementation. These developers are deeply involved in Ethereum’s development. GitHub has an entire room dedicated to Ethereum governance and development on GitHub, where they indulge in real-time discussion. If the developers feel that the code upgrade will have a positive impact on the ecosystem, then and only then is the code implemented.

More of then than not, the discussion phase is often a death knell for most EIPs. The developers are reluctant to implement any change that may be a little too extreme to avoid a debacle like the Ethereum Classic hard fork.

There are both disadvantages and advantages to this process. The biggest obstacle, of course, is that this process takes a long time. The main advantage is that each EIP is so thoroughly researched, that more often than not, the EIP that gets passed brings in a positive change to the ecosystem.

The following flowchart taken from Unblock should give you an idea of how the entire process flow works.

Tezos – On-Chain Governance

Tezos mitigates contentious hard forks via self-amendments and on-chain governance. Self-amendment helps in upgrading the blockchain without undergoing a hard fork. On-chain governance simply means voting on the platform over a proposed amendment. With a combination of on-chain governance and self-amendment event, the voting process can be modified aka amended as needed. The stakeholders of the system (which we will talk about later) take care of the voting. The design of this system allows for a smooth evolution of the blockchain rather than having to hard fork.

Alright, so how does this exactly work?

Developers independently submit proposals for protocol upgrades and request for compensation for their work.

The request for compensation makes sure that the developers have a strong economic incentive to contribute to the ecosystem

The proposal goes through a testing period wherein the community tests the protocol and criticizes it for possible improvements.

After repeated testing, the Tezos token holders can then vote on whether the proposal should be approved or not.

Once a legitimate upgrade is decided on, a “hot swap” occurs on the protocol, which initiates the new version of the protocol.

Because of this system, the protocol upgrades passively in a decentralized manner. Each protocol upgradation goes through multiple testing periods and gets relevant feedback from the community. This makes sure that whatever improvement happens has the stamp of approval from the majority of the community. This prevents any chance of a community-splitting hard fork.

#2 Tezos VS Ethereum- Consensus Mechanism

Up next, we have the consensus mechanism. Ethereum is currently using Proof-of-Work(POW), though they are going to move onto Proof-of-stake (POS) next. Tezos is using Liquid Proof-of-stake (LPOS)

Ethereum – Proof-of-Work and Proof-of-Stake

The idea of POW is for miners to use their computational power to solve cryptographically hard puzzles. The miner who gets to solve the problem, adds a new block to the blockchain and receives a block reward in return. This how the process works:

A random string called the “nonce” is appended to the hash of the previous block.

The resultant string is hashed and then checked against the network difficulty.

If the hash satisfies the conditions, then the block is added to the chain.

If not, the process repeats until the desired result is achieved.

There are two essential things to note about POW:

The process of getting the required result to meet the difficulty conditions should be extremely hard, time-consuming, and resource heavy.

The process of checking whether the miner was successfully able to mine a block should be easy.

Before long, miners discovered that they could exponentially increase their mining power by joining together and forming mining pools via parallel processing.

In parallel processing, program instructions are divided among multiple processors. By doing this, the running time of that program decreases, and that is basically what the mining pools are doing.

The biggest asset of POW mechanism is the security it brings in to the system. Since mining on it is so expensive, the miners don’t have any incentive to work against the system, and mine on any parallel chains just to waste their money for no reason.

However, POW chains definitely do have a lot of flaws:

They are slow.

They tend to be centralized.

They waste a lot of energy.

This is why Ethereum is going to ditch the POW protocol and move on to proof-of-stake (POS)

Ethereum in the future – Proof of Stake (POS)

Ethereum plans on using POS via the Casper Protocol. Proof of stake will make the entire mining process virtual and replace miners with validators.

This is how the process will work:

The validators will have to lock up some of their coins as stake.

After that, they will start validating the blocks. Meaning, when they discover a block which they think can be added to the chain, they will validate it by placing a bet on it.

If the block gets appended, then the validators will get a reward proportionate to their bets.

As you can see, the POS protocol is a lot more resource-friendly than POW. In POW, you NEED to waste a lot of resources to go along with the protocol. It is resource wastage for the sake of resource wastage.

Casper is the POS protocol that Ethereum has chosen to go with. Casper is a protocol that utilizes POS with a punishment mechanism. Let’s look at how POS under Casper would work:

The validators stake a portion of their Ethers as stake.

After that, they will start validating the blocks. Meaning, when they discover a block which they think can be added to the chain, they will validate it by placing a bet on it.

If the block gets appended, then the validators will get a reward proportionate to their bets.

However, if a validator acts maliciously and tries to do a “nothing at stake,” they will immediately be reprimanded, and their entire stake slashed.

As you can see, Casper is designed to work in a trustless system and be more Byzantine Fault Tolerant.

Anyone who acts in a malicious/Byzantine manner will get immediately punished by having their stake slashed off. This is where it differs from most other POS protocols. Malicious elements have something to lose so it is impossible for there to be nothing at stake.

Flawlessly implementing Casper and Proof Of Stake will be critical if Ethereum plans to scale up.

Tezos – Liquid Proof of Stake

Before we take a closer look at LPOS, let’s understand what liquid democracy means.

How does liquid democracy work?

Liquid democracy is a system that fluidly transitions between direct democracy and representative democracy.

The process has the following features:

People can vote on their policies directly.



People can delegate their voting responsibilities to a delegate who can vote on their policies for them.



The delegates themselves can delegate their voting responsibilities to another delegate who can vote on their behalf. This property wherein a delegate can appoint their own delegate is called transitivity.



If a person, who has delegated their voting doesn’t like the vote that their delegates have chosen, then they can simply take back their vote and vote on the policy themselves.

So, what are the advantages of liquid democracy?

The opinion of each individual person counts and plays a part in the final policy creation.



In order to become a delegate, all that one needs to do is to win a person’s trust. They don’t need to spend millions of dollars on expensive election campaigns. Because of this, the barrier to entry is relatively low.



Because of the option to oscillate between direct and delegated democracy, minority groups can be more fairly represented.



Finally, it has a scalable model. Anyone who doesn’t have the time to vote on their policies can simply delegate their voting responsibilities.

What is Liquid Proof of Stake?

Tezos is a liquid proof of stake system that requires one to stake a certain number of Tezos token to participate in the consensus over the blockchain. The process of staking Tezos tokens (XTZ) is called baking.

Token holders aka “bakers” can delegate their validation rights to other token holders without transferring ownership. This idea is very different from Ethereum where the entire network takes part in the consensus mechanism and EOS where voting rights are delegated to a handful of members.

Baking Blocks

You find and add blocks to the Tezos blockchain through a process called “baking.” This is how it works:

Bakers get block publishing rights based on their stake.

Each block is baked by a random baker and then notarized by 32 other random bakers.

If the block is good to go then the block gets added to the blockchain.

The successful baker gets a block reward and can charge transaction fees for all the transactions inside the block.

As we have said before, token holders have the option of delegating their baking rights to other holders without letting go of the ownership of their tokens. Upon the completion of the baking process, the baker will share their rewards with the rest of the delegates.

#3 Tezos VS Ethereum – Smart Contract Language

Since both of these platforms are smart contract platforms let’s now talk about the languages you will need to learn to code on top of them. Ethereum uses Solidity which is an imperative language while Tezos uses Michelson which is a functional language. Let’s understand the difference between imperative and functional language before we continue.

Imperative vs Functional Languages

When it comes to languages, they belong to two families:

Imperative

Functional.

Imperative Programming Languages

In an imperative approach, the coder needs to put down all the steps that the computer needs to take to reach a goal. All of our traditional programming languages like C++, Java and even Solidity are imperative programming languages. This kind of programming approach is also called algorithmic programming.

Let’s take an example of what we mean by that. Let’s look at C++. Suppose we want to add 5 and 3.

int a = 5;

int b = 3;

int c;

c= a + b;

So, as you can see, the addition process takes over multiple steps and each step is constantly changing the state of the program as they are all being executed in turn individually.

An addition process took four steps and the steps are:

Declaring an integer a and assigning the value 5 to it.

Declaring an integer b and assigning the value 3 to it.

Declaring an integer c.

Adding the values of and b and storing them in c.

Functional Programming Languages

The second family of programming languages is Functional languages. This style of programming was created to build a functional approach to problem-solving. This kind of approach is called declarative programming.

So, how does functional programming work?

Suppose there is a function f(x) that we want to use to calculate a function g(x) and then we want to use that to work with a function h(x). Instead of solving all of those in a sequence, we can simply club all of them together in a single function like this:

h(g(f(x)))

This makes the functional approach easier to reason mathematically. This is why functional programs are supposed to be a more secure approach to smart contract creation. This also aids in simpler Formal Verification which pretty much means that it is easier to mathematically prove what a program does and how it acts out.

Let’s take a real-life example of this and see why it can become extremely critical and even life-saving in certain conditions.

Suppose, we are coding a program that controls air-traffic.

As you can imagine, coding such a system requires a high degree of precision and accuracy. We can’t just blindly code something and hope for the best when people’s lives are at risk. In situations like these, we need a code that can be proven to work to a high degree of mathematical certainty.

This is precisely why the functional approach is so desirable. This is why Tezos is using OCaml and their smart contracts are using Michelson.

The following table compares the Imperative approach with the Functional approach.

Image Credit: Docs.Microsoft.com

Ethereum – Solidity

Solidity was developed by Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai and several former Ethereum core contributors to enable writing smart contracts on blockchain platforms such as Ethereum.

Solidity is meant to be a purposefully slimmed down, loosely-typed language with a syntax very similar to JavaScript. You can check out the Solidity Docs right here.

Using Solidity you will be coding smart contracts which are going to be executed in the Ethereum Virtual Machine aka EVM. Ethereum developers mention a set amount of gas which is assigned to their contracts. Each line of the contract requires some amount of gas to execute. The gas limit should be enough for the contract to execute completely.

Having some prior knowledge of JavaScript could be useful to learn solidity because of the following two reasons:

Firstly, like the solidity document states, it is influenced by JavaScript. Secondly, as many people have noted, solidity is pretty similar to JavaScript when it comes to syntax. The reason for this is pretty simple.

JavaScript happens to be one of the most in-demand and popular languages in the world. The Ethereum founders felt that if they modeled solidity after JavaScript, developers will be able to pick it up faster.

If you want to learn more about Solidity, then you can check our guides here and here.

Tezos – Michelson

Tezos has been coded using OCaml. The smart contracts that will run on Tezos will be created using Michelson. So, what is special about these languages? They both happen to be functional languages.

Michelson is a strongly typed, stack-based language.

In Ethereum, smart contracts are written in Solidity or Viper and they get compiled to EVM byte code, which then gets executed in the Ethereum virtual machine (EVM). In Tezos, there is no unnecessary extra step and the Michelson code itself gets to run in the Tezos VM.

Following is an example of a Michelson contract

parameter (pair ( lambda int int ) ( list int )); return ( list int ); storage unit; code { DIP{NIL int }; CAR; DUP; DIP{CAR; PAIR}; # Unpack data and setup accumulator CDR; LAMBDA (pair int (pair ( lambda int int ) ( list int ))) (pair ( lambda int int ) ( list int )) # Apply the lambda and add the new element to the list { DUP; CDAR; DIP{ DUP; DIP{CDAR}; DUP; CAR; DIP{CDDR; SWAP}; EXEC; CONS}; PAIR}; REDUCE; CDR; DIP{NIL int }; # First reduce LAMBDA (pair int ( list int )) ( list int ) {DUP; CAR; DIP{CDR}; CONS}; REDUCE; # Correct list order UNIT; SWAP; PAIR} # Calling convention

The biggest advantage of the functional approach is that it helps with creating a high assurance code because it is easier to prove how the code is going to behave mathematically.

The disadvantage though is the fact that there is a lack of experts in the functional programming field because these are simply not that popular.

Tezos VS Ethereum: Start Comparison

Let’s do some stat comparison between Ethereum and Tezos. Our data set will be between 9-13 June.

Tezos VS Ethereum: Number of blocks per day

Ethereum blocks per day

Ethereum has managed to produce more than 6,365 blocks per day in our data set. They managed a high of 6,447 blocks on 10th June and a low of 6,368 blocks on 9th June.

Tezos blocks per day

Tezos produced at least 1,360 blocks per day in our data set with a maximum of 1,402 on 9th June and a minimum on 1,360 on 12th June.

Ethereum produces 4-5 blocks per day because it produces one block every 15 seconds while Tezos produces a block per minute.

Tezos VS Ethereum: Total fees collected per day

Ethereum total fees collected (in ETH)

Ethereum users sent a staggering 767.52 ETH on 10th June and a low of 350.75 ETH on 9th June. That makes sense because Ethereum mined the least number of blocks on 9th June and the most on 10th June (in our dataset).

Tezos total fees collected (in XTZ)

Tezos sent a minimum of 3 XTZ on 11th June a max of 15 XTZ on 10th and 13th June.

Tezos VS Ethereum: Conclusion

Ethereum and Tezos are both exciting smart contract platforms. While Etheruem is the poster-child of this space, Tezos is bringing in an interesting platform which continually improves and amends itself during run-time. It will be interesting to see how both of these grow in the near future.

If you want a simple way to easily buy Ether by just using your credit card then click here.