Flow vs Ethereum: the Ultimate Comparison of Blockchains and Their Programming Languages

Since its launch in 2015, Ethereum has established itself as one of the main blockchain platforms used by developers to build new decentralized applications with smart contracts. The founders of Ethereum came up with the idea to create it after realizing that blockchain technology could actually serve many more purposes than just cryptocurrency transactions.

Ethereum is constantly improving and looks like the ideal solution for many blockchain projects. At the same time, the story of Ethereum-based CryptoKitties, an extremely viral trading game that clogged the network, suggests that even Ethereum has its drawbacks. There’s definitely a need for a more advanced blockchain solution.

That’s why the CryptoKitties creators have introduced a blockchain of their own, called Flow. Want to take a closer look at this novelty and examine how it differs from Ethereum? Alex Dolgov, a seasoned blockchain expert, is here to help you analyze these blockchains and find out which platform – Ethereum or Flow – is more suitable for NFT projects.

Read on to dig even deeper into Flow and Ethereum and their programming languages.

Introducing Ethereum and Solidity

If you are familiar with blockchain technology and keep up with the latest news about the rapidly developing crypto world, you will surely have heard about Ethereum. This decentralized open-source blockchain platform with smart contract functionality has already left its mark on the history of the blockchain.

The Ethereum creators were fascinated by Bitcoin and its popularity and decided to build the next generation of blockchain. They intended to expand blockchain capabilities and open this technology to a wide range of businesses. This led them to create Ethereum, powered by its own cryptocurrency called Ether (ETH) and its own programming language Solidity.

Solidity is an object-oriented advanced programming language for writing smart contracts. This language was influenced by C++, Python, and JavaScript. It was developed for the Ethereum Virtual Machine (EVM).

But why did Ethereum developers want to create their own language? To answer this question, we need to go back to basics.

While the developers worked hard on Ethereum, the best and most successful example of blockchain was Bitcoin (it remains the most popular to this day). The Bitcoin network was created as a peer-to-peer currency exchange. Ethereum, in its turn, is designed to digitize and efficiently move anything of value, not just cryptocurrency.

Another major point is that it’s difficult for developers to work with Bitcoin script, which is the language that makes smart contracts possible on the Bitcoin blockchain. The complexity and the lack of flexibility of the Bitcoin script prompted the developers of Ethereum to create their own platform and programming language for smart contracts.

Eventually, Ethereum’s team went beyond what Bitcoin was offering and created a brand new system with the much more flexible Solidity language.

Ethereum is currently used as a platform for numerous decentralized applications, and NFT projects are no exception. Statistics indicate this blockchain as the leader by the number of launched decentralized applications and daily active users.

Flow and Cadence: what are they?

Although the Flow blockchain was launched as recently as 2020, many are already calling it a potential alternative to Ethereum.

Flow was developed by Dapper Labs, the Canadian company behind the renowned CryptoKitties. The company’s developers realized they needed a new blockchain when their Ethereum-based collectibles game put down the network after hitting only about 10,000 users. Dapper Labs’ vision was to attract as many as a billion people to their dApp, yet no blockchain platform could scale up to meet basic consumer needs.

So they built Flow – a fast, decentralized blockchain that powers entire ecosystems of applications, especially those related to games and digital collectibles. At the heart of Flow is a new architecture that delivers the performance required for popular applications without compromising decentralization. By leveraging this new blockchain, developers can create secure and composable apps that could potentially be used by billions of consumers.

The NBA Top Shot application, for example, is already successfully running on the Flow network. This blockchain-powered trading card system, officially licensed by the NBA, accounts for more transactions than all other NFT projects combined, according to Dapper Labs CEO Roham Gharegozlou. Since launching the beta, NBA Top Shot has attracted over 800,000 users and generated nearly $500 million in sales.

Like other blockchains, Flow has its native currency named FLOW. It is the main reserve asset on the network and the exclusive token for staking, governance, and paying transaction costs. In the same spirit as Ethereum creators, Flow’s team also introduced a new language called Cadence.

Cadence is a resource-oriented programming language with new features applied to smart contracts. These features include a strong static type system, built-in pre and postconditions for functions and transactions, and the use of capability-based security. Cadence’s syntax was influenced by Swift and Rust. The resource type maps well to Move, the language developed by the Libra team.

