Solidity Vs Move Vs Rust

On the 3rd of March, Pontem hosted a panel discussion at MoveCon featuring industry leaders from Zellic,  Kana Labs, Hippo Labs, Celer Network, MarginFi, and OkayRelay. The topic of the discussion was Solidity Vs Move Vs Rust.

You can listen to the full recording on Twitter or YouTube.

‍Meet the Speakers:

• Jasraj Bedi (aka Jazzy): Co-founder and CTO of Zellic, a smart contract auditing firm that helps protocols across Move, Solana, EVM, and Cosmos chains create and maintain secure, reliable smart contracts that adhere to best practices industry standards.

• Karthik Subramanian: Co-founder and CEO of Kana Labs, a cross-chain DeFi aggregator that simplifies cross-chain transactions across Solana, Aptos, and EVM chains, enabling users to seamlessly maximize their earnings.

• Mana: Co-founder of Hippo Labs, an aggregation mechanism on Aptos that connect all the liquidity from DEXes on Aptos including Liquidswap, PancakeSwap, AUX, and several others to ensure that users trade on Aptos with the best rates.

• Junda: Co-founder and CTO of Celer Network, a layer-2 blockchain scaling platform that enables fast, secure off-chain transactions for crypto payments and smart contract executions. Their popular product cBridge is a cross-chain bridging solution for fungible and non-fungible tokens.

• Edgar Pavlovsky: Founder of MarginFi, a decentralized portfolio margining protocol that makes it easy for traders to access margin, manage risk, and improve capital efficiency across the Solana ecosystem.

• Fodé Diop: Co-founder and CEO of OkayRelay, a serverless solution for cross-chain message relaying that supports about 24 chains including Ethereum, Cosmos, Aptos, Sui, Solana, Polygon, Near, and all other blockchains supported by the Wormhole Protocol.

Comparing Move, Solidity, and Rust: A Technical Analysis for the Non-Technical Person

‍Solidity is one of the earliest and most widely used programming languages for smart contract development, specifically designed for the Ethereum blockchain. It has a user-friendly syntax similar to JavaScript, making it easy to learn and use for most developers.

However, its early development also means that it has its fair share of vulnerabilities, as evidenced by some high-profile hacks that resulted in millions of dollars lost.

Move, on the other hand, is built on top of Rust and was developed specifically for creating highly secure smart contracts. Move introduces a new concept that defines assets as a “resource”, allowing developers to define ownership and access controls over assets, thereby adding an extra layer of security.

Move's emphasis on safety and security makes it a popular choice for developers who prioritize these features, but it also means that there is a steeper learning curve for developers who are not already familiar with Rust.

Rust prioritizes performance and safety. Its emphasis on safety makes it a popular choice for developers building critical infrastructure, such as blockchain nodes or other network services. However, Rust's syntax can be challenging for developers to learn.

The choice of programming language for smart contract development depends on the specific use case and the needs of the developer.

However, since Move was developed after Solidity and Rust, it retains a second-mover advantage, allowing it to learn from their shortcomings and improve upon them. This has resulted in a language that is more efficient, secure, and flexible for building blockchain applications.

Exploring the Safety Benefits of Move and Rust  in Blockchain Development

Move and Rust are safer alternatives to Solidity, but what does that even mean in a blockchain setting?

Safety in this context refers to the ability of the language to facilitate the development of smart contracts that are not susceptible to vulnerabilities and bugs that can lead to security breaches or loss of funds. Some of these vulnerabilities include reentrancy attacks, integer overflows, and mishandling of user input.

Move's linear type system eliminates numerous classes of bugs, making it harder for developers to accidentally shoot themselves in the foot. Additionally, since Move was specifically designed with safety in mind, it has built-in support for formal verification, making it easier to verify the logic of smart contracts on the blockchain.

Rust, on the other hand, shines in areas like error handling and memory management, making it less prone to bugs that can lead to security vulnerabilities. Its strong type system and other safety features make it difficult for developers to introduce bugs and vulnerabilities into their code.

Some of the benefits of Move and Rust include:

