2025

• Computer Science Logo Style vol. 1
• Local, first, forever
• SuperMemo: Incremental reading
• Question Classification Using a Knowledge-Based Semantic Kernel
• Local-First Software
• The skill of the future is not 'AI', but 'Focus'
• Incremental reading - supermemo.guru
• Patterns for Personal Web Sites
• Why Test-First Development Is So Damn Hard
• On Long Term Software Development
• Advent of Papers (2024)
• What is Good Design?
• Best practices for prompt engineering
• Reality has a surprising amount of detail
• Good, Fast, Cheap: Pick 3 or Get None
• Trying out Zed after more than a decade of Vim/Neovim
• Surnames from nicknames nobody has any more
• Why I Chose Common Lisp
• Calendar.txt
• AI Tools — Find the Best AI For Your Needs
• How Does Ada's Memory Safety Compare Against Rust?
• Embedding Wikipedia articles for search
• Rich Hickey's greatest hits
• Generating Voronoi Diagrams using Fortune’s Algorithm
• In Defense of Text Labels
• 20 years working on the same software product
• Catalyst
• Why is the Greek def. article used in John 1:1b but not John 1:1c?
• My LLM codegen workflow

2024

• Why I don't do Domain Driven Design
• Framework Overload
• StarFX
• React Scan
• Feminism in Programming Language Design
• The Private Definition of Accessible
• Testing Without Mocks
• Why React Re-Renders
• The High-Interest Credit Card of Technical Debt
• 6 things I learned interviewing for Staff positions
• Q Document (pdf)
• Mise
• Lies I was Told About Collaborative Editing
• 10 Great Bible Films
• Intuition in Software Development
• The Essence of Christianity
• The Copenhagen Book
• Anemic Domain Model
• Unlocking the Power of JSON Patch
• An experiment in fighting spam on public forms
• Haskell A Great Procedural Language
• Get Me Out of Data Hell
• How to Think About Time
• What's wrong with DateTime anyway?
• Learn REBOL
• The Collapse of Self-Worth in the Digital Age | The Walrus
• Some Go web dev notes
• The UX of HTML - HTMHell
• Something went wrong – Ways out of the JavaScript crisis
• Working with Protobuf in 2024
• CRDTs go brrr
• Common Lisp HTML5 generator
• Flat UI Elements Attract Less Attention and Cause Uncertainty
• Too much efficiency makes everything worse
• How to Build a Strong Work Ethic
• 10 Years of Programming
• Notes on Crystal
• They don't make readers like they used to
• Recovery-Oriented Computing (ROC) Overview
• Connect RPC
• The Ultimate Guide to Writing Online - David Perell
• A Gentle Introduction to Symbolic Computation
• Why is F# code so robust and reliable? - .NET Blog
• Practices of Reliable Software Design
• Beyond the Frame | What If Data Is a Bad Idea?
• Reckoning: Part 1 — The Landscape - Infrequently Noted
• Stop using SERIAL in Postgres
• Haystack
• Creating and triggering events - Event reference | MDN
• Writing for Software Engineers: Beyond the Basics
• Writing for Software Engineers: Read Me First
• Coalton: How to Have Our (Typed) Cake and (Safely) Eat It Too
• The algebra (and calculus!) of algebraic data types
• Practical Common Lisp
• Where is the programmer inspo?
• Defense of Lisp macros: an automotive tragedy
• Clojure - Transducers
• Copying is the way design works
• Tests you love to read, write and change
• Running Lisp in Production
• Dabblers And Blowhards
• What's the value for a programmer to learn Common Lisp these days?
• FastHTML - Modern web applications in pure Python
• A skeptic's first contact with Kubernetes
• A Few FORMAT Recipes
• Clojure - Transducers are Coming
• Exploring the Power of Negative Space Programming
• My mental model of setf was wrong
• Go is a Pretty Average Language
• Tiger Style! - ratfactor
• How to think in writing
• The Power of Prolog
• Picat Language
• My Programming Beliefs as of July 2024
• Testability = Modularity
• Abilene paradox
• My Principles for Building Software
• Basic Things
• Worst practices should be hard
• The Perceived Speed of Computers
• pyinfra
• Save the Web by Being Nice
• Webmentions (Dev)
• A Forth Story
• Beautifying Org Mode in Emacs
• A Pattern Language
• Optimizing SQLite for servers
• Exploratory Programming
• 40 years of programming
• Optimal SQLite settings for Django
• Black Grouse Theory
• Failing at Combinatorics with Haskell
• Your Interview Process Is Too Damn Long
• A rational design process: how and why to fake IT
• Functional False
• What Factors Explain the Nature of Software
• A Note on Essential Complexity
• Why books don't work
• Book: Naming Things
• Pivotal mental states
• Dynamic Programming is not Black Magic
• The Hearers to Collection: T.S. Eliot’s The Waste Land
• Think more about what to focus on
• GitHub Copilot Research Finds 'Downward Pressure on Code Quality'
• A 2024 Plea for Lean Software
• A Tour of the Lisps
• Approaching a New Speed Limit for ILP
• Safely making database schema changes
• Review: A Philosophy of Software Design
• epoll: The API that powers the modern internet
• How we Increased Search Traffic by 20x in 4 Months
• Common Lisp Resources
• Kubla Khan
• Comments on fast vs slow compile cycles
• 12 Modern CSS Upgrades
• Why Is Everything So Ugly?
• Bottleneck #06: Onboarding
• Optimal function length
• Programming: Lessons Learned

