The Ultimate Guide to Blockchain Programming for New Developers

I want to contribute code to one of these projects – how can I get started?

Is there any one language used specifically for blockchains?

I don’t know how to program – can I jump straight into blockchain programming?

A few months ago, I had the pleasure of moderating a panel of four active NEO programmers at the San Francisco NEO Dev Conference. The topic of the panel was general blockchain programming, however, an additional caveat made this particular panel of participants very interesting: all four programmers wielded a different language of choice for working on the NEO project.

One favored the old-school C # language, another produced Python scripts, a third evangelized the ever-popular Javascript implementation & the fourth participant excitedly discussed an upcoming domain-specific NEO language.

Two thoughts stuck with me post-panel:

1. The NEO compiler has serious multi-language development support
2. The learning curve for blockchain programming is brutal and heavily exasperated by a lack of organized resources, especially for new developers

This article aims to address point number 2. Maximizing the effectiveness of this guide requires curtailing the expected audience to a narrow niche: new & junior programmers looking to break specifically into the blockchain space. For veteran developers, programmers, & software engineers perusing — the following section may provide some benefit, however, you’ll likely find them elementary. Senior engineers can maximize their time by scrolling to a familiar language of choice, & beginning to rip apart the attached learning resources & documentation.

So you think you’d like to break into blockchain programming eh? Let’s start by further defining exactly what blockchain programming entails.

New Industry

In general, topics that personally interest you & align with your values are easier to learn than rote memorize-ing something without a clear buy-in; I highly stress that this principle applies increasingly more in an innately-complex, rapidly-evolving field such as blockchain programming. Before we begin, let’s check out some of the challenges that a blockchain developer faces in the burgeoning industry.

First & foremost is the continual, public discrepancy between what exactly a “blockchain” does or does not entail. Spend some time in crypto-twitter & it’ll become clear just how tribal crypto -communities, & by a stretch, their development communities have become. Unchecked tribalism naturally leads to biased conversations on what ought-to-be objective content, adding another layer of obfuscation for incoming developers.

Next, with the majority of projects in their testnet phase & with live projects continuously updating, forking, & falling victim to hacks, it’s unsurprising to see incomplete documentation & unfinished tutorials. The lay of the land is rapidly evolving which requires consistent iteration – no easy task for any team.

Last is the true stigma that blockchain programming is flat-out complicated & made up of multiple intersecting fields that require at least a rudimentary understanding of the following: economics, cryptography, currency, data structures, financial policy & physics. Learning even just the parts of these fields relevant to blockchain programming takes ample time to understand — no shortcuts here.

Tribalism, haphazard documentation & complicated fundamentals. All warning signs of a steep climb up ahead. In order to adequately motivate oneself through these barriers to entry, it helps to dig through some clarity on what exactly blockchain programming means in the first place. Additionally, it might help to uncover…

Why do you want to learn blockchain programming? What project do you want specifically work on? What problem(s) are you trying to solve?

Deconstructing Blockchain Programming

If you already know what project you feverishly want to work on, kudos — I suggest heading over to the organizations GitHub repository or ctrl-Fing the language of choice here to read ahead. The following section will most benefit those that can’t quite pinpoint exactly what project & required skillset/language suits them best as a jump-off point for the potential learning roadmaps ahead.

Generally, blockchain programming can mean three different things:

• Deploying an initial coin offering (ICO)
• Building a smart contract or decentralized app (DAPP)
• Contributing to an existing or deploying a new blockchain

Strongly consider the three options described above as they each offer an array of different languages & learning curves. Additionally, they should help get you one step closer to clarifying your exact preference. Further segmentation for language criteria is right around the corner; however, don’t forget that personal preference trumps all for motivating yourself through learning a new skill.

Assuming a day-one software engineer is equally interested in learning about all three types of blockchain programming – what other criteria can they turn to in order to shine on a light on the friendliest path forward?

• General-Purpose vs Domain-Specific Languages
• Syntax Readability & Learning Curve

By overviewing these three criteria we’ll finally have a solid frame of context from which we’ll apply to our list of languages.

General-Purpose vs Domain-Specific

Categorizing tools across qualitative qualities is rarely clear-cut — programming languages are no different. Here, we’ll split all possible blockchain programming languages to two different categories: domain-specific languages & general-purpose languages.

Typically, a domain-specific language (DSL) is a computer language designed & specifically suited for a particular application. A general-purpose language (GPL), as the name aptly-describes, is a language that is broadly applicable across many programming domains.

General-Purpose Language

General-purpose languages are the languages you’ve likely heard of such as Java, Javascript, Ruby, C++, & Python. Among the general-purpose languages, one can find infinite ways to further categorize them by qualitative & quantitative differences & similarities such as readability, compiling, strictly-typed, frontend/backend, etc… A good rule of thumb on first-time friendliness is as follows:

Javascript, Python, & Ruby are generally easier for newcomers as they have less of a learning curve while C++ & Java usually take more time to learn out of the box.

