Author: Rob Pike (Newsqueak, Limbo, Go)

Pike is the closest living analogue to Mo’s programme: a deliberately small language justified by engineering rather than research, with machine formatting, compile-time strictness, and a CSP-derived concurrency model. Go’s public reversals also make him the best source on the cost of omissions.

Ethos in his own words

“The answer can be summarized like this: Do you think less is more, or less is less?” (Less is exponentially more, 2012)

“And yet, with that long list of simplifications and missing pieces, Go is, I believe, more expressive than C or C++. Less can be more.” (Less is exponentially more)

“Type hierarchies are just taxonomy.” (Less is exponentially more)

“Go’s purpose is therefore not to do research into programming language design; it is to improve the working environment for its designers and their coworkers.” (Go at Google, 2012)

“Dependency hygiene trumps code reuse.” (Go at Google)

“Features add complexity. We want simplicity.” (Simplicity is Complicated, 2015)

“Gofmt’s style is no one’s favorite, yet gofmt is everyone’s favorite.” (Go Proverbs)

“Clear is better than clever.” (Go Proverbs)

Defining decisions

One formatter, no options. “From the beginning of the project, we intended Go programs to be formatted by machine, eliminating an entire class of argument between programmers: how do I lay out my code?” (Go at Google) The no-options rule, from the Go team: “It is an intentional design choice that there are no configuration options for gofmt.” (golang/go issue 40028) The dividend was mechanical refactoring: “The program works by parsing the source code and reformatting it from the parse tree itself. This makes it possible to edit the parse tree before formatting it, so a suite of automatic refactoring tools sprang up,” including a whole-tree rewrite via “gofmt -r ‘a[b:len(a)] -> a[b:]’” (Go at Google).

Unused dependencies are errors. “The first step to making Go scale, dependency-wise, is that the language defines that unused dependencies are a compile-time error (not a warning, an error).” (Go at Google) The motivating measurement: C++ headers expanding to “over 8 gigabytes” at the compiler input (Go at Google).

No generics, then generics. Pike in 2012: “Early in the rollout of Go I was told by someone that he could not imagine working in a language without generic types. As I have reported elsewhere, I found that an odd remark.” (Less is exponentially more) Go in 2019: “In three years of Go surveys, lack of generics has always been listed as one of the top three problems to fix in the language,” constrained by “they are only worth doing if Go still feels like Go.” (Why Generics?)

Errors as values, question then closed. “Explicit error checking forces the programmer to think about errors—and deal with them—when they arise.” (Go at Google) In 2025: “For the foreseeable future, the Go team will stop pursuing syntactic language changes for error handling,” while admitting “Lack of better error handling support remains the top complaint in our user surveys.” (go.dev blog)

Concurrency as composition. “In programming, concurrency is the composition of independently executing processes, while parallelism is the simultaneous execution of (possibly related) computations.” (Concurrency is not parallelism) The limit he accepted: “Go enables simple, safe concurrent programming but does not forbid bad programming.” (Go at Google)

Where he contradicts Mo

Mo forbids where Go discourages. Pike also distrusts type-driven design: “I am not a fan of type-driven programming, type hierarchies and classes and inheritance.” (Evrone interview) And Go’s 2025 note defends print-style debugging — “being able to quickly add a println or have a dedicated line or source location for setting a breakpoint in a debugger is helpful” (go.dev blog) — against Mo’s no-log-statements law. Judgment: the generics reversal is the strongest available evidence against Mo’s confidence in its own omissions.

What Mo could take

ideamaps tostatus
Canonical formatting is what makes mechanical and agent edits safed29-edit-by-declaration-idalready in Mo
A gofmt-style rewrite flag so laws are enforced by rewriting, not only rejectingq09-compiler-diagnosticsnew idea for Mo
Unused dependency is an error, as the rule that buys compile speedd23-compile-speed-first-classalready in Mo
Publish the omissions and the evidence that would reverse themd28-nothing-final-until-measuredstrengthens Mo
Verbose error handling defended on debuggability groundsd18-two-kinds-of-failurestrengthens Mo