Smart-contract developer Road Map
Read this article to the end and you will understand what skills you need to become a smart-contract developer!
The Solidity developer roadmap is attached at the end of this article.
Introduction
Smart contract development is becoming more and more in demand every year, but there aren’t many developers who can build decent Web3 solutions. If you want to become a developer, or at least understand the path you need to take to get into this field, brew some tea and let’s go on an incredible adventure.
💡 In this article, we’ll look at the basic concept of how a smart developer works. We’ll give you a roadmap that can get you to a basic level.
Pre-requirements
Smart-contracts are programs that “live” and execute in a blockchain. Users interacting with smart-contracts invoke their functions and pay money to have them executed. And that’s worth keeping in mind, because poorly written code can waste tens or even hundreds of thousands of dollars. That’s why we recommend having a background in development before specializing in smart-contracts, for a base language such as Python, JavaScript, C, C++ and others.
1. The basics of blockchain
A lot of people don’t like the theoretical part, but here it comes in handy and will help in the further development of smart contracts!
When we defined smart contracts, we mentioned that they “live” and execute on a blockchain, which means that a smart contract developer needs to know how the environment in which their code is executed is set up. There are many nuances to smart-contract development that you can highlight for yourself as you learn the basics of blockchain.
Basics: Blockchain | Ethereum | EVM
2. Writing a Smart Contract. First Steps
Now we can try to write our first smart contracts, but the question arises: what language to write them in? Let’s turn to the popular service DefiLama to see the TVL for each language.
According to the above statistics, we can highlight two languages:
- Solidity
- Vyper
Solidity
Definition taken from the official Solidity documentation
Solidity is a high-level object-oriented language for implementing smart-contracts. Smart-contracts are programs that control the behavior of accounts in the Ethereum state.
In the syntax of the language you can notice similarities with languages such as: C, Python, JavaScript. To learn more about which languages have influenced Solidity and how, click here.
Since Solidity is the most widely used language for writing smart-contracts, we will consider it as the main one, but Vyper can also be mentioned.
Vyper
Vyper, like Solidity, is a language for writing smart contracts for EVM networks. This language is very similar to Python, which is why it is also called pythonic. Vyper was created to compete with Solidity and to eliminate some of its drawbacks, such as heavy code to read due to: multiple inheritance, function overloads, etc. More details can be found here.
Once you have chosen a language, you need to start mastering the syntax and basics; the official documentation of these languages can help with this:
Solidity: https://docs.soliditylang.org/en/latest/
Vyper: https://docs.vyperlang.org/en/latest/
We wrote a smart contract, now what?
Once a smart contract is written, you need to test it because once you deploy it in the blockchain, you can’t change it, which means your error could stay there forever.
In this part, we will also touch on writing scripts to interact with smart-contracts already deployed on the blockchain.
To test smart contracts, we need two things:
- A development environment.
- Some libraries for testing.
You can use your favorite IDE, but we recommend VS Code since it already has many plugins you may need.
We also have to choose a development environment, at the moment we can distinguish two main ones:
Hardhat
A convenient environment for writing smart contracts, with built-in functionality for the entire development process. Many projects are using this environment.
JavaScript / TypeScript is used to write tests / scripts.
💡 The libraries you need to write tests / interact with smart contracts: Mocha / Chai / Ethers
More information can be found in the official documentation.
Foundry
A relatively new development environment, actively gaining a developer base. Often used by smart contract auditors.
Key benefits: writing tests in Solidity, built-in fuzzing plugin.
Note that you may need to integrate Hardhat into your project with Foundry for a comfortable development process (scripts / interacting with the blockchain). Based on this, we recommend you to start with Hardhat.
More information can be found in the official documentation.
What framework is used by the most popular projects:
Learn main standards.
In the field of smart contract development, there are a large number of standards that describe and help unify certain types of contracts, the first standards you will need:
- EIP-20 (Fungible tokens)
- EIP-712 (Non-fungible tokens)
- EIP-1155 (Multi-token)
- EIP-165 (Interface detection)
Don’t skip any of these standards as they are very common in the development process and knowing the intricacies will only benefit you.
Next step, explore popular projects.
You will often need to interact with other smart contracts, including exchanges, oracles, and a variety of other projects. We suggest that you learn the code of some of them beforehand to increase your learning curve and pick up different tricks:
- Uniswap V2 (Decentralized exchange)
- Uniswap V3 (Decentralized exchange)
- ChainLink (Interaction with data from web2)
- ENS (Domain Name System)
- AAVE (Lending Protocol)
Conclusion.
We’ve taken apart the basic path of a smart-contract developer, it’s time to start your journey!
Obviously, it’s impossible to cover absolutely everything in this article, but we’ve tried to give a consistent roadmap that will be suitable for almost anyone to start with.
Also, for those who read this article to the end, there is a bonus: Solidity Developer RoadMap, which is a more detailed RoadMap covering more aspects, down to specific Solidity topics.
Thanks for your attention! Feel free to rate our work!
