Visual summary of operating lessons from Hillel Wayne.

Lessons from Hillel Wayne

Hillel Wayne writes and teaches about formal specification for working programmers. His Crossover Project interviewed people who had worked in both software and traditional engineering, comparing the fields' constraints and practices. This profile reviews his lessons on modeling, testing, tooling and engineering judgment. — Are We Really Engineers?.

Part 1: Formal Methods and TLA+

  1. Debugging versus specification: Model a system before implementation to expose some design bugs while they are still cheap to change; Wayne demonstrates this with a small credit-transfer specification. — The Business Case for Formal Methods.
  2. The purpose of TLA+: A short, high-level specification can clarify intended behavior and reveal subtle design errors. It complements code tests rather than replacing them. — Using Formal Methods at Work.
  3. Finding unseen design bugs: Model checking explores behaviors within the assumptions and bounds of a specification, including interactions that ordinary examples may miss. It does not prove the real implementation is bug-free. — Using Formal Methods at Work.
  4. PlusCal as a gateway: Wayne uses PlusCal, a sequential-algorithm language that compiles to TLA+, when modeling a Go deadlock because it matches the example's process flow and is easier for outsiders to follow. — Finding Goroutine Bugs with TLA+.
  5. The flossing analogy: Wayne compares software-correctness practices to flossing: the future cost of failure can be obvious while the routine tool remains too awkward to use consistently. — Software Correctness Is a Lot Like Flossing.
  6. Pedagogy and usability: Wayne argues that teaching and interface design are part of making correctness tools usable in everyday work, rather than treating low adoption as simple apathy. — Software Correctness Is a Lot Like Flossing.
  7. Beyond safety-critical systems: Wayne presents partial formal specifications as useful for ordinary business and infrastructure systems, not only highly regulated or safety-critical projects. — Using Formal Methods at Work.
  8. Alloy for structural models: Wayne distinguishes Alloy's strength in relational and structural modeling from TLA+'s focus on behavior over time; he uses Alloy to specify a package manager. — Formally Specifying a Package Manager.
  9. Focused planning: Wayne recommends focused, partial modeling when it helps clarify requirements or risky behavior; he does not prescribe exhaustive upfront specification for every project. — Using Formal Methods at Work.

Part 2: The Crossover Project: Software vs. Traditional Engineering

  1. Software is not uniquely unpredictable: Wayne cautions that software is not uniquely unpredictable; his crossover interviews found surprises and iterative work in traditional engineering too. — We Are Not Special.
  2. Is software real engineering?: In Wayne's selected group of 17 people who had worked in both fields, 15 said software engineering counts as engineering. The finding describes those interviewees, not all traditional engineers. — Are We Really Engineers?.
  3. Shared messiness: The crossover interviews challenge the picture of traditional engineering as perfectly predictable or linear: participants described iteration, uncertainty and practical compromises. — We Are Not Special.
  4. Chemical engineering analogy: Wayne uses chemical engineering, which developed through experimentation and iteration, to question definitions that would exclude newer software work from engineering. — Are We Really Engineers?.
  5. The electrician analogy: Wayne distinguishes software development from software engineering, but says the gap between them is smaller and easier to cross than the gap between an electrician and an electrical engineer. — Are We Really Engineers?.
  6. The rigor myth: The crossover interviews complicate the claim that traditional engineering is uniformly more rigorous: its practitioners also face tradeoffs, deadlines and imperfect processes. — We Are Not Special.
  7. Flexible upfront planning: Wayne suggests software teams can learn from traditional engineering's requirements work and upfront thought while preserving software's ability to iterate quickly. — What Engineering Can Teach (and Learn from) Us.
  8. Version control: Wayne identifies version control as a software practice that traditional engineering could learn from, while presenting its comparative value as his judgment rather than a measured ranking. — What Engineering Can Teach (and Learn from) Us.
  9. Open communities: The crossover interviews highlight software's open communities and shared learning as strengths that other engineering fields could adapt. — What Engineering Can Teach (and Learn from) Us.
  10. Engineering under constraints: Wayne argues that both software and traditional engineering solve problems under constraints, even though their materials, iteration speeds and kinds of constraints differ. — We Are Not Special.

