This is a short and non-technical blog post demonstrating why

the Haskell

programming language is a good choice for building

cryptocurrencies.

Cryptocurrencies are not your average software

Cryptocurrencies are different from other programs in one key

way: One mistake in the code can result in the instantaneous loss

of all value of all users.

This is not often the case with other software. In conventional

applications and services, mistakes in the code lead to downtime,

unsatisfied users, or a successful hack of the service provider.

Only in the rarest cases does this mean the complete and permanent

destruction of the service and all invested money being gone for

good. Recovery is usually possible for ordinary business software.

In cryptocurrencies code is money, so extra caution is

needed when writing it.

While other financial software also needs lots of caution,

mistakes in cryptocurrencies can be especially severe due to their

decentralised nature. Traditional banking has safety mechanisms

like chargebacks and contracts between banks that make it possible

to undo transactions correct mistakes after they happened. In

cryptocurrencies, money that's gone is usually gone for good.

Avoiding mistakes through good tooling

How do you avoid mistakes in your code? One way is to hire

excellent programmers. However, all programmers are humans and they

will eventually make mistakes. It's safer to have human-written

code cross-checked by a machine to the fullest extent possible. It

is crucial to use a programming language that makes mandatory

automated checks easy to write.

Haskell is a programming language that was designed for safety.

Haskell provides hard guarantees that certain kinds of

mistakes cannot be in the code. How does it do this? Let's look at

some features that make this possible.

Haskell safety features

• Memory safety. This means that you cannot

  accidentally modify values in your computer's memory that you did

  not intend to modify. Haskell prevents mistakes where garbage data

  is written into memory and the program is exhibiting arbitrary

  behaviour from that point. It also makes one of the most dangerous

  security vulnerabilities, remote code execution by an attacker, impossible.

• Static types.. Haskell enforces that the

  operations you do with your data are sound. Any function that

  processes data must declare what types of data (such as

  numbers, user names, cryptographic hashes) are consumed or produced

  by it. When you try to feed a function data of the wrong type

  Haskell will complain and refuse to build your code. This means the

  problem is detected long before the code ever ships, and in fact

  it's impossible to ship the code until the mistake is

  corrected. The types of all things being explicitly clear also

  makes it easier to understand the code. The ease of understanding

  enables programmers on your team to work faster and makes the job

  of external experts easier.

• Purity. Purity is the ability to prove the absence of unwanted side-effects. In Haskell you can indicate (usually done with the IO type) whether a

  function in the code has any interaction with the outside world. If

  you indicate that code doesn't interact with the outside world,

  Haskell guarantees that it will not do so. If a function with the type checkSufficientBalanceForTransaction :: User -> Amount -> Result does not carry an IO

  label you know it cannot access the Internet, that it cannot read

  any files, and that it cannot by itself have any visible effect on

  the world. You are guaranteed that all it can do is access the data

  that is passed in (the User whose balance is to be checked, and the Amount the user would like to send) and return a Result that says whether the user's

  balance is sufficient. This dramatically reduces the amount of code

  you have to vet against malicious inputs. Pure functions are

  guaranteed to always return the same output value given the same

  input values. This property allows the Haskell compiler to produce

  programs that run faster and use all available CPU cores. It also

  eases testing and quality assurance.

Haskell forces you to write code that is explicit, covers all corner cases, and is hard

to misunderstand.

Benefits of the Haskell ecosystem

Raw technical features are not the only reason why Haskell is

becoming popular for writing cryptocurrencies. It is also the

ecosystem that surrounds the language, and the mind set of Haskell

programmers that make it an attractive choice.

Quality focused community

Haskell tends to select for engineers who are particularly

interested in creating quality focused, high reliability software.

Some Haskellers started their programming career with Haskell and

stuck to it, but this is still rare. Most Haskellers chose Haskell

after a long journey in search for better tools and improved

productivity. They are often versed in many programming languages

and have explored myriad techniques.

Haskell programmers tend to be well trained and enjoy

understanding the problem domain before starting to code. This

discipline is crucial when working on high-risk projects like

cryptocurrencies.

The design and implementation of new programming language

features often happens in Haskell before they are adapted into

other languages. This entices software developers that wish to work

outside of current boundaries. The diversity, passion, and

experience makes the Haskell community a great place to build teams

for creating new technology.

Owning the toolchain

While Haskell and the surrounding tools and libraries are

sophisticated and require effort to get into, those that do master

them find themselves equipped with an unexpected power: being able

to own their entire programming toolchain. An expert Haskell

programmer can modify the code their team writes, the libraries

that the project depends on, down to the Haskell compiler that

creates the final machine code. This “hackability” of the Haskell

toolchain brings various benefits:

• If something doesn't work the way you want or need it too, you can change it.

• If you need a new compiler feature to make your code safer or easier to write, you can add it without too much effort.

• If the maintainer of a library you depend on no longer takes

  care of it, you can take over maintenance with relative ease. Tools

  like stack make this straightforward, allowing

  you to easily swap out upstream projects with your own forks. This

  reduces the risk relying on dependencies exposes to your

  project.

• Vetting the code of all your dependencies (which is critical for safety especially of cryptocurrencies) is a feasible task.

This is different compared to many other programming languages.

Even an expert C++ programmer often does not feel equipped to make

changes to the C++ compiler due to the complexities and sheer

amount of code involved. The GCC compiler has over 7 million lines

of code.

The Haskell toolchain is clean and consists of relatively small

amounts of code. GHC totals around 0.5 million lines,

including all of its Haskell dependencies. This makes it possible

for a single programmer to be familiar with Haskell's compiler,

runtime, and libraries in their entirety.

Summary

A number of technical and non-technical points come together in

making Haskell a great choice for cryptocurrency implementations.

This is especially true when it comes to safety and programming

ecosystems.

One of the biggest strengths of Haskell for cryptocurrencies is

its advertisability:

Haskell has a reputation for excelling in these areas.

It is already known and respected for providing strong guarantees

and for being made and used by experts. At time of writing coinmarketcap.com listed 1595 existing

cryptocurrencies. A new cryptocurrency can set itself apart from

that competition by drawing attention to the improved safety and

quality derived from being built in Haskell.

If you liked this post you may also like:

• Cardano and FP Complete team up to Audit Blockchain Technology

• Best Practices for FinTech Software

• 5 Killer Devops Strategies for Great FinTech Software

• 10 Common Mistakes to Avoid when Developing FinTech Software