mujun.dev

A developer's journal of paradox and contradiction

I. Self-Reference

This sentence is false. The statement that negates itself — the simplest and most devastating logical paradox. In code, we encounter it as the function that calls itself without termination, the variable that references its own assignment, the program that determines whether it will halt.

A developer's craft is built upon self-referential structures. Every recursive function embodies the paradox: to understand the whole, you must understand the part, which is the whole.

function thisStatementIsFalse() {
  return !thisStatementIsFalse();
}
// The liar's paradox, compiled.

II. Infinite Regress

To justify a belief, you need another belief. To justify that belief, you need yet another. The chain never ends, the stack never returns. Developers know this as the infinite loop — the while(true) that never breaks, the promise that never resolves.

Yet somehow we build working systems atop infinite regress. We choose a base case, an axiom, a convention — and we call it "good enough." The contradiction is that certainty rests on an arbitrary decision to stop questioning.

function justify(belief) {
  const foundation = justify(belief.basis);
  return foundation;
  // RangeError: Maximum call stack exceeded
}

III. Impossible Objects

The Penrose triangle exists perfectly on paper but can never exist in three dimensions. A Klein bottle has no inside or outside. A Mobius strip has only one surface. These objects are logically consistent in their description yet physically impossible — they are the paradox made tangible.

In software, we build impossible objects daily. An immutable object that changes. A stateless service with memory. A deterministic random number generator. We name these contradictions "abstractions" and build empires upon them.

class KleinBottle {
  constructor() {
    this.inside = this.outside;
    this.outside = this.inside;
  }
  // Where does the coffee go?
}

IV. Recursion

To understand recursion, you must first understand recursion. The joke is also the truth. Every recursive function is an act of faith — we trust that the base case exists, that the stack will not overflow, that the problem truly decomposes into smaller versions of itself.

The beauty of recursion is that it mirrors the structure of paradox itself: a thing defined in terms of itself, meaningful only because we agree to stop unwinding at some arbitrary depth. Development, like consciousness, is a recursive process pretending to be linear.

function understand(recursion) {
  if (recursion === "understood") return;
  return understand(recursion);
  // see: understand(recursion)
}

Colophon

This journal is a contradiction: a digital artifact styled as an analog one, exploring logical impossibilities through the very logic that makes them impossible. It was written in code that could never fully describe the paradoxes it presents.

Set in Vollkorn and Fira Code. Bound in CSS leather. Stitched with border-style: dashed.