Flow and Cadence are both suitable for creating decentralized applications that have the potential to go viral. Examples are applications allowing celebrities and athletes to interact with their fans, or NFT projects involving famous artists.

Flow vs Ethereum: which is better for NFT development?

With the basics of Flow and Ethereum out of the way, it’s time to begin the face-off. Let’s compare the two platforms to see which one is currently more convenient, efficient, economically viable, and profitable.

Scalability

Any developer who has ever tried to build an application using Ethereum is aware of its scalability problem: the throughput of the Ethereum network is only around 13-15 transactions per second, which makes it quite insufficient for large-scale use.

The CryptoKitties developers experienced this inefficiency as well. Their game became so popular and successful that Ethereum could no longer deal with the huge influx of users. When creating Flow, the developers’ main goal was to solve the problem of scalability while also maintaining the decentralization and high security of the network.

While Ethereum views sharding as a way to scale the blockchain horizontally, Flow uses its multi-node architecture to enable vertical scalability. The architecture of the nodes is structured in such a way that the work to be done is divided between them.

Collection nodes improve network connectivity and data availability for dApps, and Execution nodes perform the calculations associated with each transaction. These two nodes are designed to increase throughput and network scalability.

Verification nodes double-check the work being done by the execution nodes, while the Consensus nodes determine the order of transactions. In effect, Consensus and Verification nodes ensure the accountability of the network and are responsible for security.

Incorporating four different types of nodes ensures the optimal distribution of node operators and the decentralization of the network.

In terms of transaction throughput, back in 2019, the Flow prototype was able to execute about 1,000 transactions per second. Now the target is to reach 10,000 tps.

Transaction cost

To perform a transaction and successfully execute a smart contract, Ethereum users have to pay gas. It’s a special fee that depends on the complexity of the contract and how busy the network is. Gas fees are paid in ETH, Ethereum’s own cryptocurrency, and the average price some days goes over $20.

The Flow developers weren’t satisfied with the cost of gas. But did they manage to reduce the transaction fees on their own platform? It seems that they have succeeded so far. There are two fees applied to transactions: one is for creating an account, which starts at 0.001 FLOW (about $0.03), and the other is a transaction fee that starts at 0.000001 FLOW.

Consensus mechanism

Ethereum currently uses the PoW (proof-of-work) consensus protocol. With such a consensus, miners go into “battle”: they compete to create new blocks. The crypto battle will be won by the one who solves the math problem faster than others and creates a cryptographic connection between the blocks. The winner shares the new block with the rest of the network and earns ETH. One of the biggest problems of PoW lies in its energy consumption as it requires a vast amount of computing resources. It has led to a search for less expensive alternatives.

At the same time, Ethereum developers are planning to move to the PoS (proof-of-stake) consensus protocol. In this case, the process will involve validators who will place ETH to participate in the transaction verification. The validator is chosen at random to create new blocks, share them with the network and receive rewards. This kind of change will potentially reduce energy consumption and gas fees.

The Flow blockchain, for its part, is already running on the PoS consensus model. It is powered by the HotStuff consensus algorithm, originally developed by VMware Research.

The key difference between them is how the key players make their profits. In PoS the players gain from boosting the value of the currency, whereas PoW has them interested in increasing the commission. PoW is also the main reason for Ethereum’s scalability issues.

As Ethereum is still in the process of moving to the PoS protocol, Flow is a great alternative for creators who can’t wait to launch and capitalize on their NFT projects.

Smart contracts

Smart contracts tend to be associated with Ethereum because this blockchain was designed specifically to build applications that would use them. These days it’s the most popular platform for smart contract creation.

What’s most notable about the Ethereum smart contract is that after its execution it cannot be changed. Any transaction performed on top of the smart contract is recorded on the blockchain and becomes immutable. Undoubtedly, this increases trust in the platform.

However, some developers think that it ought to be possible to change the smart contract after its deployment since the smart contract may be flawed and often requires testing.

Flow allows the release of smart contracts on its mainnet in a “beta state” so that the original author of the contract can update the code step by step. Users, in their turn, can choose to use the code as it is at a given point in time, or wait for the code to be completed before they put their trust in it.

Once the authors of smart contracts are convinced that the code is safe, they no longer need to control the code, and from that moment the smart contract becomes immutable. By checking and fixing the code, developers have the opportunity to significantly improve the security of smart contracts for end users.