Part 3: Empirical Software Engineering and Research

  1. Software beliefs: Wayne argues that many software practices rest on experience and opinion rather than strong empirical evidence, and that research can help distinguish what works from what merely feels right. — What We Know We Don't Know.
  2. Read the primary research: Read the primary research before endorsing or attacking a technical claim; each retelling can lose context that changes its meaning. — Please Read the Paper Before You Comment.
  3. Question software orthodoxy: Wayne urges developers to test conventional wisdom against empirical studies and to examine how those studies were designed before treating their conclusions as rules. — What We Know We Don't Know.
  4. Primary sources: Wayne warns that claims become less reliable as they pass from an original paper through press releases, posts and reactions; reading the original preserves critical context. — Please Read the Paper Before You Comment.
  5. Language-quality research: Wayne's account of one programming-language defect study shows why classification errors, noisy repository data and failed replication can undermine confident language-quality claims. It does not show that language never matters. — This Is How Science Happens.
  6. Human factors: Wayne says the evidence for social and human factors such as sleep and psychological safety is stronger than the evidence for a large programming-language effect, while acknowledging that language may still matter. — This Is How Science Happens.
  7. Difficulty of software research: Empirical software research is difficult because projects, teams, tooling and measurement methods vary, but Wayne argues the field is still studyable and worth studying. — This Is How Science Happens.
  8. Misquoting Knuth: Wayne points out that the common short form of Knuth's premature-optimization saying omits the qualifiers about small efficiencies and 97 percent of the time, changing the practical lesson. — Please Read the Paper Before You Comment.
  9. Research disputes: Wayne's account of a disputed language-quality paper shows how replication, rebuttal, data access and professional incentives shape software research—and why a single headline should not settle a technical debate. — This Is How Science Happens.

Part 4: Software Design and Architecture

  1. Explain necessary complexity: When a complex design is justified, document why simpler alternatives do not meet the requirements so future maintainers can evaluate the tradeoff. — Write the Most Clever Code You Possibly Can.
  2. Investigate inherited constraints: Before simplifying an old system, investigate the history and constraints behind its current shape; apparent oddities may reflect earlier requirements. — There’s Always More History.
  3. Model selected behavior: A formal specification can model selected system behaviors at a high level before code exists, exposing some design errors without pretending to describe the entire implementation. — Using Formal Methods at Work.
  4. Design and implementation checks: Wayne distinguishes design mistakes from implementation mistakes: a specification can test a proposed design while code tests remain necessary to check the implementation. — Using Formal Methods at Work.
  5. Compose state-machine specifications: Wayne demonstrates one advanced way to compose TLA+ specifications from state-machine components, while warning that the technique is not a general starting point for beginners. — Composing TLA+ Specifications with State Machines.
  6. Use models to expose assumptions: A small model can make hidden assumptions and edge cases visible before implementation, particularly where several parts of a system interact. — Using Formal Methods at Work.

Part 5: Logic for Programmers

  1. Logic for working programmers: Wayne argues that formal logic has practical uses in everyday programming and wrote his book to make those applications accessible to working developers. — Logic for Programmers Launch.
  2. Simplify conditions: The official book shows how elementary logic can simplify conditional code and help reason about database-related problems. — Logic for Programmers.
  3. Specify test properties: Property-based testing is one practical application of logical reasoning: expressing a behavior that should hold across many generated inputs. — Property Tests + Contracts = Integration Tests.
  4. Model missing requirements: Formalizing requirements can reveal cases and assumptions that informal prose leaves unspecified. — Modeling Missing Requirements.
  5. Reason about API changes: Wayne presents logic as a way to reason about whether API changes might break clients, within the assumptions of the model. — Logic for Programmers.
  6. Use decision tables: Decision tables provide a relatively approachable way to enumerate interacting conditions and check behavior before changing code. — Decision Tables.
  7. Model probabilistic behavior: Wayne uses PRISM to explore probabilistic system behavior; such models can express questions about outcomes and averages that deterministic models cannot. — Probabilistic Modeling with PRISM.
  8. Bridge logic and practice: Wayne says programmer-focused resources for applying formal logic were scarce, motivating a book organized around software examples rather than abstract proofs alone. — Logic for Programmers Launch.

