Ken Thompson Style Guide⁠‍⁠‌‌‌‌‍‌‌‌‌‍‌‌‌‍‌‌‌‍‌‍‌‌‌‌‍‌‍‌‌‌‌‌‌‍‌‌‌‍‌‌‌‌‌‌‌‍‌‌‌‍‌‌‌‌‌‌‍‌‌‌‌‍‌‌‌‌‍‌‌‌‌‌‍‌‌‍‌‌‌‌‌‌‍‌‌‌‍‌‌‌‌‍‌‍‌‌‌‌‍‌‌‍‌‌⁠‍⁠

Overview

Ken Thompson co-created Unix, contributed to C, designed UTF-8, created Plan 9, and co-designed Go. He is a Turing Award winner whose work spans five decades of profound influence. His hallmark is finding the simplest possible solution that actually works.

Core Philosophy

"When in doubt, use brute force."

"One of my most productive days was throwing away 1000 lines of code."

"I think the major good idea in Unix was its clean and simple interface: open, close, read, and write."

Thompson believes complexity is the enemy. The best code is the code you don't write. The best abstraction is the one that disappears.

Design Principles

Radical Simplicity: The simplest solution that works is the best.
Small Sharp Tools: Programs should do one thing excellently.
Composition: Combine simple tools to solve complex problems.
Brute Force Works: Don't be clever when simple is good enough.

When Writing Code

Always

Question every line of code—is it necessary?
Design for composition via simple interfaces
Use text as the universal interface
Throw away code that doesn't serve the goal
Prototype with brute force, optimize only if needed
Trust the tools you build

Never

Add features "just in case"
Optimize before measuring
Create complex abstractions for simple problems
Fear starting over
Conflate clever with good

Prefer

Simple linear algorithms over clever ones
Text streams over binary formats
Regular expressions for text processing
Iteration over recursion when simpler
Small programs over monolithic ones

Code Patterns

The Unix Filter Pattern

// A perfect Unix filter: read stdin, transform, write stdout
#include <stdio.h>
#include <ctype.h>

// uppercase: convert input to uppercase
int main(void) {
    int c;
    while ((c = getchar()) != EOF) {
        putchar(toupper(c));
    }
    return 0;
}

// Usage: cat file.txt | uppercase | sort | uniq
// Composition through pipes

Simple Interfaces

// The Unix file interface: elegant simplicity
// Everything is open/close/read/write

int fd = open("file.txt", O_RDONLY);
char buf[4096];
ssize_t n;

while ((n = read(fd, buf, sizeof(buf))) > 0) {
    write(STDOUT_FILENO, buf, n);
}

close(fd);

// This same interface works for:
// - Files
// - Pipes
// - Sockets
// - Devices
// - /proc entries

Brute Force First

// Problem: find if a pattern exists in text
// Thompson's approach: just search

// Simple, obvious, correct
int contains(const char *text, const char *pattern) {
    while (*text) {
        const char *t = text;
        const char *p = pattern;
        while (*p && *t == *p) {
            t++;
            p++;
        }
        if (*p == '\0') return 1;
        text++;
    }
    return 0;
}

// Don't reach for KMP or Boyer-Moore until you've
// measured and proven you need them.
// For most inputs, brute force is fast enough.

Minimal Data Structures

// Arrays and structs solve most problems
// Don't reach for complexity

typedef struct {
    char *key;
    char *value;
} Entry;

typedef struct {
    Entry *entries;
    int count;
    int capacity;
} Table;

// Linear search is fine for small tables
char *table_get(Table *t, const char *key) {
    for (int i = 0; i < t->count; i++) {
        if (strcmp(t->entries[i].key, key) == 0) {
            return t->entries[i].value;
        }
    }
    return NULL;
}

// Only add hash table when profiling proves you need it

UTF-8: Elegant Encoding

// UTF-8: Thompson and Pike's masterpiece
// Self-synchronizing, ASCII-compatible, variable-width

// Decode one UTF-8 codepoint
int utf8_decode(const char *s, int *codepoint) {
    unsigned char c = s[0];
    
    if (c < 0x80) {
        *codepoint = c;
        return 1;
    }
    if ((c & 0xE0) == 0xC0) {
        *codepoint = (c & 0x1F) << 6 | (s[1] & 0x3F);
        return 2;
    }
    if ((c & 0xF0) == 0xE0) {
        *codepoint = (c & 0x0F) << 12 | (s[1] & 0x3F) << 6 | (s[2] & 0x3F);
        return 3;
    }
    if ((c & 0xF8) == 0xF0) {
        *codepoint = (c & 0x07) << 18 | (s[1] & 0x3F) << 12 | 
                     (s[2] & 0x3F) << 6 | (s[3] & 0x3F);
        return 4;
    }
    return -1;  // Invalid
}

// Simple rules, profound implications

Go: Modern Thompson

// Go reflects Thompson's philosophy for modern systems

// Simple concurrency: goroutines and channels
func pipeline() {
    naturals := make(chan int)
    squares := make(chan int)

    // Generator
    go func() {
        for x := 0; ; x++ {
            naturals <- x
        }
    }()

    // Squarer
    go func() {
        for x := range naturals {
            squares <- x * x
        }
    }()

    // Consumer
    for i := 0; i < 10; i++ {
        fmt.Println(<-squares)
    }
}

// No inheritance, no generics (initially), no exceptions
// Just structs, interfaces, goroutines, channels
// Radical simplicity

Regular Expressions

// Thompson's NFA regex algorithm: elegant and efficient

// Match: reports whether regexp matches text
// Simplified from Thompson's original
int match(const char *regexp, const char *text) {
    if (regexp[0] == '^')
        return matchhere(regexp + 1, text);
    
    do {  // must look even if string is empty
        if (matchhere(regexp, text))
            return 1;
    } while (*text++ != '\0');
    
    return 0;
}

int matchhere(const char *regexp, const char *text) {
    if (regexp[0] == '\0')
        return 1;
    if (regexp[1] == '*')
        return matchstar(regexp[0], regexp + 2, text);
    if (regexp[0] == '$' && regexp[1] == '\0')
        return *text == '\0';
    if (*text != '\0' && (regexp[0] == '.' || regexp[0] == *text))
        return matchhere(regexp + 1, text + 1);
    return 0;
}

// ~30 lines for a working regex engine
// That's Thompson elegance

Mental Model

Thompson approaches problems by asking:

What's the simplest thing that could work? Start there
Can I throw away code? Less is more
Does this compose? Small pieces, loosely joined
Is brute force good enough? Usually yes
Would I want to maintain this? Simplicity endures

Signature Thompson Moves

Text streams as universal interface
Brute force before cleverness
Throwing away code
Small programs that compose
Regular expressions for text
Clean, minimal interfaces

thompson-elegant-systems