Rob Pike shares thoughtful essays and talks on software engineering, Go’s evolution, and the dangers of complexity, reflecting on what the Go project got right, what it got wrong, and how to build better software systems.
18 articles from this blog
Explores the mathematical and implementation challenges of adding high-precision transcendental functions (sine, cosine) to the Ivy programming language.
A closing talk from GopherConAU reflecting on 14 years of the Go programming language, discussing its successes and lessons learned.
A Google engineer's 2009 talk on the importance of simplicity in software design, contrasting Google's simple homepage with its complex internal systems.
A personal perspective on red-green color blindness (deuteranopia), explaining how it actually works and its impact on interpreting digital charts.
A historical look at a quirky C code snippet from 1992 using smiley face typedefs, shared from the author's Google+ archive.
A personal account of the creation of UTF-8, the dominant character encoding for the web, by one of its co-inventors.
Answers and historical context for a 1984 Unix/mpx exit quiz, covering early Unix trivia, commands, and Bell Labs lore.
A challenging Unix trivia quiz with historical context, originally used to control program exit and later featured at a USENIX conference.
Discusses the challenges of computational reproducibility in science, highlighting the Ten Years Reproducibility Challenge and using Go's stability as a model.
A 1984 trip report detailing technical observations and critiques of Xerox PARC's computing environment, including machine allocation and disk usage.
A 1973 CERN memo reveals programmable control knobs for a particle accelerator, predating and inspiring Apple's iPod click wheel.
Explores the design and use of a custom error handling package in the Upspin project, with lessons for Go programming.
A manifesto proposing Upspin, a global file system to restore user data ownership and enable seamless sharing between programs and people.
A retrospective on the 10-year history of the Go programming language, from its initial design discussions at Google to its open-source launch and key contributors.
Explores a Go design pattern using self-referential functions to create a clean, extensible API for setting and managing options on a type.
Rob Pike discusses the design philosophy behind Go, explaining why it attracted Python/Ruby developers more than C++ programmers.
Explains why checking native byte order in code is usually wrong and demonstrates portable, endianness-agnostic data extraction techniques.
A critique of modern programmers' tendency to complain about new languages and tools rather than engaging with them, using Go and Dart as examples.