Note, the editor is refraining from commenting on second & third-level consequences of a newcomer starting off with one group of languages or the other. There are multiple debates across further features of these languages, such as forcing newcomers to understand variable types first through a strictly-typed language that we’re circumventing to maximize usage here for a new developer approaching strictly the blockchain space.

The biggest pro for newcomers picking up a general-purpose is the immediate ability to apply that language in a vast number of fields outside of blockchain programming. Unfortunately, the flipside of that same coin creates a con for those newcomers looking to join the job market as you’ll likely compete directly against senior & veteran software engineers from other domains with years of experience wielding said general-purpose language.

Domain-Specific Language

To provide context, let’s step back from blockchain programming. While it’s a fairly new programming field, the concept of a new programming field itself is not that new – you don’t have to look too far past the twin-recent-buzzword machine learning to see this. A few, additional programming field that has also witnessed a natural evolution of one or more domain-specific languages are: statistics (R, MatLab), database querying (SQL), Web UI (HTML, CSS).

Domain-specific language blockchain programmers are in very high demand with very little supply: these young languages, whose only purpose is one or more of the three blockchain programming options listed above, undoubtedly offer the clearest path to landing career-industry placement.

Since these languages were designed from the ground up with blockchain & smart contract engineering in mind, experienced developers may struggle to readjust previous frames of references from other languages.

While newcomers, with a fresh slate programming habits, lean-out all that’s necessary to begin deploying code in current or future projects.

Again, by circumventing the very-real programming fundamentals found in general-purpose language, one may find him or herself at a significant disadvantage down the line if the domain-specific language of his or her choice is somehow deprecated.

The follow diagram breaks down the pool of possible blockchain programming entry-points from a DSL/GDL segmentation; transparent/distant languages are languages not covered at length:

Syntax Readability & Learning Curve

Different programming languages offer different levels of readability based on how simple or complex their syntax is. Syntax refers to the designated spelling & grammar rules of a programming language. Usually, syntax readability correlates with the steepness of the learning curve; hard to read code makes for hard to learn code. Again, there are certainly exceptions to this rule however, for our purpose this linear relationship holds true.

We will use two key, yet common, programming language syntax features to create a readability understanding specifically for new developers & blockchain programming languages. The most common of these concepts is loose vs. strict variable typing.

Loose vs Strict Typing

All programming extensively uses variables; however, there isn’t simply a single, regular variable type — there are many, each with unique properties. You’ve probably heard a few of these variable types such as strings, integers, & booleans. Every programming language leverages these natural types in their syntax; however, each language layers these variable types with their own variable-referencing logic. Some languages, such as Python & Javascript, allow developers to simply use a single “var” variable: var example = “coincentral.” This flexibility allows developers to circumvent the tedious process of making sure each variable type is appropriately set in every line. Languages that hide low-level variable assigning are known as loosely-typed languages.

The latter category, strictly-typed languages, consists of a more verbose, albeit more descriptive syntax. Declaring variables in strictly-typed languages consists of specifically declaring the original variable type the developer intends to use: string example = “coincentral.” If you compare this to the previous variable declaration, pay close attention to the bolded “string.” This strict-typing of a variable is the key difference in syntax between loosely-typed language & strictly-typed language. The difference in syntax is not at all narrowed down to just declaring variables, it’s a key language design feature that’s pervasive across the entirety of each language.

Both loosely-typed & strictly-typed languages offer heaps of pros & cons tradeoffs. One of the most important trade-offs to consider for newcomers is the learning curve associated with both types. In general, loosely-typed languages offer a friendlier-syntax for newcomers & therefore a lower barrier to entry; however, the biggest immediate drawback to consider is a serious gap of fundamental software engineering knowledge when it comes to interacting with variable types.

Leverage this information however you see fit, we visually separate our pool of blockchain programming languages by loosely-typed & strictly-typed syntax below:

The Language Landscape

We’re finally at the core section of this article, which is a high-level catalog & survey of available blockchain programming languages. For each section we’ll briefly introduce the language, summarize its intended purpose within the blockchain environment, overview any projects or frameworks currently in production, & finally list out learning resources for further information.

C++

Let’s kick off with the oldest language in the list first: C++. Introduced first by one Mr.Bjarne Stroustrup in 1985, C++ was created as an extension of the original C language. The idea was to maintain the flexibility, security & efficiency of C, but to streamline the language for more object-oriented processes. Thus, leading to C++ being an object-oriented language while C remains process oriented.

C++ is a particularly powerful, oldschool, domain-general language that’s quite popular for core blockchain programming.

However, the new developer be warned. As a strictly-typed language with a relatively outdated syntax relative to its peers, the learning curve is very steep. It’s likely the hardest to language for a new developer to jump into; yet it must be stated that the fundamental knowledge attained through pushing the C++ learning curve is second-to-none. As previously stated, the blockchain world heavily leans on C++ so you’ll find no shortage of learning resources:

Bitcoin Core: https://github.com/bitcoin/bitcoin

Ripple Daemon: https://github.com/ripple/rippled

