The Ultimate Smart Contract Developer Roadmap

This content originally appeared on DEV Community and was authored by Oliver Jumpertz

2022 could be the year you get into smart contract development. The market has a high demand for developers knowing their way around Solidity for Ethereum, and this is why the following roadmap could potentially help you get your foot in the door. Furthermore, with average salaries of around $150k for remote positions, Solidity developers can earn pretty well, even working from home. And even better, by learning Solidity and this development stack, you become proficient on multiple blockchains at once. From Ethereum, to Polygon, Binance Smart Chain, Avalanche, and more, Solidity covers them all.

This roadmap is a long-term investment. It's nothing you finish in one day and are then good to go. But by following the path presented here, you will learn all the basics, including advanced concepts, and become ready for a job after a while.

Without further ado, let's get into it.

(This article was originally posted on my personal blog)

CS50: Introduction to Computer Science

Depending on where you currently stand in terms of your skills, it might be that you first need an introduction to CS overall.

Harvard offers its CS50 for free, and it'll take you a while, but it's worth it. Fundamentals are crucial, especially as many of the advanced concepts you will learn later build on top of them.

freeCodeCamp

JavaScript is the basis of many tools in the Ethereum ecosystem. You should know JavaScript relatively well before you get into Solidity later.

Do at least the JavaScript courses here, including quality assurance. This will also take you quite some time, but knowing JavaScript well also helps you learn Solidity later.

Public Key Cryptography

At the heart of a blockchain lies public key cryptography. You should understand what it is, how it works, and why what you'll do later makes sense.

This video is a great introduction. Go through it a few times if you need to. Don't forget to take a few notes.

Cryptography Digital signatures

With cryptography, you can begin to sign messages and verify identities. Blockchains use it a lot. Without signing messages, there would be no secure transactions.

This article will give you a better idea of how transactions are initiated, for example, and why that is secure.

What is Hashing on the Blockchain?

Hashing is a core concept that blockchains use. And as a smart contract developer, you will probably also use it a lot.

This video is an excellent introduction to hashing and its use in blockchains. Like before, take notes. At some point, you will be thankful for having them ready.

Blockchain Definition: What You Need To Know

Now that you know what cryptography is actually about, it's time to learn more about blockchains in general. The blockchain will be your place of work, so you better know well what you'll work with.

How does Ethereum work, anyway?

Knowing Ethereum is pretty essential, primarily as you work toward being able to code with Ethereum-like blockchains in the future. When you're done with this article, you'll have a general understanding of Ethereum.

This is the last theory material for now. When you are done with this, you'll be able to get into the code again. And this time, it's Solidity you will work with.

The Hitchhiker's Guide to Smart Contracts in Ethereum

Time to finally dip your toes into the waters of Solidity. While already a little older, this guide is a great way to finally implement your first Smart Contract.

Take your time to go through this guide. Solidity is probably new for you, and so it's way better to really digest the learning material until it sticks.

Crypto Zombies

CryptoZombies is a game, but one that teaches you Solidity. In this tutorial, you'll write more advanced logic and get comfortable with the language.

You can also take your time with Crypto Zombies. Do a few lectures here and there, and don't try to rush through it. You'll learn many basic and advanced concepts throughout this course.

Time-locked Wallets: An Introduction to Ethereum Smart Contracts

Time for even more practice. This tutorial walks you through creating a full dApp, including your own ERC 20 token.

Take this course as an opportunity to learn Solidity even more profoundly and apply what you previously learned. Practice is everything, so all chances for you to code in Solidity are valuable.

Ultimate Introduction to Ethereum Ðapp Development

This one is a great video series on dApp development. Concentrate on the Smart Contract videos, and you'll get even more valuable practice with Solidity.

Once again, it's all about applying Solidity. You might begin to notice that you already know a few of the concepts, but don't let this hold you back. The more often you do something, the higher the chance that this knowledge doesn't vanish again.

Ethernaut

Ethernaut is another game that teaches you Solidity. This one primarily focuses a little more on security, a topic that will be very important to you as a smart contract developer.

