Articles
Comparative essays
Deep dives on how these languages relate, differ, and borrow from one another.
The Sigil Lineage: Perl, Raku, and Guji
How the $, @, % sigils travelled from Perl's variant punctuation to Raku's invariant names to Guji's shape-typed bindings.
From ML to Rust to Guji: a lineage of type systems and pattern matching
How algebraic data types, exhaustive pattern matching, and type-directed error handling travelled from OCaml's research roots through Haskell's pure type classes and Rust's systems pragmatism into Guji's text-first, one-obvious-way design.
Threads, Goroutines, async, and hatch: how these languages do concurrency
Five languages, five bargains with the same hard problem: how to do many things at once without the things tripping over each other.
TMTOWTDI vs One Obvious Way: language design philosophy
Two opposing slogans - Perl's 'There's more than one way to do it' and Python's 'one obvious way' - and how Raku and Go inherit the argument.
Text Processing Through the Ages: Perl, Raku, Python, and Guji
Four decades of teaching computers to read: from Perl's sigils and regexes to Raku's grammars, Python's batteries, and Guji's first-class parsing.
Compiled, Interpreted, or Both: execution models and what they cost
From Perl's one-pass interpreter to Haskell's lazy GHC backend, Rust's LLVM pipeline, and Guji's single native binary - the spectrum of execution models and the trade-offs each one buys you.
Null, None, and Nothing: how eight languages handle absence
Six languages, one question: when a value is missing, does the type system know, or does the program find out at 3am?
Exceptions, Results, and Panics: error-handling philosophies
How six languages answer one question: when something goes wrong, is failure a value you return or a control-flow event you throw?
One Function, Many Types: how each language does generics
Six languages, one shared problem: writing a single function that works across many types - and six different bargains struck between safety, dispatch, and ceremony.
What Haskell Teaches: purity, laziness, and the cost of side effects
How Haskell's pure, lazy core reframes side effects as data, and what OCaml, Rust, and Guji each keep, drop, or trade away.
Macros, Reflection, and Eval: metaprogramming compared
How six languages let programs write, inspect, and run programs - from compile-time macros to runtime eval - and what each one deliberately leaves out.
A Tour of Package Managers: cargo, opam, CPAN, pip, stack, and friends
How six languages each answer the same question - where does my code's code come from? - and why their answers differ.
First-Class Functions: closures, currying, and higher-order style
How eight languages treat functions as values - capturing closures, currying arguments, and threading behaviour through higher-order pipelines.
Immutable by Default, or Not: how eight languages treat change
Eight languages, one question - who has to ask permission before a value is allowed to change?
Loops, Iterators, and Laziness: how each language walks a sequence
Eight languages, one question: when you ask for the next element, who computes it, and when?
Ints, Floats, Bignums, and Overflow: the number story
How eight languages answer one quiet question: what happens when a number gets too big?
Batteries Included or Bring Your Own: standard-library philosophies
How eight languages draw the line between what ships in the box and what you fetch from the ecosystem - and why that line is a design statement.
Strings and Unicode: bytes, code points, and graphemes across eight languages
What does length even mean? Eight languages, three answers - bytes, code points, and graphemes.
Build, Run, REPL: the toolchain experience in eight languages
How eight languages answer the same three questions - how do I build it, run it, and poke at it live?