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

Overview

Ken Thompson co-created Unix, the C language, UTF-8, and Go. His approach to software is legendary: build small, sharp tools that do one thing well and compose together. The Unix philosophy is his philosophy.

Core Philosophy

"One of my most productive days was throwing away 1,000 lines of code."

"When in doubt, use brute force."

"I'd rather write programs to write programs than write programs."

Thompson believes in minimalism and pragmatism. Build the simplest thing that works, make it work well, and compose larger systems from small pieces.

Design Principles

Do One Thing Well: Each program, function, or module has one job.

Compose Small Programs: Build complex behavior from simple pieces.

Text Streams as Interface: Universal, simple, debuggable.

Brute Force When Appropriate: Don't over-engineer; simple algorithms often win.

When Writing Code

Always

• Make each function do exactly one thing

• Use simple data formats (text, JSON)

• Write programs that can be composed via stdin/stdout

• Start with the simplest solution that could work

• Measure before optimizing

• Make tools that are easy to script

Never

• Build monoliths when pipelines work

• Use complex formats when text suffices

• Optimize without profiling

• Add features "just in case"

• Create interactive tools when batch works

Prefer

• Line-oriented text formats

• Streaming over loading everything into memory

• io.Reader /io.Writer for data flow

• Flags over config files for simple tools

• Exit codes for scripting

Code Patterns

Programs as Filters

// Unix philosophy: read stdin, write stdout func main() { scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { line := scanner.Text() // Transform result := process(line) fmt.Println(result) } if err := scanner.Err(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } }

// Composable: cat file | myprogram | sort | uniq

Do One Thing Well

// BAD: Swiss army knife func ProcessData(data []byte, format string, compress bool, encrypt bool, output string) error { // 200 lines handling all combinations... }

// GOOD: Separate tools func Compress(r io.Reader, w io.Writer) error { ... } func Encrypt(r io.Reader, w io.Writer, key []byte) error { ... } func Format(r io.Reader, w io.Writer, fmt string) error { ... }

// Compose: // cat data | compress | encrypt | format > output

Simple Data Flow with io.Reader/Writer

// Everything flows through Reader/Writer func CountWords(r io.Reader) (int, error) { scanner := bufio.NewScanner(r) scanner.Split(bufio.ScanWords) count := 0 for scanner.Scan() { count++ } return count, scanner.Err() }

// Works with files f, _ := os.Open("file.txt") n, _ := CountWords(f)

// Works with strings n, _ := CountWords(strings.NewReader("hello world"))

// Works with HTTP responses resp, _ := http.Get(url) n, _ := CountWords(resp.Body)

// Works with compressed data gz, _ := gzip.NewReader(f) n, _ := CountWords(gz)

Brute Force First

// BAD: Premature optimization func FindDuplicates(items []string) []string { // Complex trie-based algorithm with O(n) complexity // 150 lines of code... }

// GOOD: Simple and clear (Thompson's way) func FindDuplicates(items []string) []string { seen := make(map[string]bool) var dups []string for _, item := range items { if seen[item] { dups = append(dups, item) } seen[item] = true } return dups } // Profile first. Optimize only if this is actually slow.

Command-Line Tools

package main

import ( "flag" "fmt" "os" )

func main() { // Simple flags, not complex config n := flag.Int("n", 10, "number of lines") flag.Parse()

// Read files from args, or stdin
args := flag.Args()
if len(args) == 0 {
    process(os.Stdin, *n)
} else {
    for _, filename := range args {
        f, err := os.Open(filename)
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            continue
        }
        process(f, *n)
        f.Close()
    }
}

}

// Exit codes matter for scripting // 0 = success // 1 = general error // 2 = usage error

Text as Universal Interface

// BAD: Custom binary format type Record struct { // Complex serialization... }

// GOOD: Line-oriented text (like /etc/passwd) // name:age:email:role func ParseRecord(line string) (*Record, error) { parts := strings.Split(line, ":") if len(parts) != 4 { return nil, fmt.Errorf("invalid record: %s", line) } age, err := strconv.Atoi(parts[1]) if err != nil { return nil, err } return &Record{ Name: parts[0], Age: age, Email: parts[2], Role: parts[3], }, nil }

// Debuggable: you can cat the file // Composable: grep, awk, sed all work // Universal: every language can parse it

Mental Model

Thompson asks:

• Can this be simpler? Usually yes.

• Can this be a filter? stdin → stdout

• Does this do one thing? Split it if not.

• Will brute force work? Start there.

The Unix Way in Go

Unix Tool Go Equivalent

cat

io.Copy(os.Stdout, file)

head

bufio.Scanner

• counter

grep

strings.Contains / regexp

wc

bufio.Scanner with splits

sort

sort.Strings

uniq

map for dedup

tee

io.MultiWriter