Advent of Code

Advent of Code is an annual programming challenge that runs through December: 25 days, two puzzle parts each. The puzzles range from straightforward parsing and simulation problems in the early days to genuinely tricky graph problems, dynamic programming, and custom virtual machine emulation by the end. It has a dedicated following of competitive programmers, language learners, and people who just enjoy the puzzle-solving ritual.

I've used AoC as a deliberate tool for language learning: rather than working through tutorials or toy exercises, I pick a language and throw myself directly into real problem-solving. Constraints force familiarity fast. Both years I completed all 25 days, both parts — which is less common than it sounds; the later days are genuinely difficult.

2023: Learning Rust

---

I'd been curious about Rust for a while. The ownership model, the performance guarantees, the way it treats memory safety as a compile-time constraint rather than a runtime hope. AoC 2023 was my first serious exposure to it.

The early days went slowly. The borrow checker pushes back hard on patterns that feel natural in other languages: passing data into a closure while also holding a reference, mutating a collection while iterating over it, returning a reference to something created inside a function. Each error message is genuinely helpful, which makes the learning curve steep but not opaque.

By mid-December I was writing idiomatic Rust: using iterators instead of index loops, reaching for HashMap and BTreeMap naturally, understanding when to clone and when to fight the borrow checker harder. The grid-walking and pathfinding problems (BFS/DFS, Dijkstra) in week 3 were where everything clicked.

Source: github.com/YentlHendrickx/rust-aoc-2023

2024: Learning Go

---

After Rust, Go felt deliberately minimal. No generics headaches (at the time), no lifetime annotations, garbage collected. The language gets out of the way. AoC 2024 was about learning Go's idioms: how it handles concurrency with goroutines and channels, how error handling works as values instead of exceptions, and what "idiomatic Go" actually means in practice.

The contrast with Rust is striking. Where Rust makes you prove correctness at compile time, Go trusts you and catches problems at runtime. The toolchain is fast and opinionated. gofmt means no bikeshedding about formatting, and the standard library covers most of what you need without reaching for external packages.

The puzzles that benefited most from Go's concurrency model were the simulation-heavy days: running many independent state machines in parallel with goroutines and collecting results over channels is genuinely elegant once the pattern clicks.

Source: github.com/YentlHendrickx/go-aoc-2024