The Philosophy of Software Design – with John Ousterhout
The Philosophy of Software Design – with John OusterhoutStanford professor John Ousterhout explains why thoughtful software design matters more than ever as AI tools transform coding practices and developer workflows.
Stream the Latest EpisodeListen and watch now on YouTube, Spotify, and Apple. See the episode transcript at the top of this page, and a summary at the bottom. Brought to You By
— In This EpisodeHow will AI tools change software engineering? Tools like Cursor, Windsurf and Copilot are getting better at autocomplete, generating tests and documentation. But what is changing, when it comes to software design? Stanford professor John Ousterhout thinks not much. In fact, he believes that great software design is becoming even more important as AI tools become more capable in generating code. In this episode of The Pragmatic Engineer, John joins me to talk about why design still matters and how most teams struggle to get it right. We dive into his book A Philosophy of Software Design, unpack the difference between top-down and bottom-up approaches, and explore why some popular advice, like writing short methods or relying heavily on TDD, does not hold up, according to John. We also explore:
As a fun fact: when we recorded this podcast, John was busy contributing to the Linux kernel: adding support to the Homa Transport Protocol – a protocol invented by one of his PhD students. John wanted to make this protocol available more widely, and is putting in the work to do so. What a legend! (We previously covered how Linux is built and how to contribute to the Linux kernel)  TakeawaysTopics I found especially interesting in our conversation: 1. The explosion of AI coding could make software design more important than before. Currently, AI coding tools and agents are akin to “tactical tornadoes” that code fast, fix issues fast… while creating new issues and adding tech debt. John doesn’t see the current tools being able to replace high-level design. And so software design could be more important than before – thanks to more code being written than before! 2. Software design is a decomposition problem. How do you take a large system and divide it into smaller units that you can implement relatively independently? John believes that the most important idea for all of computer science is just this – decomposition. If you can break up complicated problems into smaller parts: you can solve so many problems! 3. Test Driven Development (TDD) works against good software design. John firmly believes that TDD is counter-productive because it forces thinking about the small details before thinking about the high-level design. This observation could explain why TDD has not gained much traction in the last decade or so! John sees some value in TDD in specific cases. Most commonly: when fixing a bug, it’s helpful to write a test first that the bug breaks; and then fixing the bug fixes it. The Pragmatic Engineer deepdives relevant for this episodeTimestamps(00:00) Intro (02:00) Why John transitioned back to academia (03:47) Working in academia vs. industry (07:20) Tactical tornadoes vs. 10x engineers (11:59) Long-term impact of AI-assisted coding (14:24) An overview of software design (15:28) Why TDD and Design Patterns are less popular now (17:04) Two general approaches to designing software (18:56) Two ways to deal with complexity (19:56) A case for not going with your first idea (23:24) How Uber used design docs (26:44) Deep modules vs. shallow modules (28:25) Best practices for error handling (33:31) The role of empathy in the design process (36:15) How John uses design reviews (38:10) The value of in-person planning and using old-school whiteboards (39:50) Leading a planning argument session and the places it works best (42:20) The value of doing some design upfront (46:12) Why John wrote A Philosophy of Software of Design (48:40) An overview of John’s class at Stanford (52:20) A tough learning from early in Gergely’s career (55:48) Why John disagrees with Robert Martin on short methods (1:10:40) John’s current coding project in the Linux Kernel (1:14:13) Updates to A Philosophy of Software Design in the second edition (1:19:12) Rapid fire round (1:01:08) John’s criticisms of TDD and what he favors instead (1:05:30) Why John supports the use of comments and how to use them correctly (1:09:20) How John uses ChatGPT to help explain code in the Linux Kernel A summary of the conversationImpact of AI on software engineering: tactical applications
Principles of good software design
John’s disagreements with practices outlined in the book Clean Code by Robert C. Martin
Teaching software design at Stanford
What John is currently working on
Where to find John Ousterhout: • X: https://x.com/johnousterhout • Website: https://engineering.stanford.edu/people/john-ousterhout Mentions during the episode: • UC Berkeley: https://www.berkeley.edu/ • Sun Microsystems: https://simple.wikipedia.org/wiki/Sun_Microsystems • Stanford University: https://www.stanford.edu/ • A Philosophy of Software Design: https://www.amazon.com/Philosophy-Software-Design-2nd/dp/173210221X/r • TDD (test-driven development): https://en.wikipedia.org/wiki/Test-driven_development • Design Patterns: https://en.wikipedia.org/wiki/Design_Patterns • Engineering Planning with RFCs, Design Documents and ADRs: https://newsletter.pragmaticengineer.com/p/rfcs-and-design-docs • Tk: https://en.wikipedia.org/wiki/Tk_(software) • Waterfall methodology: https://www.atlassian.com/agile/project-management/waterfall-methodology • Robert "Uncle Bob" Martin and John Ousterhout’s discussion: https://github.com/johnousterhout/aposd-vs-clean-code/blob/main/README.md • Clean Code: A Handbook of Agile Software Craftsmanship: https://www.amazon.com/dp/0132350882 • Bob Martin on X: https://x.com/unclebobmartin • Single-responsibility principle: https://en.wikipedia.org/wiki/Single-responsibility_principle • The Linux Kernel Archives: https://www.kernel.org/ • How Linux is built with Greg Kroah-Hartman: https://newsletter.pragmaticengineer.com/p/how-linux-is-built-with-greg-kroah • Homa: A Receiver-Driven Low-Latency Transport Protocol Using Network Priorities: https://people.csail.mit.edu/alizadeh/papers/homa-sigcomm18.pdf • Behnam Montazeri on LinkedIn: https://www.linkedin.com/in/behnam-montazeri-639a8a29/ • TCP: https://en.wikipedia.org/wiki/Transmission_Control_Protocol • Resources from John’s website: https://web.stanford.edu/~ouster/cgi-bin/aposd.php • A Philosophy of Software Design: My Take (and a Book Review): https://blog.pragmaticengineer.com/a-philosophy-of-software-design-review/ — Production and marketing by Pen Name. For inquiries about sponsoring the podcast, email podcast@pragmaticengineer.com. You’re on the free list for The Pragmatic Engineer. For the full experience, become a paying subscriber. Many readers expense this newsletter within their company’s training/learning/development budget. This post is public, so feel free to share and forward it. If you enjoyed this post, you might enjoy my book, The Software Engineer's Guidebook. Here is what Tanya Reilly, senior principal engineer and author of The Staff Engineer's Path said about it:
|
%26stroke%3Dnone%26strokeWidth%3D3.6){kind=small}
Comments
Post a Comment