Primary Features of Move Programming Language

Do not index

content plan

keyword

keyword list

topic search volume

💡

Original article by BuidlerDAO Paradise for Web 3.0 developers, researchers and learners. Move over HODL, it's time to BUIDL!

Read More About Buidler DAO Here or Join Fellow Developers to start building!

Overview

Public chain programming languages are languages used to create programs that run on a public blockchain. There are three mainstream languages that are used for this: Solidity, WASM, and Move.

Solidity is a high-level programming language for developing smart contracts on the Ethereum blockchain. It is a contract-oriented, serpent-inspired language with functionality similar to that of JavaScript.

Solidity was designed to target the Ethereum Virtual Machine (EVM), while WASM is an intermediate state language developed by Netscape, but because of its large size, its safety is difficult to control.

Developed by Meta's crypto team, Aptos, Move is a new smart contract language that is purpose-built for security and scalability. As a Rust-based programming language, Move inherent Rust's merits of safety and efficiency.

In this blog post, we'll outline the main features and advantages of Move and explain why we believe it has great prospects.

Primary Features of Move

Security

The primary advantage of Move is its security. Unlike other smart contract languages like Solidity, Move was designed from the ground up with security in mind.

At the language level, Like Rust, Move has its own ownership and ownership mechanism which helps to ensure security at the language level. This means that it is less likely for data to be accidentally leaked or corrupted, which can help to keep your system safe.

The resource-facing programming model also enables Move to have strong data abstraction capabilities. This means that you can be sure that the data in your system is properly protected and inaccessible to unauthorized users. This can help to keep your system secure from unwanted access or manipulation.

Besides the language and syntax, Move also has its own bytecode validator which helps to ensure security at the virtual machine level.

Move programs are verified by a bytecode verifier that checks for correctness before execution, helping to protect your system from potential bugs or exploits.

One advantage of the Move language is that it provides better asset management. In particular, it uses a linear type to ensure that assets cannot be accidentally copied or lost. This makes it easier to manage and keep track of assets in smart contracts.

Also, the Move language is notable for its ability to create custom resources with semantics similar to linear logic. This makes it safe and impossible to copy or implicitly discard any resource in Move.

Instead, resources can only be moved across program storage locations. The type system of Move is responsible for enforcing these safety assurances statically.

Efficiency

Another advantage of Move is its efficiency.

Because Move programs are compiled to bytecode, they can be executed directly on a blockchain without the need for an interpreter.

This makes Move programs much more efficient than interpreted languages like JavaScript or Python. In addition, the static type system means that Move programs can be optimized for performance more easily than other languages.

Move is also a programming language with fast adaptation. Languages from C, C++, and Java to Rust are all learning from their prior languages, Move as a language that started out in Facebook, has a good foundation in summing up the problems in the blockchain industry, and thus developed to become a super adaptable language.

For example, say you created an NFT project on Ethereum on an ERC-721 standard, and new protocols such as ERC-721a or ERC-4907 came out.

It is impossible for you to update your previous NFT project in Solidity. But if your project is written with Move language, you are able to bring newer protocols into your NFT project and thus extend its lifetime, bringing a second revolution to your NFT project.

Scalability

Lastly, Move is designed to be scalable. The language has built-in support for modularity and upgradability, which means that large programs can be broken down into smaller pieces that can be updated independently.

Solidity, on the contrary, suffered from a low-level problem in the earlier days. It was difficult to optimize the code and confronted many bottlenecks.

For example, projects would need to invest time and resources to develop and redeploy their code to comply with ERC-721a as an update of ERC-721.

Although you could not deny Solidity's wonderful ecosystem after years of accumulation and has endured the test of reliability. It's much easier and more convenient if a smart contract were written in Move.

Solidity Fundamentals Layout of a Contract | Coinmonks

This would make it much easier for NFT projects to bring in new features. The scalability of the Move language brings better prospects to ecosystems using Move.

Compiled contracts and APIs ensure rapid construction of basic functions. As the infrastructure builds up and the framework layer populates, many hands are freed up to focus on their particular business instead of struggling with the bottom layer.

What's Stopping Developers From Entering the Move Ecosystem?