Account model

An Ethereum account is created based on a private key, which is a 64 (256 bits / 32 bytes) hexadecimal number. After the private key is successfully generated, mathematical operations are performed on it to derive the public key. Then the public key is subjected to several more mathematical operations to obtain a valid address. This process is one-way: it is not possible to generate a private key from a given address.

As for Flow, accounts are automatically created by the blockchain and can support multiple public keys. To create an account on Flow, public and private key pairs must first be generated using ECDSA (Elliptic Curve Digital Signature Algorithm) P-256 or secp256k1 curves, and then the transaction must be sent to the blockchain. Through this transaction, new account storage is initialized and the generated keys are then assigned to that account.

Each account on Flow can have between 1 and n public keys associated with it. For each public key, there will be a private key in the direct possession of the account holder.

On the Ethereum blockchain, smart contracts are deployed to their individual accounts, and these accounts don’t have a private key. On the Flow blockchain, however, accounts can have multiple smart contracts deployed at the same time.

Another difference in the account models of these two blockchains is the ability to track tokens and smart contracts. Technically, an Ethereum account can track all the tokens and smart contracts it has interacted with using Ethereum logs, but Ethereum does not provide a single store for account assets in smart contracts. Flow, however, does just that: resources are in a sense “first-class citizens” on the Flow blockchain and you can track all smart contracts that your resources interacted with.

Working philosophy

Ethereum developers’ philosophy includes several principles: simplicity, universality, modularity, non-discrimination, and agility. Ideally, the average programmer should be able to successfully implement the intended decentralized application. As for universality, the creators of Ethereum conceived the platform as a base for applications for various purposes: you can invent your own financial instrument, create your own currency, tokenize real assets, and so on. Last but not least, Ethereum developers are constantly looking for opportunities to improve the security and scalability of their blockchain.

In reality, smart contract development looks like a compromise game. Developers have to constantly find a balance between the established app architecture and Solidity peculiarities. Implementing a contract is a complex task with a large number of scenarios needed to be taken into account. At the same time, the cost of each unnecessary action is very high. A developer who makes a mistake can watch their money disappearing and there’s nothing they can do about it.

The Flow creators’ philosophy emerged from their own experience of working with other blockchains, in particular with Ethereum. They analyzed all the problems developers encounter and created a new blockchain to make the user’s life easier. With the Flow blockchain, developers can now focus on the problems of business logic, rather than complex blockchain specifics.

Flow is a new blockchain with a new programming language, so it naturally involves a learning curve. Luckily, it has an abundance of documentation, and creators are constantly looking for ways to simplify development.

Nevertheless, Ethereum is still one of the most popular blockchains, with bucketloads of tokens and stablecoins already issued. Just take a look at the current statistics: 74% of all stablecoins are issued on the Ethereum blockchain. In addition, the Ethereum protocol has lots of time-tested features and templates that can be used as foundations as opposed to new technologies that always pose a risk of having vulnerabilities.

Essentially, if you would like to simply produce NFTs and you’re not planning to hold auctions on the blockchain, using Ethereum will be a good choice. It can be a bit expensive, but that’s both an advantage and disadvantage at the same time because the high cost of transactions also indicates the demand for the blockchain and its liquidity. On the other hand, if you desire flexibility and you need to implement logic with different conditions, and you are not afraid to take risks and try something new, then Flow is the way to go.

The success of CryptoKitties and NBA Top Shot is alone inspiring enough for developers to begin exploring Flow and its capabilities.

Solidity vs Cadence: how different are they?

Solidity and Cadence are smart contract languages designed specifically for their platforms. While Ethereum and Flow are obviously very different blockchains, what are the main features and differences between their languages? Let’s find out!

Programming model

First of all, Solidity is an object-oriented programming language, while Cadence is resource-oriented. What does this mean?

Generally, object-oriented programming means organizing software development around data (objects) rather than logic and functions. Apart from Solidity, there are many other popular object-oriented languages: JavaScript, Python, C ++, Ruby, and so on.

In the case of resource-oriented programming, when something is labeled as “Resource“, the programming environment is told that this data structure is something tangible and all code interacting with this data structure must follow a series of rules that will maintain the value of that data structure. This programming model is very suitable for digital assets.

