2024

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

2023

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

2022

• Intentionally Making Close Friends
• The Art of Not Thinking
• What to Blog about
• Writing by hand is the best way to retain information
• Zettelkasten
• Advice that actually worked for me
• Brian Lovin - Writing
• Learning by Writing
• Only solve one new problem at a time
• Programming in the 21st century
• Pulumi
• Python Asyncio
• Speed Reading is Bullshit
• Work is Work
• A complete guide to useEffect
• React I love you, but you're bringing me down
• 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
• A walk through lightweight blogging
• How To Design A Chat Bot
• 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
• Hash Visualisation
• Here's Another Voronoi Code
• Open Logic Project
• Polymorphism in Python
• Book: Daily Rituals
• Book: The Now Habit
• Book: The War of Art
• Against SQL
• F# is the best coding language today
• Generating JSON Directly from Postgres
• Docker Compose Production Best Practices
• How to Get Rich
• Obsidian
• Umami
• Working in Godot with SQLite and C#
• Use Google like a pro
• Functorio
• Are You User Friendly?
• aria2
• Code Browser
• Complicated Haskell Words - Isomorphism
• Preql
• Redux vs. XState
• Serverless SQLite

2020

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

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