Security is actually one of the biggest issues in smart contract development these days, and this is why you should pay very close attention to the matter and take many notes. The industry loves developers who know what they are doing, and they will highly value candidates with experience in smart contract security.

ethgas

Every line of code you write has an impact on your users. They pay gas to call functions of your smart contracts. Time to learn about the what, why, and how of gas.

You are back at some theory now, but a pretty important one, to be honest. Understanding the concept of gas and why it is both good and bad helps you to value good code design higher, and it will hopefully trigger different thought processes in you when writing Solidity.

Blockchain Oracles, Explained

You won't be able to do everything on the blockchain. Time to learn about oracles, a way for Smart Contracts to communicate with the outside world.

Oracles are an advanced concept but one that every Solidity developer should understand. Knowing about Oracles is a considerable advantage. Depending on what projects you work on later, you will have more or less contact with them. But as soon as you understand that you already need an Oracle when you want a random number, you will see that learning a lot about them helps you a lot.

Contract ABI Specification

Every smart contract has an ABI. When someone wants to use your contracts, they need to know their ABIs, and you should also know what you actually create there.

After you have already built quite a few contracts by now, it's time to learn what you actually create. ABIs are at the core of blockchain client usage. Without an ABI, no clients would be able to call your contracts on-chain.

Keccak

Keccak is the important hash algorithm for Solidity developers. You'll work with it a lot, so you better know what you are using there.

Hardhat

The time has come to choose the stack you will use from now on.

My recommendation for your development environment: Hardhat.

Go through the documentation and learn more about this Ethereum development environment. You will probably understand by now why you had to learn JavaScript in the beginning. Hardhat is - like many other Solidity tools - implemented in JavaScript.

Waffle

Tests are crucial, especially for Smart Contracts.

My recommendation: Waffle.

Waffle is the engine that drives your tests. It enables you to write JavaScript and test your smart contracts as a client.

ethers.js

Next to Waffle, you will also need a client library to invoke your contracts.

My recommendation: ethers.js.

ethers is the library that slowly completes your stack. You will use ethers in your tests a lot.

OpenZeppelin

Smart contract development is like traditional development, and you should not try to reinvent the wheel every time. OpenZeppelin provides many useful standards already implemented.

See what the library has to offer and learn to use it. Many professional projects use OpenZeppelin a lot, so why shouldn't you later?

Ethereum Improvement Proposals

Ethereum has defined many standards, especially for tokens. Standardized A(B/P)Is are crucial to making the ecosystem work. Go through them all, and learn the most important ones, like ERC20, ERC721, etc.

Solidity Patterns

Now that you can freely build things without a browser, it's time to build and learn important Solidity patterns along the way.

Patterns can be applied in certain places and help you to achieve specific things in a recognizable and maintainable way. You will see many of them regularly when reading code, and you will hopefully also apply them a lot. This is the last thing you should learn really well before you branch out to build your own projects and use your own imagination.

What's Next?

You should be a pretty competent Solidity developer by now. Your skills, however, are still pretty general.

From here on, build a lot of stuff, experiment even more, and see what fields you might like. You can definitely specialize from here on.

Look into:

• NFTs
• Currencies/fungible tokens
• DeFi
• DAOs

Learn more about all of them, and see whether you like a field specifically.

Another topic you can now begin to research is decentralized computing. You won't always be able to do everything within your smart contracts (remember learning about Oracles?). Look into Chainlink as a beginning.

After that, you can also try to become comfortable with Functions as a Service in JavaScript and such because sometimes, you will have to write code outside of the blockchain. The more you research, the more interesting platforms and applications you will find.

Before You Leave

Do you like written content like this? If so, you will probably love my newsletter.

Iteration Three is the Web 3 newsletter I would love to get into my inbox each week.

From the latest news in the industry, opportunities, analyses, and development tips, to showcases of interesting new projects, this newsletter tries to give you everything you might have missed or did not even know existed.

This content originally appeared on DEV Community and was authored by Oliver Jumpertz