Cadence is actually the first high-level, resource-oriented programming language available for use. Another example of a resource-oriented language is Move, but it differs from Cadence in that it focuses on performance and efficiency. Move has a virtual machine and compact bytecode that can be executed efficiently. At the same time, the syntax is minimal, easily interpreted by computers, but hard for people to follow. Cadence, on the other hand, has an ergonomic syntax that prioritizes readability and clarity.

Compiled or interpreted?

Another difference is that Solidity is compiled by the Ethereum Virtual Machine (EVM), while Cadence is currently an interpreted language. Cadence developers are trying to find ways to compile Cadence down to Move bytecode for running on the Move VM. The team has not set any deadline for when this update will be completed.

It’s worth noting that both compiled and interpreted languages have their own pros and cons. Compiled programs, for instance, are usually faster than interpreted code, but additional time is required to complete the entire compilation step before testing, and the platform depends on the generated binary code.

Interpreted languages, meanwhile, are generally more flexible. In addition, because interpreted languages ​​execute the source code themselves, the code itself is platform-independent. However, there is a serious drawback that is the lower execution speed compared to compiled languages.

Dealing with arguments

Cadence allows you to use argument labels to describe the meaning of a function’s arguments. With Solidity language, you can use comments. Writing comments can be a way to explain a function’s purpose and what each argument is used for.

Wrapping native tokens

The FLOW token is in itself a smart contract and can be imported directly without a wrapper. Solidity’s native currency is Ether (ETH) and it often needs to be wrapped into wETH to be used in smart contracts.

Why does it work this way with Solidity? To successfully complete a transaction between users, each user must have the same standardized format for every token they trade. In this case, we are talking about the ERC-20 format. ETH, in its turn, was built before this standard was introduced, so it doesn’t correspond to it. Hence we need to “wrap” ETH and turn it into WETH. This simplifies the work of contracts when interacting between different tokens. However, it’s not a requirement as you can write smart contracts using native ETH, although the logic will be more complex.

Access control

The access control function is simple: it allows some parts of the program to be made accessible and others inaccessible. Cadence provides two different layers of access control built into the language: keyword-based and capability-based. The second security model is not used very often.

Many other smart contract programming languages provide or restrict access depending on who you are, but capability security is about what you own. Users receive special resource objects that they store in their account that determine what functionality the user is allowed to access. Basically, nothing is public by default here. If other accounts want to read or write objects, they are unable to do so unless the owner of the account grants them access by providing references to their objects.

In the case of the Solidity programming language, the developers point out that Ethereum is a public blockchain, so you can never prevent a person or computer from reading the contents of your transactions and viewing the state of your contracts. If you wish you can make this task more complicated by using encryption or simply restricting read access to the state of your contract with other contracts.

Access in Solidity depends on who you are and is managed via access control lists or using the ‘msg.sender’ function which contains the address of the user that interacted with the contract.

Precondition & postcondition

When using Cadence software, design by contract allows developers to declaratively state preconditions and postconditions for functions and interfaces so that callers can be confident in the behavior of the methods they call. Precondition and postcondition are built-in for functions and transactions.

Solidity doesn’t have built-in preconditions and postconditions, but there is a way out. Developers can use function modifiers as a workaround for precondition and use ‘eventEmitter’ method and ‘ethereum-event-processor’ module for postcondition.

Upgradability

Cadence modules have configurable and transparent built-in upgradability which enables projects to test and iterate the code before making it immutable.

Solidity, on the other hand, allows developers to use proxy or data separation patterns. As a result, they have to put in a lot of effort to update smart contracts.

Incidentally, if you realized that you made a mistake after the code became immutable on the Flow blockchain, you will still have to deal with the same problems that developers face when working with Ethereum.

Among other differences between Solidity and Cadence is their syntax. Cadence was inspired by Swift and Rust, while Solidity was influenced by C++, JavaScript, and Python. Cadence generally allows you to write in a declarative style, while Solidity offers imperative programming.

In terms of safety and the likelihood of making errors, Cadence looks to be a more attractive programming language. However, since most developers have already got their hands dirty working with Solidity and know how to deal with emerging issues, many will still stick with Solidity.