2023

• Belief and its role in science
• Maybe Haskell
• Why your F# evangelism isn't working
• Stop building databases
• Code is run more than read
• Parse, don't validate
• Why Do Everyone’s Logo Fonts Look the Same?
• Many explanations of JOIN are wrong
• How to Read a Paper
• Confusing git terminology
• The Wizardry Frontier
• “Useless Ruby sugar”: Argument forwarding
• Decker
• Why is it so hard to buy things that work well?
• Push Ifs Up And Fors Down
• The Decline of Usability: Revisited
• This is your brain on books
• In defense of simple architectures
• When static types make your code shorter
• The Revised Psychology of Human Misjudgment
• Things you're allowed to do
• Open Data Structures
• A Better Explanation of the Liskov Substitution Principle
• Just because it's old, doesn't make it tech debt
• Choose Boring Technology
• The C4 Model
• Bad Emacs defaults
• Component Programming in D
• What is .NET, and why should you choose it?
• Lets just try it
• The Gentle Art of Patch Review
• Fortunes Algorithm: Explanation and Implementation
• Elixir for Cynical Curmudgeons
• Leaving Haskell behind
• Je ne sais quoi
• The Elmish Book
• Taboo OO
• Git Magic
• How to Roman Republic 101, Part I: SPQR
• Without Belief in a God, But Never Without Belief in a Devil
• It's 2023, so of course I'm learning Common Lisp
• Building a Programming Language in Twenty-Four Hours
• Haskell Fan Site
• The Staff Engineer's Path
• Reading Slightly More Incrementally
• Forth: The programming language that writes itself
• Where have all the hackers gone?
• The Ultimate Deliberate Practice Guide: How to Be the Best
• Litestream - Streaming SQLite Replication
• Mental Liquidity
• Writing Python like it's Rust
• Caddy
• Imaginary Problems Are the Root of Bad Software
• The Timeless Way of Programming
• Sixteen Days of Haskell
• Fear of Macros
• Raku is pretty damn Cool
• An On-Ramp to Flow
• Kata, Kumite, Koan, and Dreyfus
• Coding Challenges
• OOP vs type classes - HaskellWiki
• How To Survive Your Project's First 100,000 Lines
• Radical Simplicity in Technology
• Characterizing Tech Debt
• The seven programming ur-languages
• Local state is harmful
• First Principles of Interaction Design
• 916 days of Emacs
• Laws of UX
• It’s worth putting in the effort to regularly update dependencies
• Explore the In Our Time archive
• Category Theory Illustrated
• Combinatory Logic
• Demystifying Type Classes
• SQLite performance tuning
• Janet for Mortals
• All you need is data and functions
• The Codeless Code
• Rust-based platform for the Web – SWC
• 'Modules Matter Most' for the Masses
• Dream - a web framework for OCaml
• Writing - Apple Human Interface Guidelines
• A fast, local neural text to speech system
• Edward Tufte: Books - Envisioning Information
• Haskell is not category theory
• My Future with Elixir: set-theoretic types
• Rewrite, refactor, or reinvent?
• I learned 7 different programming languages so you don't have to
• Monadic Comprehension Syntax via LINQ in C#
• The case for frameworks
• Beautiful Binary Search in D
• On Technical Debt: Shoveling forward
• Squeezing a Sokoban Game into 10 Lines of Code
• The Market for Lemons
• The Case for Models
• Right and Wrong - ten choices in language design
• Understanding Onion Architecture
• How the Blog Broke the Web
• Protection System Conceptual Design
• Component Programming with Ranges
• Challenging DSAs every programmer should try
• Surviving disillusionment
• Why and how to write things on the Internet
• The Art of Money Getting
• More challenging projects every programmer should try

2022

