Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Parser CombinatorsBetter than regex!
A hands-on TypeScript introduction to parser combinators: starting from a partial parser type, chaining parsers with sequencing and mapping, and building up a hand-rolled combinator library that parses real ping output into structured data, as a cleaner middle ground between regex and tree-sitter.
7 min · 1,661 words
I built a programming language that LLMs can't use
Dominik Picheta introduces KillSwitch, an esoteric language designed to confound coding agents, and reports how frontier models fare on a small human-solvable task set.
3 min · 803 words
ConcurrentML: Improving on Go's concurrency model
Nikhil explores Concurrent ML-style first-class events as a richer concurrency model than Go's channels alone: wrapping and composing communication operations, selective choice, guard events, and cancellation, with Racket ConcurrentML as the reference and notes on how Go falls short.
28 min · 6,476 wordsagent-assisted
Daniel Temkin's Folders is an esolang where programs are encoded purely as nested directory structures—no file contents required—updated for 2026 among his Forty-Four Esolangs.
4 min · 820 words
Interactive refactoring in gopls
The Go team introduces interactive refactoring in gopls, built on a new Language Server Protocol capability designed with the Dart team as an open standard, which lets refactorings run as dynamic multi-step dialogs inside any editor. The post explains the LSP background, walks through example refactorings, and outlines what comes next and how to give feedback.
6 min · 1,468 words
Lean Now Ships with Verified Kernels
Leonardo de Moura explains how Lean v4.35 hardens proof checking after AI-found kernel soundness bugs: a sandboxed `lake check` that rechecks developments with the official kernel, four additional independent kernels, and the scaling challenges ahead for multi-million-line proof libraries.
3 min · 708 words
The Rust team released 1.99.1, a point release fixing regressions from 1.99.0. The post lists the notable fixes and points users at rustup update as the upgrade path.
1 min · 321 words
Gleam case exhaustiveness, as a fan
A Gleam enthusiast walks through how the language's exhaustiveness checking shapes nested decision trees, pattern matching and day-to-day refactoring confidence, celebrating compile-time guarantees that catch incomplete case analysis.
12 min · 2,860 words
Abner Coimbre describes how he writes modern C in late 2026 after C23: naming, headers, types, error handling, and the conventions he kept from older 'How I Write C' guidance while adopting new language features.
4 min · 939 words
I built the RealWorld app in Lean 4
A Leangineering write-up on building RealWorld, the Medium-clone reference app with official API and website test suites, entirely in Lean 4, from the HTTP server to the frontend. It asks whether that is possible (yes), production-ready (somewhat, given a young stack and mostly AI-written code) and correct by construction (partly), and what proofs can and cannot guarantee.
11 min · 2,641 words
Making all divisions slower to fix a bug in 0.000000000000000000542% of cases
The Futhark compiler blog explains how signed integer division by -1 of the most negative two's-complement integer is undefined behaviour in the C code Futhark generates, how the compiler now adds a branch to every signed division to handle that single case correctly, what that costs on contrived and real benchmarks, and why unsigned division avoids the overhead.
8 min · 1,822 words
Types of types: Haskell's Kind system
A practical tour of Haskell’s kind system—values, types, kinds, higher-kinded types and data, and custom kinds—drawn from adding typed configuration to a Redis clone.
15 min · 3,422 words
Fun Extending the C Preprocessor
David Priver, who is writing his own C2Y compiler/interpreter/REPL, shows extensions he added to its C preprocessor, including __print() and __where() debugging builtins, a native __map() that replaces recursive macro hacks, and __VA_COUNT__ for counting variadic arguments.
5 min · 1,147 words
Release notes for Factor 0.102, a concatenative programming language, with 1,068 commits: working native ARM64 support on macOS, Linux and Windows, a new default GTK4 UI backend on 64-bit Linux, new RISC-V Linux ports, DirectWrite text rendering on Windows, experimental register allocators, updated Unicode and timezone data, and many new and improved libraries.
21 min · 4,934 words
C vs C#: racing VLC's Gaussian blur
Martin Finkel ports a real VLC video filter, the Gaussian blur, line by line to C# with .NET Native AOT and races it against the original C inside VLC 4 on the same frames with byte-identical output, then optimizes both sides and compares again.
9 min · 2,060 words
Crystal 1.22.0 ships 251 changes from 33 contributors: standard streams now exit on EPIPE like SIGPIPE, revamped DWARF parsing, a native event loop on all targets, LLVM 23 and 24 support, aarch64-linux promoted to Tier 1, and Process.fork removed.
4 min · 808 words
C++26 Contracts: Introduction to Preconditions and Postconditions
C++ Stories introduces C++26 contracts: pre() and post() on function declarations and contract_assert() inside functions, why they beat assert, the ignore/observe/enforce/quick-enforce evaluation semantics, compiling examples with GCC, const parameters in postconditions, avoiding side effects in predicates, predicate cost, and why contracts are not a replacement for input validation.
9 min · 2,052 words
Why 'externalized' proofs of cyclic trait impls does not work
Niko Matsakis compares modular proofs, where an impl must establish its supertraits, with external proofs, where users of the impl carry that obligation, and argues that external proofs are incompatible with Rust as designed, so cyclic trait impls require a modular strategy.
7 min · 1,585 words
The stable release of Python 3.15.0, with 5,643 commits from 1,012 contributors: sentinel and frozendict built-ins, UTF-8 by default, explicit lazy imports, unpacking in comprehensions, a significantly faster experimental JIT, the Tachyon sampling profiler, new typing features, a stable ABI for free-threaded builds, and frame pointers enabled by default.
3 min · 704 words
A follow-up to a post on math_errhandling that digs into strtod and friends, showing why errno and floating-point exceptions cannot portably detect overflow, underflow or invalid input in standard C across glibc and musl, and what checks you can do instead.
7 min · 1,594 words