λ

Abstract
Algorithm

where logic meets intention

An algorithm is a set of instructions for solving a problem. An abstract algorithm is the idea behind the instructions — the pattern that exists before code, before language, before computers.

Every piece of software ever written is an attempt to express an abstract algorithm in concrete terms. The code is the shadow on the cave wall. The algorithm is the fire.

We build systems that start from the algorithm, not the framework. Start from the what needs to happen, not the what's trendy on Hacker News.

// The Abstract Algorithm
function solve(problem) {
  const understood = understand(problem);    // most skip this
  const simplified = reduce(understood);      // most fear this
  const solution = build(simplified);         // most overcomplicate this
  return solution;                            // most never reach this
}

// Complexity: O(stubbornness)
// Space: O(coffee)
// Sacred numbers: 47, 73, 432, φ

Principles

01

Understand before you build

The most expensive line of code is the one that solves the wrong problem. Spend 80% of your time understanding. The building takes 20% and happens almost by itself.

02

Reduce before you add

Every abstraction layer is a tax on comprehension. Every dependency is a bet on someone else's priorities. Strip it down until only the essential remains.

03

Own your infrastructure

If your business runs on software you can't modify, you don't have a business. You have a subscription. There is a difference, and the bill comes due eventually.

04

Ship, then polish

Perfect is the enemy of deployed. A working system that serves real users today is worth more than an elegant architecture that ships next quarter.

05

The knuckledragger way

Present primitive. Get underestimated. Outthink them. The best code looks simple. The best systems look obvious. That's not because they're easy. It's because someone made them look that way.

Enter the Workshop