Grady Booch is a legendary software engineer who built his first computer at age 12, co-created UML, originated object-oriented analysis and design (the Booch method), and has spent decades working across nearly every domain of software-intensive systems. He is an IBM Fellow and ACM Fellow, and in this conversation he traces the evolution of software engineering through its “golden ages,” explains why UML declined, shares candid views on LLMs and AGI, and reflects on what it means to be a software architect in an era of rising abstraction.
What it means to be an IBM Fellow
IBM Fellow is a rare distinction — roughly 89 active Fellows out of about 350 in IBM’s history — granting researchers freedom to pursue long-term, high-impact work without quarterly business pressures.
Booch was made a Fellow immediately upon IBM’s acquisition of Rational Software in 2003, an unusual honor that reflected his decades of contributions.
Legacy systems and the domains Grady has worked in
Booch defines legacy code broadly: the moment you write a line of code, it becomes legacy until you throw it away.
He has worked across defense, finance, real-time systems (pacemakers, subway systems, CT scans), government (the IRS, which still runs IBM 360 Assembly Language on emulators), and space systems (James Webb Space Telescope uses UML in its design).
Modern computing was “woven on a loom of sorrow” — born from WWII and Cold War defense projects like SAGE (Semi-Automatic Ground Environment), which drove early software engineering challenges and triggered the NATO conference that coined the term “software engineering.”
The two golden ages of software engineering
First golden age (1960s–1970s): Dominated by algorithmic languages (Fortran, COBOL, APL, Lisp). Systems were largely monolithic, and the key challenge was algorithmic complexity. Structured analysis and design techniques (Yourdon, DeMarco, Constantine) emerged to manage this.
Second golden age (late 1980s–1990s): Driven by the rise of distributed systems (ARPANET, early client-server), real-time systems, and new languages influenced by Simula and Smalltalk. The challenge shifted from algorithms to systems engineering — how to decompose systems into classes and objects across distributed, heterogeneous environments.
The Department of Defense’s creation of Ada was a pivotal moment: a language far ahead of its time, incorporating abstract data types, information hiding, and ideas from Parnisk, Liskov, and others that are now taken for granted.
The Booch method
The Booch method was a response to the limitations of algorithmic decomposition. Instead of decomposing systems by processes, it decomposed them by classes and objects — combining data and behavior into single abstractions.
It was influenced by abstract data type theory, Plato’s philosophical debate about atoms versus processes, and the work of Liskov, Parnisk, Dijkstra, and Hoare.
Booch acknowledges the method overemphasized inheritance as a code-reuse mechanism, which led to awkward abstractions. But the core idea — class-based decomposition — became foundational and is now embedded in frameworks and tools people use without thinking about it.
The method also hinted at viewing systems through multiple points of view, an idea that later became central to UML and the Rational Unified Process.
The creation of Rational Software and UML
In 1982, Booch co-founded Rational Machines with Paul Levy and Mike Devlin to build development environments for Ada. Their R1000 system became the dominant Ada environment worldwide.
In the mid-1990s, Rational pivoted to the commercial sector with ROSE (Rational Object-Oriented Software Engineering), a design tool that let developers draw Booch diagrams to reason about system designs.
Rational grew by acquiring companies across the software development lifecycle, including Pure Atria (led by Reed Hastings, who later founded Netflix with the proceeds).
In the late 1990s, Rational hired James Rumbaugh and acquired Ivar Jacobson’s company, bringing together three leading object-oriented methodologies (Booch, OMT, and Jacobson’s use cases).
The three collaborated to create UML (Unified Modeling Language), released as UML 1.0 through the Object Management Group. Philippe Kruchten contributed the “4+1 view model” (logical, process, implementation, deployment, and use case views), which became an IEEE/IEC standard for architectural description.
Booch was the primary author of the UML 1.0 specification and considers it one of his proudest achievements.
Why UML declined
Booch intended UML as a visual language for reasoning about, visualizing, specifying, and documenting software-intensive systems — explicitly not a programming language.
In the transition from UML 1.0 to 2.0, a faction pushed to make UML more precise and turn it into a programming language for code generation and reverse engineering. Booch considers this a “profound mistake” that made UML much more complex and led to its misuse.
UML peaked at roughly 20–30% market penetration around 2000, with Microsoft even integrating Rational’s tools into Visual Studio.
Today, UML is still used in domains with high ceremony, risk, and complexity (defense, aerospace, finance) but has largely disappeared from startups and mainstream commercial development.
Why software architecture has changed
The entire history of software engineering is one of rising levels of abstraction. Today’s developers stand on extraordinarily powerful frameworks where many architectural decisions have already been made.
Booch describes a three-dimensional space for understanding when formal architecture matters:
Ceremony: Startups with disposable software need little; defense systems with billions at stake need much more.
Risk: Systems where failure means someone dies demand more disciplined architecture.
Complexity: Well-understood problems (e.g., CRUD apps) don’t need UML; novel problems (e.g., constellations of LLMs working with non-neural systems) do.
The economics have shifted dramatically: computational resources are now cheap and abundant, unlike the 1960s when machine time was expensive and required careful upfront optimization.
Companies like Amazon and Microsoft have codified architectural patterns for common system types, reducing the need for ground-up architectural thinking for many use cases.
The role of the architect has evolved from making software-specific decisions to making systemic decisions involving cloud services, messaging platforms, and economic tradeoffs — what Booch calls “solutions architecture.”
Formal methods
Formal methods have always been niche, applicable to specific domains (e.g., hardware driver verification at Microsoft) but never driving architecture itself.
They deal with functionality but not real-world concerns like space and time, making them useful for parts of a system but insufficient as architectural drivers.
Booch notes that Amazon has recently applied formal methods to AWS S3 to catch edge cases that only appear at trillion-operation scale.
The software architect role
Booch was influenced by Mary Shaw’s foundational book on software architecture and by architectural thinking in civil engineering, shipbuilding, and aircraft design.
He defines architecture as “the set of significant design decisions that shape the form and function of a system, where significant is measured by cost of change.”
The architect’s role has shifted from shaping software to shaping systems — including hardware, humans, and economic constraints. The rise of “solutions architect” as a cloud-specific role reflects this evolution.
Why software migrations are so hard
Migrations will “plague us until the heat death of the cosmos” because technology continuously changes underneath economically viable software.
The core difficulty: “The code is the truth, but the code is not the whole truth.” Design decisions, rationale, naming conventions, and tradeoffs are rarely captured in code. The people who made those decisions may have left or died, leaving subsequent teams working in the dark.
Booch points to Linus Torvalds as an example of a “chief decider” who provides conceptual integrity to Linux. When such a person is gone, entropy and drift are inevitable.
Disruptive changes in software history
Booch identifies several seismic shifts comparable to LLMs:
The rise of distributed systems (late 1970s): The ability to network many computers fundamentally restructured how systems were built, requiring new thinking about messaging, RPC, shared memory, and failure handling. This was enabled by miniaturization driven by Department of Defense semiconductor investment.
The rise of GPUs: Originally built for gaming, GPUs turned out to use the same matrix multiplication mathematics as deep learning. Combined with abundant data and algorithms like backpropagation, this created the “perfect storm” for modern AI.
Booch does not consider LLMs as pervasively important as distributed systems, but sees them as part of a similar pattern of disruptive technological convergence.
Grady’s early AI work
Booch has been interested in AI since he was 12–14 years old. At IBM, he documented the architecture of Watson Jeopardy — which turned out to be a pipeline architecture combining statistical systems and knowledge engineering, not a neural network.
He led a study on cognitive systems for IBM and warned management about overhyping Watson’s capabilities — warnings that proved prescient when Watson later struggled commercially.
He worked with Hilton Hotels on a robotic concierge using Watson technology and with NASA’s Johnson Space Center on human-robotic interaction for Mars missions.
Around 2014, he designed a neurosymbolic architecture called SELF, combining Marvin Minsky’s Society of Mind, Rodney Brooks’s subsumption architectures, and Douglas Hofstadter’s strange loops. This was used for NASA’s Robonaut 2 and for oil rig robotics with Woodside Energy.
At its peak, 35 people worked on SELF. When IBM’s Watson division faced cuts, most of the team was let go, but Booch continued the work as a Fellow.
Grady’s views on LLMs and AGI
LLMs are “pretty freaking cool” but are “unreliable narrators” — or less politely, “stochastic parrots” that do not reason or understand.
They work by navigating a complex latent space trained on the internet corpus, enabled by the perfect storm of data, algorithms, and hardware.
Booch is a consistent critic of claims that scaling LLMs will lead to AGI. He and Gary Marcus argue we are hitting diminishing returns on scale and that the architecture is fundamentally wrong for achieving human-like intelligence.
He points out that artificial neurons are a “whisper of a shadow” of organic neurons. The human brain has cortical columns (tens of millions, seven layers deep in humans), entangled architectures involving the thalamus, hormonal messaging systems, and other complexities that LLMs do not capture.
LLMs are largely unimodal (text, static images) and sensory-sparse, whereas human intelligence evolved through embodiment — interacting with and acting in the physical world.
He believes AGI will require neurosymbolic architectures and embodied cognition, not simply larger language models.
A UML for AI
Booch has called for a standard way to visualize the architecture and activity of LLMs and neural networks — “a UML for AI.”
He has been providing architectural oversight for IBM’s LLM work and is experimenting with using UML-like diagrams to describe complex AI systems.
Following the public release of AlphaFold 3’s source code and weights, he plans to describe its architecture using UML as a case study.
Advice for early-career software engineers
Don’t be afraid: despite fears that AI tools will eliminate developer jobs, there will always be a need for people who make informed decisions. Software engineering continues to be a story of rising abstraction — today’s developers work at much higher levels than Booch did when he learned assembly language.
Learn as much as you can, but don’t get stuck in one domain. Find an emerging space and make a name for yourself.
Have fun: the tools and computational resources available to a single person today are extraordinary and cheap. You are limited largely by your imagination.
What’s next for Grady
He is writing a software architecture book — a handbook documenting the as-built architectures of real systems people use every day (Photoshop, Wikipedia, climate monitoring systems, and now AlphaFold 3) to expose readers to diverse architectural styles.
He is also working on a documentary and book called “Computing & The Human Experience,” examining the history of computing and what it means to be human — how computation has changed individuals, societies, nations, science, art, and religion.
He continues to live and work from Maui, Hawaii, studying neuroscience and the architecture of the organic brain to inform his approach to software architecture.
Rapid fire
First programming language: Fortran
Most recently committed code: his own project, SELF, in Python
How he recharges: lives in Maui — “I wake up, that’s enough”
Book recommendation: Mary Shaw’s Software Architecture — the foundational text on the subject