Solidity is a statically typed language, which means that you need to specify the type of each variable. Cadence has a strong static-type system as well. The resource-oriented programming paradigm enables Cadence developers to create linear types with object capabilities.

Ethereum and NFTs

Now that we’ve examined the technical parameters of Ethereum, Flow, and their programming languages, let’s look at real-world examples of how these blockchain platforms work and what role they play in the ongoing NFT craze.

As a little reminder of what NFTs are: these are non-fungible tokens, which means they’re non-transferable and represent unique digital artworks, images, clips, GIFs, or even poems. NFTs are sold online, sometimes for extremely large sums of money.

Many NFTs are part of the Ethereum blockchain, and here are some of them.

KnownOrigin

KnownOrigin is one of the fastest-growing Ethereum art platforms within Web 3.0. The platform allows digital creators to easily authenticate, publish and sell their works of art. Through KnownOrigin, the platform’s authors strive to empower digital artists from all over the world to monetize their craft and talent and help them get closer to their fans and collectors in a meaningful, transparent, and fair manner.

The combination of Ethereum smart contracts and compliance with the ERC-721 standard provides a very high level of transparency and security. Thanks to Ethereum smart contracts, the creators of KnownOrigin are able to offer a reliable and secure way to continually maintain the provenance and supply chain of digital art sold through the platform.

The platform currently hosts the works of over 1,000 artists and has already sold over 11,000 digital artworks for a total of $1.3 million.

Palm

Palm is one of the newest platforms for digital creators. Developed by ConsenSys, it operates as a sidechain on the Ethereum mainnet but will be supported through the MetaMask crypto wallet. This new creative studio and NFT ecosystem promises to be 99% more energy-efficient than proof-of-work blockchains.

Palm will ultimately be driven by its own $PALM token and will provide artists with a more sustainable platform where they can publish and sell artworks in the form of NFTs without worrying about the potential ecological impact.

Damien Hirst was one of the first to use Palm to tokenize his work called “The Currency Project.” Damien plans to sell 10,000 oil paintings on paper in the form of NFTs from a series that explores “the conflation of art and wealth”. He believes that Palm is the best platform for him because it is art-oriented, greener, faster, and cheaper to use.

Decentraland

Decentraland is a kind of virtual world owned by its users. Based on the Ethereum blockchain, the platform makes use of two tokens: MANA and LAND. The former is an ERC-20 token that serves multiple purposes: for example, using MANA you can buy in-world goods and services, or instead, it can be burned to get a LAND ERC-721 token.

Changes to LAND parcels are registered in the Ethereum LAND smart contract and verified by the blockchain. Everything works almost like in real life: if you become the owner of the LAND, you’ll have full control over the life and environment you create there.

OpenSea

Built in 2017, OpenSea is one of the largest NFT marketplaces, offering a diverse range of NFTs, from virtual real estate to sound loops from The Weekend. Based on the Ethereum blockchain, OpenSea boasts 300k users and more than $3 billion in trading volume. The marketplace supports more than 200 payment options, including stablecoins. OpenSea allows users to send NFTs as a gift to other platform users and supports NFT minting.

As of February 2021, OpenSea is in the process of building support for Flow. It would bring great opportunities by attracting new users and enabling new types of engagements for OpenSea’s existing user base.

Flow and NFTs

Flow is still a “young” blockchain, but it successfully powers several extremely popular games, applications, and marketplaces.

CryptoKitties

CryptoKitties were initially released in 2017 on Ethereum and quickly went viral. However, the CryptoKitties boom was followed by scalability issues on the Ethereum network, as the popularity and influx of users severely congested it.

After launching their own Flow blockchain, Dapper Labs developers began the process of migrating digital collectibles from the Ethereum network and moving them to Flow. It is expected that CryptoKitties will gain new features such as animated 3D “cattributes”. Over time, it will also become possible to use these digital assets in other games on Flow.

Dapper Labs CEO Roham Gharegozlou pointed out that anyone using Ethereum will be able to take their cat to Flow. So, for all crypto cat lovers – don’t worry, you will keep your kitty collection and enjoy even more new features that come with it.

NBA Top Shot

We mentioned this app earlier, but there’s more to say about it. NBA Top Shot continues to make headlines and generate quite a buzz about itself.

Dapper Labs received $305 million in funding from the biggest names in Hollywood, sports, and financial investment. According to media reports, the new round is valuing the company at $2.6 billion – a sign of just how buoyant the NFT scene is today.