C++ Tutorial: http://www.cplusplus.com/doc/tutorial/

Javascript

JavaScript is a loosely-typed, scripting programming language for the web supported by all major browsers; it is the primary language used to enhance static HTML & CSS pages to full-fledged UIs. A few of these common web UIs include animations, refreshing pages, user menus & dialog boxes, interactive maps, etc…

This language powering all webpage behaviors in modern browsers, Javascript, was never supposed to leave the highest-level presentation layer of a web app. Yet it’s undeniable that Javascript took off, especially for newcomers, in an unprecedented way.  With Node.JS first placing Javascript server-side, then Angular/React/Vue basically rewriting the HTML/CSS stack client-side, full-stack Javascript has become all the rage. Without delving too deeply it’s safe to say at least a handful of veteran developers will groan at this recommendation. While there may be some merit to these complaints it doesn’t render the following sentence false:

Javascript is very newcomer-friendly, maturing, & now entrenched in all parts of the modern web stack.

For Javascript, the forefront runner in blockchain support is the Lisk blockchain project. Their landing page speaks volume in terms of their belief in building an entire blockchain ecosystem in Javascript: “Lisk makes it easy for developers to build and deploy blockchain applications in JavaScript.”

Learning Resources

Lisk: https://lisk.io/

Python

A relatively-modern programming language, Python is often the favorite for newcomers – and for good reason! Python was designed by Guido van Rossum with syntax simplicity & readability above all else. Since it’s release, Python has exploded as a simple yet powerful language with massive community support leading to Python integration literally everywhere – from web UI libraries such as Flask to machine learning essentials like NumPy.

While with native Python one can’t technically contribute to an existing blockchain, write decentralized apps, or hold an initial coin offering, it’d be a mistake to leave Python out of this list as almost every single blockchain ecosystem has one or more public tools written in & for Python.

Learning Resources

IBM Blockchain Foundations Tutorial – https://www.ibm.com/developerworks/cloud/library/cl-develop-blockchain-app-in-python/index.html

Ethereum Web Wrapper – http://web3py.readthedocs.io/

GO

The GO (short for GOLang) programming language is a relatively modern domain-general language developed at Google in 2007 & unveiled for public use in 2012. Designed as a robust, multi-purpose language, GO was an attempt at combining the syntax & user-friendliness of modern languages such as Python & Javascript, with the performance & security advantages of older, compiled languages such as C.

GO is a compiled language – which means it runs directly within an operating system. This feature allows maximal flexibility when it comes to using GO for multiple parts of a blockchain project. Want to contribute directly to an existing blockchain? Ethereum has a protocol SDK written in GO. Want to write a smart contract? The Linux-Foundation Hyperledger Fabric blockchain has that covered.

Learning Resources

Go Documentation – https://golang.org/doc/

Go Ethereum – https://github.com/ethereum/go-ethereum

Hyperledger Fabric – https://github.com/hyperledger/fabric-sdk-go

Solidity

Solidity is a javascript-like domain-specific language made by the Ethereum team(Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai & others) for creating decentralized apps on the Ethereum platform. It’s by far the most adapted & mainstream DSL that has seen ample adoption within the Ethereum community & blockchain industry.

For anyone looking to build a dApp or hold an ICO, Solidity is hands-down one of the most straightforward ways to dive directly into the heart of it all. Since the development of Solidity began prior to the Ethereum hard-fork, it thankfully averted any engineering effects on part of the civil disagreement, as evidenced by both Ethereum Classic & Ethereum continuing Solidity support. Furthermore, the Cardano team also recently announced Solidity support – making Solidity the single blockchain programming DSL supported in multiple blockchains.

The language itself was created with developer-adoption prioritized, which led to a syntax purposefully similar to the ever-popular Javascript with, of course, a few twists.

Learning Resources

Consensys Academy – https://consensys.net/academy/

Solidity Documentation – https://solidity.readthedocs.io/en/v0.4.24/

In Closing

Bitcoin & blockchain technology will continue to revolutionize the way data & assets are transferred — it’s clear that the impact will be global & industry-agnostic. No matter where you start, taking the first step in learning one of these languages is already a substantial first step. The mismatch in supply-demand for this skillset cannot be overstated.

Best estimates place the number of active developers worldwide, at around ~20M. Yet industry estimates state that less than 1 in a whopping 1000 active developers feel confident in their skillset to consider themselves blockchain programmers & are actively applying to open positions. For the less-arithmetically inclined, that means there are roughly around 20 thousand blockchain programmers.

If that seems like a lot let’s look at Microsoft – with a headcount of roughly 100k – let’s assume they have at least one support staff per software engineer, that leaves us with around 50 thousand programmers. On the flip-side, banking giant Goldman Sachs currently staffs ~9 thousand programmers & engineers.

The point is–this shortage of blockchain programmers is very real & the answer to your inner-dialogue but is it too late for me to start learning from scratch? is NO. For developers, investors, & regulators, and everyone else involved it’s still very early days.

The only question is what project do you want to start working on & what problem do you want to start solving?