Lack of Capital Volume

As an ecosystem that is in a fairly early stage, the capital volume now in the Move ecosystem is not attractive enough for crypto developers. Developers want to make a profit, but the ecosystem doesn't yet have a capital volume and user base as much as BSC or Ethereum ecosystems. Though a process from 0 to 1 really has unlimited potential.

Lack of Tools and Developers

Being at an early stage also means the lack of tool kits and developers.

The Move language itself is actually a competent one for smart contract development as well as asset management, but it doesn't yet have enough developers to actually help with the infrastructure, and many core development tools are still missing.

If we gave ecosystems like Aptos and Sui three years, the landscape would definitely have a totally different look.

It would also take developers time to actually get used to Move. Many previous languages are object-oriented. And Move is more resource-oriented on a structural level.

This is more prominent in more experienced developers. But in all cases, this is a good time to excavate this new land and deploy in advance. Once the capital rushes in and the ecosystem skyrockets, it would be too late to learn then.

Some Interesting Projects Developed Using Move

Move-on-EVM

Translating Move to Solidity in one click, which is to change it to EVM in one click. This is an official project by Move, a feature that Move has. You could solve security problems easily by writing Solidity using Move.

ComingChat

Kind of like a Web3 version of QQ with three tools: a full-stack wallet, a plug-in browser, and a crypto version of the red envelope in the social/chatting function.

Image Source: ComingChat Twitter

OmniBTC

All-chain finance platform based on LayerZero, allows exchanging assets on the EVM chain or any other chain in one click. It is similar to decentralized exchange but more convenient, and has safety in your own control.

Souffl3

An NFT Marketplace, only took them 5 days from announcing its adaptability to Aptos to breaking 10k fans.

The DAO Part in Starcoin

DAO could be a big opportunity in the next cycle. If Move ecosystem were to jump ahead, they would have to grasp their opportunity in DAO

Other Q & A

Q: The updatable contract is a super powerful function for developers in Move language, but for users, would risky things like the project changing the fundamental contract happen? What kind of contract can be updated? For a contract, which part of it can be updated?

There are limitations to updating contracts. After minted tokens reach the designated amount, the right to mint tokens will be dropped, and no more assets could be created out of blue.

Also, updating code is just a tool rather than an end. Eventually, it is up to all the holders and interested parties to decide what to do and if they should update a code.

Q: What's the main advantage that Move's virtual machine has compared to EVM?

Sui chose to use Directed Acyclic Graph, in which every asset is an object with its own ID. You are able to find all the kin relationships of a specific object, so every single object here is processed in a parallel fashion.

Aptos, on the other hand, adopted another method, in which they did an inside ranking and a verification process.

You could set EVM in a parallel fashion. But the current EVM-related ecosystems are all unparalleled, and if anyone set up a paralleled EVM, it could have good long-term value, but due to its incompatibility with all other projects in the ecosystem, it could be quite pricey. However, the main advantage of Move is that the ecosystem simply doesn't exist, and they have created a parallel EVM from the very beginning.

Ethereum is a standard blockchain. You have to perform global authentication of data and consider your control over the global situation, which renders parallel processing impossible.

Q: Why is EVM development hard and complicated?

Because the speed is hard to improve. For every single transaction, you will have to process the hash value, signature, and so on. If the computer were to execute this in sequential order, TPS could only get to 10k tops.

Solidity's virtual machine was initially not designed to make its function updatable, and not many people tried to overthrow it.

That leads to a situation where people know it is hard to use, but still use it, thus making the ecosystem bigger and bigger. That is not because EVM itself is a good ecosystem, it just means there hasn't been a decent competitor at the moment.

Conclusion:

The Move language is designed specifically for blockchain development, making it an ideal choice for creating decentralized applications. Its self-iterative design ensures high performance and stability, while its intuitive syntax makes it easy to learn.

Additionally, the Move language has built-in support for smart contracts, making it the perfect tool for creating powerful blockchain applications. In the Aptos ecosystem, table data structure enables more application scenarios for Move.

As more resources and volume go into rising ecosystems like Aptos that use Move, we will see this powerful programming language will gain more popularity and support more mind-blowing dApps.