When I want to build an operating system, a programming language or a tool, I reach for Rust. This is the first post in a series about the tools I reach for and why: not a ranking of languages, but the reasons one of them became my default, from a career of trying to move from each language to something better.

Resource Link
Rust rust-lang.org
The longer timeline TBT #13: Many Decades of Learning the Next Thing
Built in Rust, lately X_eTaL, reva-fork
Array Languages sw-mlpl, X_eTaL
The series Why I Use: every post
Comments Discord

It started with macros

One of my first systems programming languages was IBM’s PL/S (in its PL/S-III form), which I used from 1981. Its macros were executable: code that ran during compilation and generated the code to be compiled. A macro could look at its arguments, compute, and write exactly the source it wanted. Compared with the alternatives, and the C preprocessor in particular, which only substitutes text, that was much better, and it set a bar I kept measuring later languages against.

A career of moving to the next improvement

Through my career I kept trying to move from a language to an improvement on it. The path went:

Step Languages
The start assembler
Systems PL/S-III
The next generation C and C++
Managed Java
Java’s derivatives Clojure, Forte 4GL, Gosu, Groovy, Kotlin, Scala
Tried F#, Go, Julia, Python

Each had its quirks, and each had its pros and cons. None of them was the last stop. (TBT #13 has the full timeline, with the years.)

Past the borrow checker

Rust has a well-known hurdle: the borrow checker, which refuses code whose ownership of memory it cannot prove safe. Getting past it takes a while. Once I had, what was on the other side was what I had been looking for:

  • Macros I like to use. Rust’s macros run at compile time and generate code, the PL/S idea again, with declarative macros for patterns and procedural macros that are ordinary Rust programs over the source.
  • A really good build system, ecosystem and tooling. Cargo builds, tests and fetches dependencies the same way everywhere, and the crates and tools around it are there for nearly anything.
  • The targets I build for: command-line tools, desktop apps, the web, embedded systems and GPUs.

Everywhere I want to run

Rust supports Linux, macOS, Windows and more. Below the operating systems it runs on an RTOS or on bare metal. It compiles to WebAssembly, for the browser or the server. One language covers the whole range, from a microcontroller to a web page.

Whole classes of errors, and no runtime to pay for

Rust prevents entire classes of errors at compile time: memory errors such as use after free, and data races between threads. It does that without a garbage collector, so there are no collection pauses, and without the overhead of a p-code interpreter. It compiles to native code, so there is no need for a JIT.

The compile times

A block print of a pocket stopwatch, its face cut away to show the gears inside

Yes, people complain that Rust compiles slowly, and that is fair enough. For my situation it rarely bites. I combine Rust projects so that I generally compile only a subset at a time, and I build on beefy systems with many cores and lots of RAM.

For pleasure, and for demos

Rust is not the only language I enjoy. From a coding-pleasure point of view, Ruby, Clojure and JavaScript were fun. And I enjoy building and playing with APL, Forth and Lisp, which I build in assembler, C or Rust, or, in Forth’s case, in Forth itself (Embedded #4 is the latest of those).

So the split is simple. When I want to build an operating system, a programming language or a tool, I reach for Rust. When I want to demo a concept, I choose an interactive language with a REPL; I reach for APL, Forth, Lisp, or one of my array languages. By a demo I mean showing one idea, an algorithm, a data structure or a piece of how a language works, in as little code as lets someone see all of it at once, usually live at a REPL. A Rust program is built to last and to be maintained; a demo is built to be understood, and those languages get the idea onto the screen with the least in the way.

[Ed. 2026/10/28: the closing paragraph now says that for a demo I choose an interactive language with a REPL. Post history.]