• What to Blog about
• The Art of Not Thinking
• Intentionally Making Close Friends
• Zettelkasten
• Writing by hand is the best way to retain information
• Python Asyncio
• Learning by Writing
• Advice that actually worked for me
• Pulumi
• Only solve one new problem at a time
• Programming in the 21st century
• Speed Reading is Bullshit
• Brian Lovin - Writing
• Work is Work
• React I love you, but you're bringing me down
• A complete guide to useEffect
• Unbounded sieve of Eratosthenes
• Transitional Apps with Phoenix and Svelte
• Calculus Made Easy
• C++ Frequently Questioned Answers
• Ruby for the self-taught developer
• Making the world's fastest website, and other mistakes
• Algorithmica / HPC
• How To Design A Chat Bot
• A walk through lightweight blogging
• Hyperscript
• Effortless personal productivity
• Failing to Learn Zig via Advent of Code

2021

• Assign Multiple Engineers to the Same Task
• An Integer Formula for Fibonacci Numbers
• Polymorphism in Python
• Open Logic Project
• Here's Another Voronoi Code
• Hash Visualisation
• Book: The War of Art
• Book: Daily Rituals
• Book: The Now Habit
• F# is the best coding language today
• Generating JSON Directly from Postgres
• Against SQL
• Docker Compose Production Best Practices
• Obsidian
• Umami
• Working in Godot with SQLite and C#
• How to Get Rich
• Use Google like a pro
• Functorio
• Redux vs. XState
• Complicated Haskell Words - Isomorphism
• Code Browser
• Are You User Friendly?
• aria2
• Preql
• Serverless SQLite

2020

• OWASP Session Management Cheat Sheet
• Haskell for Imperative Programmers
• To compute a constant of calculus
• Functional Design and Architecture
• Beginning Raku
• pg_cron
• Game of Life (32b)
• Modern Object Pascal Introduction for Programmers
• Getting Started with Org Mode
• The Construction and Use of C++ Algorithms
• Typeclassopedia
• Building a Desktop App using Svelte and Electron
• On The Shoulders of Giants
• NOAA Satellite Signals With a PVC QFH Antenna and Laptop
• Lambda? You Keep Using that Letter
• Org Mode Reference Card
• C++20 Concepts - Testing constrained functions
• OWASP Authentication Cheat Sheet

2019

• re2c
• Functional Programming in OCaml
• 3D Cube World Level Generation
• Postmodernism
• Lazy Functional State Threads
• The Surprising Rigidness of Higher Rank Kinds
• Use constexpr for faster, smaller, and safer code
• Recursive Permutations | Programming Abstractions
• Empirical analysis of programming language adoption
• Some thoughts on security after ten years of qmail 1.0
• Cache Oblivious Algorithms and Data Structures
• Game Engine Programming - Animation Playback
• A Practical Theory of Programming
• Painless Functional Specs (Part 1 of 4)
• Software Requirements Spec
• GrassGIS RaPlaT Main Page
• Links to Ada Gems
• How to remember everything you'll ever learn
• The True Power of Regular Expressions
• Game Engine Programming - Animation Groundwork
• R-trees with Voronoi Diagrams for Spatial Nearest Neighbor Queries
• CMMI
• Declarative Behavioural Requirements with Control State Hierachy
• How to build static checking systems using orders of magnitude less code
• Computational Geometry - Algorithms and Applications
• Learning Skills You Can Practice
• Generation of polygons characterizing the shape of a set of points
• Precomputed Atmospheric Scattering
• Write-up - Out of the tar-pit
• Investing Advice Inspired by Jack Bogle
• Code generation with templates
• Software Verification - Model Checking vs. Testing
• Finite and Infinite Games
• The Sound of Space-Filling Curves
• Code Review Checklist
• Terrain Erosion 3 Ways
• Alloy
• A viewshed algorithm for large terrain maps on a CUDA GPU
• Programming from the Ground Up
• Creating a language using only assembly language
• Write code that is easy to delete, not easy to extend
• Perl, the first postmodern computer language
• Marian Petre and Andre van der Hoek on Software Design
• Pharo by Example 5
• Generating call graphs for Python code
• Smooth Voxel Terrain
• Lessons from Building Static Analysis Tools at Google
• Traditional assignment considered harmful
• Collection of good talks/videos
• The Smalltalk-80 System
• How to Solve It
• Ada Concurrency
• Functional Data Structures
• Divisibility by 7 is a walk on a Graph
• A high-performance parallel radio coverage prediction tool for GRASS GIS
• Continuous Distance-Dependent Level of Detail for Rendering Heightmaps
• PyColorPalette
• TRPL PDFs
• Fortune's Algorithm - The Details
• AVL Tree Tutorial
• Mental maths prime factorisation
• FreeCAD
• Groups - A Primer
• Fast Computation of Generalized Voronoi Diagrams
• Word numbers, Part 1 - Billion Approaches
• Information Theory, Inference, and Learning Algorithms
• Perlin Noise Explanation