The financing of the company was led by financial services company Coatue in coalition with high profile individuals such as NBA legends and prominent players, including Michael Jordan Kevin Durant, Andre Iguodala, Kyle Lowry, Spencer Dinwiddie, Andre Drummond, Alex Caruso, Michael Carter-Williams, Josh Hart and others.

The company said they will use the funds to continue developing the NBA Top Shot and expand the updated digital trading card platform to other sports.

NBA Top Shot became the first blockchain-based solution reaching more than 1 million consumers with over $80 million in primary revenue. Moreover, its remarkable success gave birth to many new successful projects being built on Flow, from games like Chainmonsters and nWay to marketplaces like Rarible and xtingles.

VIV3 NFT marketplace

In January 2021 VIV3, the first shared marketplace on Flow designed to empower digital artists and creators was introduced to the world. VIV3 is currently in beta testing. Some of the early adopters of VIV3 were renowned artists such as Anne Spalter, known for her large-scale public works in Hong Kong and New York.

The creators of VIV3 also announced their partnership with Ben Mauro, a famous concept design artist. He worked on the films The Hobbit Trilogy, Spider-Man 2, Elysium, as well as the Call of Duty and Halo games. Ben Mauro’s card game EVOLUTION is coming to Flow soon.

Dapper Labs has also recently signed a new deal with UFC. The company is collaborating with UFC to create cryptocurrency digital assets and a companion game on the Flow blockchain for MMA fans around the world.

In addition to the listed names and brands, Dapper has many more famous partners such as Dr. Seuss Enterprises, Samsung, Ubisoft, and Warner Music Group.

What does the future hold?

Ethereum has secured its status as the first and most popular general-purpose blockchain. It allows you to use smart contracts, tokenize assets, issue unique tokens (including NFTs) and create complex dApps. Ethereum’s popularity also continues to grow as a result of its unified standards, which make it easy to integrate into the Ethereum network.

Although developers have been talking about Ethereum’s scalability issues for a long time, its engineering team promises that the problem will be resolved with the upcoming ETH 2.0 update. It promises to introduce sharding and make the transition from PoW to PoS consensus. No exact date has been given for when the transition will take place, but it’s likely to occur somewhere between 2021 and 2023.

Ethereum 2.0 promise to solve the main scalability problem might pull the developers back into its saddle and allow the platform to retain its status as the main hub for large-scale NFT projects.

On the other hand, Flow’s creators stand at the forefront of the current NFT craze. Successful NFT projects and crypto games like NBA Top Shot could stray developers towards using Flow for future projects and bring the platform global exposure.

Flow’s capabilities stretch way beyond these trending applications. As of now, developers continue to build tools and services to make Flow the best platform for consumer apps with improved scalability, composability, and user experience. As a general-purpose blockchain with DeFi support, it’s most likely to evolve into its own ecosystem.

Conclusion

Flow and Ethereum are both suitable platforms for a big variety of applications. Each of them has its own benefits and drawbacks, especially when it comes to NFT project development.

Speaking of the scalability issue, Ethereum views sharding as a solution to this problem. Once sharding is implemented, it will reduce network congestion and increase transaction speed. Flow is better than Ethereum in this aspect because it already offers multi-node architecture and faster transactions. Besides, Ethereum is currently using the PoW consensus protocol whereas Flow is running on the PoS model. PoW is not the best option for NFT projects as it also causes scalability issues. Thus, in terms of scalability, Flow may be a better option for you.

Transaction cost on Ethereum is pretty high, while Flow allows users to pay much less. It seems that the low transaction cost is clearly a benefit, but in the case of Ethereum, the high cost indicates strong demand and trust in the platform. Concerning smart contract development, once you deploy a smart contract on Ethereum, it will become immutable, while smart contracts on Flow are upgradable. Having the ability to fix the problem is definitely an advantage.

Consider all the described pros and cons of both blockchains and decide which one will bring the greatest benefit to you. The choice is yours, but a little reminder: each project is unique and has its own peculiarities that must be carefully considered in order to choose the right technology. Only an experienced blockchain company can analyze your case, provide detailed consultation on the best technology option and develop your project from scratch.

Don’t miss out on the NFT wave and start building your own app today!