What to learn in 2022
Tags: webassembly, wasi, javascript, microservices
Published: 2022-04-19 23:37:23

---
title: What to learn in 2022
published: true
description: Important technologies and programming languages to keep an eye on in 2022
tags: wasm, wasi, javascript, microservices
//cover_image: https://direct_url_to_image.jpg
---

I have a history of betting on technologies that later became very popular, like JavaScript in 1996 when everyone was saying that Java applets are the future, or Node.js in 2009 when everyone was saying that it would never get popular, or Deno in 2018 and WASI in 2019 - that you may still have not heard of.

Because of that, many people are asking me what is the next big thing to bet on. The truth is that I was always following much more things than only those that eventually got so popular, but what I follow is usually backed by reasons that I find important.

Here are some of the things on my radar that I believe are most important to keep an eye on in 2022.

## WASM and WASI

Links:

- https://webassembly.org/
- https://wasi.dev/

My reasons:
Norman Hardy, Jonathan S. Shapiro, Mark S. Miller

Long story...

In 2004 I created Wikipedia article for [KeyKOS](https://en.wikipedia.org/wiki/KeyKOS), and made some contributions to articles on [EROS](https://en.wikipedia.org/wiki/EROS_(microkernel)), and [capability-based security model](https://en.wikipedia.org/wiki/Capability-based_security) that was freshly created just few months before.

At that time I was sure that capability-based security is the way to go and the [BitC programming language](https://web.archive.org/web/20130815183427/http://www.bitc-lang.org/docs/bitc/spec.html) will be the future. I was really surprised that systems like GNOSIS, KeyKOS, EROS and Coyotos didn't gain more popularity.

Sadly, the BitC language never got finished and [its Wikipedia article](https://en.wikipedia.org/wiki/BitC) was [removed in 2017](https://en.wikipedia.org/w/index.php?title=Special:Log/delete&page=BitC), but meanwhile the capability model surfaced in the form of [Secure ECMAScript](https://github.com/tc39/proposal-ses) and [WebAssembly System Interface](https://github.com/WebAssembly/WASI).

And **that** is actually my personal reason why I am betting 100% on WASI - not the undeniable performance potential for light microservices and language-agnostic runtimes that will probably make it popular in the end, but its **security model** with deep roots in [MicroEssays on Capability Theory by Norman Hardy](http://www.cap-lore.com/CapTheory/), some of them written in the 1970s, which I found somewhere in the early 2000s and to this day I believe to be the most important articles about security that I've read so far, as I still find the capability-based security model to be the best model presented to date.

To fully appreciate Secure ECMAScript and WASI, one has to read articles and watch the talks by:

- Norman Hardy
- Jonathan S. Shapiro
- Mark S. Miller
- Lin Clark
- Steve Klabnik

Now, the creation [Bytecode Alliance](https://bytecodealliance.org/), the development of [multiple WebAssembly runtimes](https://github.com/appcypher/awesome-wasm-runtimes) and the work of the [W3C WebAssembly Community Group](https://www.w3.org/community/webassembly/) is why I belive it **will** get popular, but the capability-based security model is why I **want** it to get popular.

In my talk at WarsawJS in January 2020 I said that the most important technologies to follow are WebAssembly and WASI and I still believe so.

You can see my talk where no one in the audience knew what WASI was and very few people knew about WebAssembly:

{% embed https://youtu.be/kuscscuKTa8 %}

I remember when I was already excited about the development of WASI and I saw this tweet from Solomon Hykes, founder and CTO of Docker, in March, 2019, that reassured me about my intuition. I am always quoting it when talking about WASM and WASI:

{% embed https://twitter.com/solomonstre/status/1111004913222324225 %}

I believe that Web development will change forever because of WebAssembly. And how we understand microservices and cloud computing will change because of WASI.

For that reason while evaluating programming languages today, my recommendation is to always look at how important for them is targeting WASM and WASI, and how well they are suited for that.

That means that the first languages to support WASI when it gets traction, may be relatively low-level, non-garbage-collected system languages.

Now, after this short introduction, finally some languages.

## Programming languages

Programming languages to keep an eye on in 2022, in the context of WASM and WASI

### Rust

- https://www.rust-lang.org/
- https://github.com/rust-lang/rust

Rust probably needs no introduction, especially in the context of WASM. Pretty much all of early tools for WASM were written in Rust, and Rust has been used in many WASM examples from the very beginning.

### Zig

- https://ziglang.org/
- https://github.com/ziglang/zig

Great little language with interesting ways of how it handles errors and memory allocation. It supports WASM as one of its build targets.

### AssemblyScript

- https://www.assemblyscript.org/
- https://github.com/AssemblyScript/assemblyscript

It is pretty much a version of TypeScript that is stripped down to run on WASM.

### TinyGo

- https://tinygo.org/
- https://github.com/tinygo-org/tinygo

A smaller Go version developed for embedded systems that is also well suited for WASM targets.

### Odin

- https://odin-lang.org/
- https://github.com/odin-lang/Odin

A interesting data-oriented language, used for graphical effects in movies.

### Nim

- https://nim-lang.org/
- https://github.com/nim-lang/Nim

A statically typed compiled systems programming language with Python-like syntax.

### Grain

- https://grain-lang.org/
- https://github.com/grain-lang/grain

An interesting strongly typed functional language. It targets WASM as it's main (only?) compilation target.

### JavaScript and TypeScript

- https://tc39.es/
- https://github.com/tc39/proposals
- https://www.typescriptlang.org/
- https://github.com/microsoft/TypeScript
- https://nodejs.org/
- https://github.com/nodejs/node
- https://deno.land/
- https://github.com/denoland/deno

JavaScript and TypeScript will always be popular, but those languages will not be the first to **target** WASM and WASI because of many reasons like big runtimes and garbage collection, but will be important to **host** other WASM-targeting languages and to bridge them with DOM and other Web APIs.

## Runtimes

### Wasmtime

- https://wasmtime.dev/
- https://github.com/bytecodealliance/wasmtime

### WAMR

- https://github.com/bytecodealliance/wasm-micro-runtime
- https://www.intel.com/content/www/us/en/developer/articles/technical/webassembly-interpreter-design-wasm-micro-runtime.html

### Wasmer

- https://wasmer.io/
- https://github.com/wasmerio/wasmer

### More

More WASM runtimes:

- https://github.com/appcypher/awesome-wasm-runtimes

## Frameworks

### Spin

- https://spin.fermyon.dev/
- https://github.com/fermyon/spin

Spin is not a language but a framework for cloud microservices written in other languages that can compile to WebAssembly.

More of the tech that I currently follow is in my GitHub README:

- https://github.com/rsp

Let me know in the comments what you think about those languages both in the context of native targets and WASM. I'd like to hear about your experiences.

## Platforms

### wasmCloud

- https://wasmcloud.com/

wasmCloud is one of the most interesting things that I've found lately and it's hard to explain what it is in just one sentence.

The description of its website says: "wasmCloud is a platform for writing portable business logic that can run anywhere from the edge to the cloud, that boasts a secure-by-default, boilerplate-free developer experience with rapid feedback loop."

It is something that I had in mind for quite some time but didn't know it existed, and when I found it I was really delighted.

If I had to explain the idea quickly I would say that it is a platform for running and orchestrating little WebAssembly programs (that are written in Rust or anything that is compiled to WebAssembly) called Actors, that contain just business logic with no boilerplate related to connecting to databases and other services.

You really need to watch their demos and other presentations to appreciate the idea.

### Cosmonic

- https://cosmonic.com/

"Distributed Application Platform, for the enterprise" - based on wasmCloud. From what I understand it's like a hosted wasmCloud. Not available yet but you can sign up now for early access.