Building a Compiler Backend (Part 4: ARM)

The story of how I became a compiler developer, I guess. It’s time to add a backend for a new CPU – by copying an existing one.

Building a Compiler Backend (Part 3: Standard Library)

The story of how I became a compiler developer, I guess. As one final stop before I start explaining the new backend features, I’ll take a look at the Callisto standard library.

Building a Compiler Backend (Part 2: Compiler)

The story of how I became a compiler developer, I guess. This time, I’m digging into how the Callisto compiler works in general, as background for what I worked on next.

#48in24 – Four Interesting Solutions

I’m finally getting back to doing some #48in24 challenges, and picked out a few highlights to share. It’s got low-level assembly, declarative programming, and more!

Building a Compiler Backend (Part 1: Callisto)

The story of how I became a compiler developer, I guess. In the first part, you’ll see how a tiny benchmark program got me hooked on a neat little stack language.

#48in24 – Week 13: Scrabble Score

It’s time for that one well known word game! …no, not Wordle. I’ll show off a neat one-liner (not really), as well as a really terrible hack. Featured languages: Python, Scheme, C.

#48in24 – Week 12: Luhn

This week, I’m steali– sorry, validating credit card numbers. The featured exercise is the Luhn algorithm, used to check all card numbers. Featured languages: TypeScript, Perl, AWK.

#48in24 – Week 11: Sieve

Sifting through numbers is a remarkably neat way to generate primes, so we’re looking at the Sieve of Eratosthenes in three languages this week! Featured languages: Zig, Bash, Fortran.

#48in24 – Week 10: Allergies

Achoo! Week 10’s exercise is all about allergies, and I’ll be looking at bit fields and metaprogramming to solve it. Featured languages: Nim, Elm, Rust, plus a bonus!

#48in24 – Week 9: Parallel Letter Frequency

Counting letters, but fast! (and hopefully without race conditions…) Featured Languages: Go, Java, Elixir.

#48in24 – Week 8: Circular Buffer

It’s week 8, which is a pretty circular number - and I’m writing some circular buffers! Featured languages: C, Groovy, Scala, plus a bonus one!

#48in24 – Week 7: Acronym

TWWBLAA! (This week we’ll be looking at acronyms!) Sounds simple enough, but there are a few tricky cases to catch. Featured languages: Haskell, Tcl, PowerShell.

#48in24 – Week 6: List Ops

This week, the battle of procedural and functional programming takes place… and a third thing? Featured Languages: Gleam, Swift, Standard ML.

#48in24 – Week 5: Protein Translation

I get to learn about biochemistry and functional programming in the same week of #48in24, what a deal! Featured languages: F#, Crystal, C#.

#48in24 – Week 4: Roman Numerals

In Week IV of #48in24, Roman numerals are the focus, and some relatively obscure languages were chosen. Featured languages: Elixir, Pharo, Julia.

#48in24 – Week 3: Raindrops

Objects and vectors and macros, oh my! This week is all about Exercism’s take on FizzBuzz. Featured languages: Ruby, R, Common Lisp.

#48in24 – Week 2: Reverse String

!2 keew rof emiT – sorry, time for week 2! This week the task is to reverse some strings, which is pretty simple… until it isn’t. Featured languages: JavaScript, Nim, C++.

#48in24 – Week 1: Leap

Week 1 of #48in24 is here, and we’re leaping into it by looking at leap years! Featured languages: Python, Clojure, MIPS Assembly.

#48in24 – Introduction

#48in24 is a year-long challenge from the Exercism coding practice and mentoring site. As the year goes on, I will document my experience with it here.