Ian K. Duncan
Software engineer
IndexEngineering

Engineering

Technical writing on software engineering, programming languages, distributed systems, and building reliable software.

Every piece carries a stability level and remains subject to revision.

28 essaysUpdated 07.08.2026

2026

  1. Getting Freaky in the Age of AI stable The only way to have a competitive edge in the age of AI is to be aggressively weird with what you build.
  2. The Mathematics of Build Queue Optimization and Auto-Scaling stable A deep dive into queueing theory and auto-scaling for CI/CD build fleets, exploring when and how to optimize build infrastructure for both cost and developer productivity.
  3. Deconstruct the Monolith: Composable App Bootstrapping with Fractal Layer stable How fractal-layer attacks the compilation bottleneck and initialization chaos of the monolithic App datatype by treating startup as a composable graph of resource-managed layers.
  4. What’s in the Box? A Field Guide to AI Models stable A beginner-friendly tour of parameters, quantization, MoE, context windows, and other LLM jargon.
  5. Stealing from Biologists to Compile Haskell Faster stable The trick that makes GHC’s ApplicativeDo optimization faster is structurally identical to how biologists predict RNA folding.
  6. Making Haskell Talk to PostgreSQL Without Suffering stable How to eliminate the three performance taxes that make database queries slow: encoding overhead, round-trip latency, and N+1 query patterns.
  7. Archive: Automatic Optimal Pipelining of Redis Commands stable Archived from Informatikr (originally published January 18, 2012). Describes how the Haskell Redis client Hedis achieves automatic and optimal pipelining by combining lazy I/O with a synchronous-looking API, getting the best of both synchronous and asynchronous approaches.
  8. TIL: HTTP/3 Is Not Always Faster Than HTTP/2 stable Local benchmarks revealed HTTP/3 can be 50-100x slower than HTTP/2. QUIC’s userspace implementation loses to decades of kernel TCP optimizations on high-bandwidth, low-latency networks.
  9. What Functional Programmers Get Wrong About Systems stable Type systems verify properties of programs. Production correctness is a property of systems. The gap between these is where the interesting failures live.
  10. In Praise of Control Planes, or: Why You Need a Place to Stand stable The control plane pattern (a coordinator that tells workers what to do) shows up everywhere good infrastructure exists. The concept is simple. Naming it is useful.
  11. Your Best Thinking Is Wasted on the Wrong Decisions stable Some engineering decisions punish you for being wrong. Most don’t. Learning to tell the difference and calibrate your deliberation accordingly might be the most valuable skill your team never explicitly develops.
  12. No, Really, Bash Is Not Enough: Why Large-Scale CI Needs an Orchestrator stable A deeper dive into why shell scripts cannot replace a proper CI control plane, drawn from years of building and operating CI systems at scale.
  13. GitHub Actions Is Slowly Killing Your Engineering Team stable Why GitHub Actions is the Internet Explorer of CI, and why Buildkite offers a better path forward for teams that care about developer experience.

2025

  1. Punycode: My New Favorite Algorithm stable A deep dive into how Punycode works, and why I think it’s so neat.
  2. The CRDT Dictionary: A Field Guide to Conflict-Free Replicated Data Types stable A comprehensive guide to CRDTs and their tradeoffs, from counters to sequences. Written in the spirit of the Typeclassopedia, exploring how different CRDTs solve the distributed consensus puzzle.
  3. JSON Schema Demystified: Understanding Schemas, Dialects, Vocabularies, and Metaschemas stable An accessible guide to understanding the confusing terminology around JSON Schema. What are schemas, dialects, vocabularies, and metaschemas, and how do they all fit together?
  4. Event Design for Streaming Systems: A Primer stable How to use event streams in an effective, scalable, future-proof way.
  5. Accidental or Essential? Understanding Complexity in Software Design stable Understanding the difference between essential and accidental complexity in software design.

2024

  1. Embracing Flexibility in Haskell Libraries: The Power of Records of Functions stable Improve the robustness and flexibility of your Haskell apps by changing how you design your libraries.
  2. Hi, Barbie! Higher kinded records made easy(er) stable We often need to make and manipulate derived types that are similar to each other, but not quite the same. Higher-kinded records provide a way to do this in a generic way, but are clunky. We’…

2023

  1. Haskell Best Practices– Wildcards aren’… stable An argument for using really exhaustive pattern matching.
  2. There and Back Again: Turning Haskell functions into RPC calls- Part 2 stable In the last post, we figured out an interface for the RPC caller to invoke remote Haskell functions. In this post, we’…
  3. There and Back Again: Turning Haskell functions into RPC calls- Part 1 stable In
  4. Integrating a large Tokio-based Rust library with Haskell stable A lot of the Rust <-> Haskell interop examples out there are for small, synchronous libraries. They also tend to omit how to actually package the Rust library. We’…
  5. One Serialization Class to Rule Them All stable Typical serialization libraries in the Haskell ecosystem target a single format. We explore how to provide composite serialization for data types that chooses the best format for each data type.
  6. OpenTelemetry Gotchas– Phantom Spans stable We struggled for several months with a mysterious tracing issue in our production environment. Unrelated web requests were being linked together in the same trace, but we could never see the root trace span. This is the story of how we found and fixed root cause.

2014

  1. Using React with GHCJS stable Early explorations in data-driven Haskell applications in the browser.
  2. Introducing Growler, a simple HTTP server toolkit stable Sinatra-esque Haskell web apps.
A 1602 engraving of Simon Stevin’s wind-powered sailing chariot racing along a beach.
SpecimenEngineering

Reliable, debuggable, maintainable.

  • sail0.95
  • wheel0.98
  • flag0.83
  • wind0.07