Blockchain Programming Languages for Ambitious Web3 Developers

Web3 is characterized by network decentralization in which digital ownership is recorded on distributed ledgers, ushering in a new age for the Internet: an age of trustlessness. Entities across the globe can now safely and transparently transact with each other without the need for trust as they know that their assets are held safe and immutable on blockchain ledgers.  

Intermediaries won’t be necessary for two parties to transact with each other because there won’t be a need for any “trust” between them. However, a trustless world cannot become reality until the globe’s best developers understand key programming languages and start building the Web3 world from the ground up. 

Fortunately, developers are hearing the call to action and are flocking to Web3 in droves. In 2021, more developers than ever joined Web3, with over 34,000 joining the industry throughout the year. Mirroring the situation in the traditional finance world, “crypto” job hirings are likewise at all-time highs. This paradigm shift is happening faster than the news can get out, resulting in high numbers of related job openings as well as increased higher pay, bonuses, or other remunerations like token allocations.

It appears that major hiring decisions followed the 2017 price spike of Bitcoin, continuing to rise throughout the Covid-19 pandemic, and remaining constant ever since.

Developers these days have learned to use a number of popular languages like Python, C++, Truffle, Javascript, Golang, Solidity, Rust, and many others. Those trained in the most contemporary languages will find the transition from Web 2.0 to Web3 dApp development easier to manage. 

For example, smart contract languages like Solidity were designed to be an easy bridge for programmers already familiar with contemporary programming languages used by the biggest names in tech today. Platforms such as the Ethereum Virtual Machine (EVM) allow for the development of Ethereum-compatible dApps with various implementations written in languages like Go, Python, Parity, Haskell, etc.  

Languages like Rust and Haskell are also gaining prominence, making them relevant for developers to consider using to deploy their dApps on other blockchains with attributes like higher throughput capabilities, time to finality, or network decentralization and consensus methods. Therefore, an overview of some of the top Web3 languages may cast a light on what an aspiring Web3 developer can do to gain early advantages to build dApps in an evolving space. 

The most popular blockchain choice for developers is currently Ethereum, though there are others like Cardano, Solana, Avalanche, Tezos, and many more gaining traction among new and experienced developers alike. These blockchains are written in various languages, meaning there are work opportunities for devs no matter which language they know, though joining a larger dev community has certain advantages like educational material, compatibility libraries, and other plug and play opportunities for porting dApps.   

Learning a new programming language is a crucial decision for developers as it involves a significant investment of their time. Moreover, learning one language instead of another inevitably includes a wager on the chosen language’s growth in popularity and adoption. The best hedge is to become at least familiar with multiple coding languages.

That doesn’t mean one should delay the decision to learn too long, but developers entering the industry need to choose wisely. With a more active community comes more resources, employment opportunities, and end-retail users of one’s dApps. 

This brief summary should give some insights as to where most of the development has been and is going, what other developers are learning, what they want to learn, and what new developers can do to prepare for entering Web3 development. First, Javascript and Solidity are discussed with regards to their uses on Ethereum, then Haskell and its basis for Cardano’s native Plutus language, as well as Rust, notably used by Solana, NEAR protocol, and Polkadot.

Javascript & Solidity: Speaking Ethereum

As an object-oriented language, Javascript (JS) and Solidity share several similarities, but their functionality can hardly be compared. JS has, of course, been used for web development for some time already, as the code adds interactivity to a web display. 

That is, it is primarily front-end code which ‘displays’ backend systems data. While JS’s predecessors, CSS and HTML, focused primarily on displaying content, JS has brought the web to life with dynamic user experiences and impressive functionality. 

Just as with web pages and mobile applications, JS can be used to create dApps in Web3 development. As previously mentioned, all of the existing features of web development are used to structure and style Web3 dApps, but when it comes to dApps, there are some key differences to note. 

For instance, developers need to know how to use the ‘Web3.js’ library, a collection of libraries that allow users to interact with both local or remote Ethereum nodes using HTTP, IPC or WebSocket. This allows developers to implement plug-and-play tools to make their dApps compatible with Ethereum’s standards.

Going by the numbers, learning Rust, Kotlin, Haskell, and Go would equip a developer with an uncommon and desirable skill set. Source: HackerEarth 2021 Developer Survey

Solidity, as mentioned, is easier to learn than other Web3 languages since it was designed by programmers familiar with languages already being used in Web 2.0. It is the smart contracts language used by Ethereum developers, but its code only takes up a fraction of the total language used to run a given dApp. 

Other languages will do the heavy lifting in terms of the dApps look and functionality excluding the smart contracts themselves. Solidity can also be tricky in that internal state conditions might affect certain protocol behaviors, meaning the language can cause critical failures in certain contexts. 

Consequently, more rigorous stress-testing needs to be done before launch to avoid disaster. Due to the lack of uniformity with regards to the language’s functionality, critical mistakes might not be immediately obvious, hiding in plain sight before creating trouble down the road. 

To be fair, Solidity is a relatively young language, meaning the population of developers to identify bugs and other issues is smaller and has had less time to put in the collective work yet. The youth and size of Solidity’s community thus have a relatively smaller library of reusable behaviors and standards implementations in comparison with older languages, though this is quickly changing. 

Solidity’s community and its libraries have expanded even more rapidly since 2020, and developers have been eager to launch their dApps on Ethereum using Solidity to write their smart contracts. In Web3, Solidity has been the gold standard smart contracts language for several years, and only recently have alternatives begun gaining significant traction.  

Furthermore, the Ethereum blockchain is the largest player in DeFi and has a stronger network effect than any other smart contracts platform, boasting over 2,000 active developers working at the end of 2021. Learning Solidity has been a necessity for devs entering the Web3 space, and the industry’s mainstreaming process has only just begun. Ethereum consistently attracts 20-25% of new developers entering the Web3 space, with numbers trending upwards since 2017. 

With Ethereum 2.0 on the horizon, recently rebranded the consensus layer as it forks to a proof of stake consensus mechanism, there is a lot of upside to learning Solidity and pairing it with another language to create dApps on Ethereum’s massive network. Many developers looking to break into Web3 will find this to be the path of least resistance. 

Rust is most suitable for high throughput, concurrent operations, and gives developers confidence that unexpected bugs won’t lie dormant only to cause issues down the road.

In addition, concurrent (and parallel) programming makes for lightning-fast transactions, since various computations can be done simultaneously to execute the code. This gives Rust programs incredible scalability as its throughput can handle more transactions per second (TPS) than other languages. 

This scalability in processing concurrent transactions is made possible by the use of futures, thread pools, and channels. These features seem to alleviate the congestion issues which have continued troubling Ethereum users as network usage skyrocketed over the years since its inception in 2015.  

Zero-cost abstractions have also become a core principle of Rust development. These abstractions are also advantages for developers using Rust, as abstractions take high-level, complex code and reduce it to its quickest and most efficient implementation. 

Essentially, it means that developers don’t need to spend as much time optimizing code as the compiler will compile the abstractions for them. The results are often that the application runs faster written in Rust compared with other languages, even if one spent time hand-optimizing the code in other languages.