Part 6: Friction, Testing, and Tooling

  1. Compounding friction: Small sources of friction can combine into a disproportionately unpleasant user experience; removing only one obstacle may not make a tool feel easy to use. — Software Friction.
  2. Anticipate friction limits: Wayne argues that some friction is inevitable and difficult to foresee fully, so tool designers need to observe how people actually use their systems. — Software Friction.
  3. Fuzzy integration-test labels: Wayne argues that the term “integration test” has fuzzy boundaries; the label by itself says little about what behavior the test exercises. — “Integration Tests” Are Just Vibes.
  4. Test component interactions: A useful test strategy needs to consider interactions between components, not rely solely on an imprecise unit-versus-integration label. — Just a Whole Bunch of Different Tests.
  5. Pragmatic formal-methods use: Wayne advocates using small, partial formal models where they can clarify a risky design; the practice need not require formalizing an entire product. — Using Formal Methods at Work.
  6. Check domain assumptions: A seemingly simple recipe data model can fail on real-world edge cases; Wayne uses that example to show why domain assumptions deserve explicit testing. — Edge Case Poisoning.

Part 7: The Realities of AI and Industry Hype

  1. Skepticism of AI hype: In a LinkedIn post, Wayne expresses frustration with sweeping AI predictions from people with limited software-engineering experience; this is his opinion, not an empirical age effect. — Hillel Wayne on LinkedIn.
  2. Experience and prediction: Wayne argues that a few years of professional experience are not enough to make confident, sweeping claims about AI destroying software engineering. — Hillel Wayne on LinkedIn.
  3. Hard parts of maintenance: Legacy constraints and changing requirements make software work more complicated than a clean-room example suggests; Wayne does not use this source to measure AI performance on those tasks. — Reject Simplicity, Embrace Complexity.
  4. No single silver bullet: No one language, test, method or tool guarantees correctness; Wayne argues for choosing practices in light of the problem instead of treating one technique as sufficient. — Uncle Bob and Silver Bullets.
  5. Evaluate practices on their merits: Wayne cautions against treating a fashionable programming practice as a universal rule; its value depends on the specific system and tradeoffs. — Uncle Bob and Silver Bullets.
  6. Learn from other engineering fields: Wayne's Crossover Project argues that software is not uniquely messy; comparing fields can reveal practices software engineers might adapt while also showing what other engineers could borrow from software. — What Engineering Can Teach (and Learn from) Us.

Part 8: Communication, Writing, and History

  1. Clarify the actual decision: When documenting a complex solution, write down why it was chosen over simpler alternatives; that explanation makes later review more useful than an unexplained implementation. — Write the Most Clever Code You Possibly Can.
  2. Study software's history: Wayne urges programmers to look beyond the familiar short history of current tools: earlier work often explains why a practice or problem exists. — There’s Always More History.
  3. Make assumptions explicit: Writing a machine-checkable specification forces some system assumptions and intended behaviors into a form precise enough to inspect and challenge. — Using Formal Methods at Work.
  4. Restore primary-source nuance: Wayne shows how claims can lose important qualifications when repeated secondhand; read the original paper or argument before treating a compressed summary as authoritative. — Please Read the Paper Before You Comment.
  5. Teach beyond reference lookup: Wayne argues that some technical subjects need sequential explanations and conceptual teaching, not only reference pages organized for random access. — My Problem With the Four-Document Model.