Tantaman

Start Here

New here? This guide organizes a decade of posts into thematic paths. Pick what interests you, or wander.

If You Write Code

First Principles

Start with the foundations—patterns that recur across languages and decades:

  1. The Almighty Function - Objects are closures, closures are objects, everything is functions
  2. Inheritance, Aggregation, and Pipelines - Why pipelines beat inheritance for extensibility
  3. Practical Laziness - Lazy evaluation isn't academic—it improves API design
  4. Oh Lisp - Why Lisp matters: code as data, minimal syntax, domain languages

Types and Abstraction

On using type systems to think better:

  1. These Are Not Types - int and string are storage types, not application types
  2. Understanding Generics - Generics are for the caller, not the callee
  3. Typed Literals ARE Constants - When types make constants redundant

React & State

Wrestling with state management in modern frontends:

  1. React Anemic Models - The problem with property bags
  2. Missing Mutation Primitives - Mutation isn't bad; untracked mutation is
  3. Reference Equality - What is it Really? - Nominal vs physical identity
  4. Deeply Nested Updates - Why React re-renders too much
  5. URLs as Display Data - Invert the router

Minimalism in Practice

Proving you need less than you think:

  1. The Shortest TODO App - ~200 lines, zero dependencies
  2. Skipping the Bundling - ES6 modules make bundlers optional
  3. Simple MDX - MDX without the complexity

If You Build Distributed Systems

Local-First Architecture

The case for flipping client-server on its head:

  1. Why SQLite? Why Now? - The manifesto for local-first
  2. Meta's Graph Model - How constraining SQL enabled scaling to billions
  3. Large Local Storage - A 2013 solution to browser storage fragmentation

Clocks and Consistency

Understanding time in distributed systems:

  1. Lamport Clock - The simplest logical clock, explained
  2. Do LWW Registers Need Vector Clocks? - When simpler is enough

Query Systems

Building query layers from scratch:

  1. Query Builder - Linked lists of expressions
  2. Query Planning - Converting builders to executable plans
  3. Chunk Iterable - Streaming results in digestible pieces

Infrastructure

Understanding the full stack:

  1. Pi Cloud - Building cloud infrastructure from Raspberry Pis
  2. Observability Driven Development - If it's not monitored, it's not done
  3. Services and Coupling - Why dependency injection isn't enough

If You Think About Thinking

Epistemology and Statistics

How to reason under uncertainty:

  1. Understanding False Positive Rate - Base rates matter more than you think
  2. Regression to the Mean vs Gambler's Fallacy - They don't contradict
  3. Volatility Isn't Risk - Finance's biggest lie

Language and Identity

How words shape what we can think:

  1. I Am, You Are - You aren't angry, you're experiencing anger
  2. Non-Conceptual Definitions - Some words are defined by examples, not principles
  3. Filter, Map vs For Each - Programming is upleveling language

Philosophy

On ideas, danger, and limits:

  1. Dangerous Ideas - Ideas need frameworks like power tools need safety protocols
  2. All Things Are Permitted - Laws curb what nature permits
  3. Mathematical Government - Math cannot confer value
  4. You'll Always Have a Body - Even uploaded consciousness has constraints

If You Wonder About Society

Foundational Myths

How stories shape civilizations:

  1. Monotheism to Now - The cognitive style we inherited from one God
  2. Foundational Myths / 1619 Project - Memes as civilizational operating systems
  3. What If Religion Is Last? - Religion as culmination, not precursor
  4. Doing For Others - The present shapes the future, not itself

The Big Picture

State of the Union - A synthesis of everything here, written looking back over a decade.

Vision - What I'm building toward: software to help people think deeply, local-first architectures, docs as development platforms.

Fiction

The Mirror Room - A collection of short stories exploring identity, consistency, and becoming.

Still lost? The throughline is this: understanding is liberation. Whether it's understanding why Lamport clocks work, how base rates affect test results, or how monotheism shaped our appetite for singular explanations—deep understanding leads to better choices.