• Seamless Composability: Smart contracts built using Move and Rust can easily interact with one another securely and predictably.

• Prevent Reentrancy: Smart contracts developed using move and rust are resistant to reentrancy attacks which occur when a smart contract calls an external contract and then immediately calls itself before the external call has completed. This can result in unexpected behavior and potential vulnerabilities.

Transitioning to Move: A Developer's Perspective

Programming languages are like tools, they can be powerful and useful, but they can also be dangerous in the wrong hands. While languages like Move and Solidity have built-in guardrails to prevent developers from making certain mistakes, it ultimately falls on the developers themselves to be careful and avoid causing harm.

Move incorporates ownership and resource management into its type system. This means that developers can express ownership of resources, such as tokens or data, within the code itself. As a result, Move's type system can catch errors such as data races and memory leaks at compile time, preventing them from ever occurring at runtime.

However, the adoption of Move has not been without challenges including:

1. Steep learning curve: Developers who are already proficient in Solidity or other languages may find it difficult to switch to Move. However, many developers who have made the switch report that the initial learning curve is not as steep as they expected

2. Limited tools and resources: While the language itself is open-source, there is a lack of documentation and tutorials compared to Solidity. Additionally, the tooling around Move, such as compilers and IDEs, is still in its early stages of development.

Despite these challenges, there is a growing community of developers and projects that are embracing Move. The language's security features and performance benefits are attracting attention, and many developers see it as a viable alternative to Solidity.

Solidity Vs Move: Evaluating Potentials for Improvement

The ability of programming languages to evolve and adapt to changing needs is essential in the fast-paced blockchain industry. Hence a balance between stable features and the need for updates is delicate, and it requires constant attention from developers to ensure that the languages remain robust and reliable.

Solidity has been used in many production-level projects and is designed to make it easier for developers to interact with the Ethereum virtual machine. However, the language's maturity level is still evolving, indicating the potential for future improvements.

Move, on the other hand, is designed to make it relatively easy for developers to jump in and start developing. In addition to the frequent contributions made to the Move repository, the ready-to-use building blocks and libraries are an essential part of the Move Language, making the development process faster and more efficient.

Solidity vs Move vs Rust: Which Language Offers the Best Performance for Blockchain?

While safety and ease of use are important considerations, the success of a blockchain project heavily depends on its performance. Hence, it's crucial to understand how we can improve performance and what sets a high-performing implementation apart from others.

It is important to distinguish between language performance and virtual machine performance. While languages like Solidity and Move can be compiled into more efficient representations, they are bound to specific virtual machines. Solidity is bound to the Ethereum Virtual Machine (EVM) and Move is bound to a large extent to the Move interpreter, while Rust is not bound to any specific virtual machine.

Hence, Rust is likely to be faster in terms of language performance than Solidity or Move. However, it also depends on the underlying virtual machine that is used.  

Exploring the Limitations of Move Language

Despite the strengths of the Move language, there are some areas where it falls short when compared to Rust and Solidity. For example, Move lacks tooling and abstractions which limits its flexibility in some use cases.

Moreover, as Move is a relatively new language, its ecosystem is still heavily dependent on a handful of developers to drive its evolution. This is in contrast to Solidity, which has a large and active developer community that has contributed significantly to the language's evolution.

To address these limitations, the Move ecosystem needs to be more open-source and foster a bigger sense of community. The community needs to contribute to the development of the language, build new tools and libraries, and help identify and fix bugs and vulnerabilities.

This will not only help Move evolve more quickly but also make it more robust and widely adopted.

ABOUT PONTEM

Pontem is a product development platform that enables global financial inclusion through blockchain technology. Pontem is developing infrastructure and decentralized tools for the fastest and most scalable Layer 1 blockchain – Aptos.

The Pontem Wallet is the gateway to the Aptos ecosystem available for Chrome,  Firefox, and iOS. Pontem Wallet users can send and receive tokens, connect to decentralized applications, and explore the Aptos ecosystem.

As a result of its partnership with Aptos, Pontem has developed foundational dApps like the Move Playground IDE, Liquidswap AMM, and ByteBabel code translator.