TL;DR
Get business pricing on monitors, keyboards and dev gear
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
The Pragmatic Engineer published a podcast conversation with Titus Winters, a former Google engineering leader and co-author of Software Engineering at Google, about large-scale refactoring, testing, code review and computer science education. Winters also discussed AI’s effects on engineering productivity, though several claims in the episode summary are based on his observations rather than independently presented data.
The Pragmatic Engineer has published a podcast interview with Titus Winters, a former Google engineering leader and lead author of Software Engineering at Google, covering the company’s large-scale C++ refactoring work and his views on computer science education. The conversation also addresses testing, code review and AI’s effect on software development, connecting practices used to manage large codebases with Winters’ argument that engineering curricula need an update.
Winters spent more than a decade at Google, where he led the company’s readability program and helped build Abseil, Google’s open-source foundational C++ libraries. The Pragmatic Engineer identifies him as currently a senior principal scientist at Adobe, working on developer experience and productivity. The episode’s host describes Winters as having worked on updating the ACM/IEEE undergraduate computer science curriculum guidelines.
A central example in the interview is a Google effort around 2010 to change old C++ patterns across a codebase the source says contained nearly 250 million lines and was edited by about 10,000 engineers. Winters recalled a team of roughly a dozen people using language-parsing techniques to locate and change code. The process involved parsing build targets into abstract syntax trees, matching specific call patterns, generating edits, releasing the old and new APIs side by side, and distributing changes in batches. The report says the work also led the team to create the clang-format toolkit.
The interview also recounts Google making automated tests a requirement for changes after Search had fallen from a monthly release cadence to quarterly releases, according to Winters’ account. At the time he left Google, the report says, more than 10,000 engineers were enrolled in the readability program. Google’s review process, as described in the report, required sign-off from both a domain expert and a language-specific readability reviewer.
Engineering Practices at Google’s Scale
The examples show why testing, review and safe refactoring matter beyond code style: at a large organization, a change can affect many teams and products, and accumulated dependencies can make routine updates risky. The Google story offers a case study in using automated tools and review structures to coordinate work across a very large codebase, rather than relying on individual engineers to track every consequence.
The education discussion matters because new graduates enter workplaces where they may encounter mature systems, collaborative review and tools that change how code is produced. Winters’ call to rethink parts of computer science education, as framed by the episode, speaks to the gap between teaching programming fundamentals and preparing students for software engineering in teams. The interview does not provide a complete curriculum proposal in the supplied excerpt, so its specific recommendations cannot be fully evaluated here.
Winters also offers a caution on AI-assisted development. The report says he has heard from engineers at other companies that code output has risen while outages have increased and feature output has remained static. Those observations point to a practical question for engineering teams: whether faster code generation produces reliable, useful software, or shifts work toward testing and maintenance. The report does not supply a dataset or define the companies and time period behind the figures, so they should be treated as Winters’ reported observations, not a measured industry-wide result.
Popular right now
Vitamix 5200 Professional-Grade Blender, 64 oz. Container, Black
De'Longhi 15-Bar Pump Espresso Machine with Milk Frother & Temperature Control
Ninja CREAMi Scoop & Swirl 13-in-1 Ice Cream and Soft Serve Maker, NC701
As an affiliate, we earn on qualifying purchases.
From Refactoring to Curriculum Reform
The Pragmatic Engineer presents the episode as a discussion of both Winters’ Google experience and his current work. The C++ refactor took place in 2010, before large language models were available for the task, according to the report. The team instead relied on parsing and controlled, machine-generated edits, while keeping the old and new interfaces compatible during the rollout. That approach illustrates how tooling and staged deployment can support changes that would be difficult to make safely through manual edits alone.
The interview links that experience to Google’s broader engineering processes. The report says Search’s release cadence had slowed to quarterly by around 2007, prompting the company to require tests with changes. It also describes code review as a combination of project ownership and language-specific readability expertise. These details are presented through Winters’ account and the episode summary; the source excerpt does not include independent documentation or Google statements verifying each historical detail.
Winters’ education work extends the discussion beyond one company. The report says he contributed to updating undergraduate computer science curriculum guidelines associated with the ACM and IEEE. It frames the tension as a striking one: a contributor to established software engineering education now arguing for major changes to much of it. The supplied excerpt establishes that debate as a subject of the interview, but does not include the full curriculum case or the resulting guideline text.
“We were replacing the foundation of the Empire State Building. We were not allowed to close the building or block traffic. Oh, and we discovered nuclear waste in the basement.”
— Titus Winters, recalling the Google C++ refactoring project
Limits of the Interview’s Evidence
The supplied report is an episode summary, not a transcript of the full discussion. It does not include the full details of Winters’ proposed curriculum changes, nor does it establish which parts of current courses he would retain or replace. The reported history of Google’s refactor, testing mandate and readability program is attributed to the interview rather than independently corroborated in the material provided.
The AI-related figures need particular caution. Winters reportedly said outages at companies he speaks with were up about 30%, while code output had risen and feature counts were static. The excerpt does not define the outage measure, comparison period, sample of companies or baseline. It therefore cannot establish that AI caused an increase in outages or that the observation applies across the software industry. The supplied material also ends partway through its list of discussion points, leaving further claims and interview details unavailable.
Full Episode and Curriculum Details
The Pragmatic Engineer says the episode is available on YouTube, Apple and Spotify, with a transcript and timestamps on its page. Readers seeking Winters’ fuller argument about AI productivity and computer science education will need the complete interview; the excerpt supplied here does not set out a publication schedule for revised curriculum guidance or further follow-up reporting.
The next useful evidence would include the full curriculum recommendations and supporting material, alongside clearly defined data on software output, outages and releases. Until then, the episode provides Winters’ perspective and recollections, while the broader claims about education and AI remain subjects for further documentation and comparison.
Key Questions
Who is Titus Winters?
Winters spent more than a decade at Google, where he led its readability program and helped develop Abseil, an open-source C++ library collection. The report identifies him as a senior principal scientist at Adobe and lead author of Software Engineering at Google.
What does the interview cover?
The conversation covers Google’s large-scale C++ refactor, testing requirements, code review and readability practices, Winters’ work on computer science curriculum guidelines, and his views on AI and software productivity.
How did Google manage the C++ refactor?
According to the report, the team parsed code into abstract syntax trees, matched targeted patterns and generated edits. It introduced the replacement API alongside the old one, distributed changes in batches and then removed the old API.
Does the report prove AI is increasing outages?
No. It relays Winters’ observation that outages were up about 30% among companies he speaks with, but gives no defined sample, measurement period or baseline. That figure does not establish that AI caused the increase or that it represents the industry as a whole.
Where can readers hear the episode?
The Pragmatic Engineer lists the episode on YouTube, Apple and Spotify, and says a transcript and timestamps are available on its page.
Source: newsletter.pragmaticengineer.com
