Bjarne Stroustrup: C++ | Lex Fridman Podcast #48

Bjarne Stroustrup: C++ | Lex Fridman Podcast #48

Lex Fridman PodcastNov 7, 20191h 47m

Lex Fridman (host), Bjarne Stroustrup (guest)

Bjarne Stroustrup’s early programming experiences and influences (Algol, Simula, Assembler)History and evolution of programming languages (Fortran, ALGOL, Simula, Lisp, functional languages)Core design philosophy of C++: zero-overhead abstractions, strong static typing, RAIIObject-oriented and generic programming in C++ (classes, inheritance, templates, concepts)Reliability, safety, and static analysis in large, long‑lived systemsC++ standardization process (ISO/ANSI committees, C++98, 11, 14, 17, 20)Relationship between C++ and other domains/tools (JavaScript, ML/Haskell, Rust, machine learning/AI)

In this episode of Lex Fridman Podcast, featuring Lex Fridman and Bjarne Stroustrup, Bjarne Stroustrup: C++ | Lex Fridman Podcast #48 explores bjarne Stroustrup on C++: Abstraction, Efficiency, and Reliable Systems Bjarne Stroustrup traces his personal journey through early languages like Algol, Simula, and C into the creation of C++, explaining how object-oriented and generic programming emerged from the need to express domain concepts as efficient user-defined types.

Bjarne Stroustrup on C++: Abstraction, Efficiency, and Reliable Systems

Bjarne Stroustrup traces his personal journey through early languages like Algol, Simula, and C into the creation of C++, explaining how object-oriented and generic programming emerged from the need to express domain concepts as efficient user-defined types.

He emphasizes C++’s core philosophy: give programmers high-level abstractions that cost no more than hand-written low-level code (the “zero-overhead” principle), enabling both performance and reliability in long‑lived, safety- and cost-critical systems.

The conversation explores the history of programming languages, the role of strong but flexible type systems, templates and concepts, constructors/destructors (RAII), and the ISO standardization process that has guided C++’s evolution.

Stroustrup contrasts precise, systems-level engineering with fuzzier domains like machine learning, arguing that different problem areas demand different tools but can still share deep design principles and philosophies.

Key Takeaways

High-level abstractions must not sacrifice performance in systems programming.

Stroustrup’s “zero-overhead principle” demands that abstractions like classes, templates, and algorithms compile down to code as efficient as carefully hand-written low-level C or assembly, enabling C++ to power performance- and cost-critical infrastructure.

Get the full analysis with uListen AI

User-defined types are central: model your domain directly in the type system.

Inspired by Simula, C++ treats classes as user-defined types that should behave like built-ins in syntax and efficiency, letting developers express domain concepts (e. ...

Get the full analysis with uListen AI

Constructors and destructors (RAII) are the key to safe, predictable resource management.

Stroustrup identifies RAII as C++’s most important idea: acquire resources in constructors and release them in destructors so memory, file handles, locks, and other resources are managed deterministically without requiring garbage collection.

Get the full analysis with uListen AI

Static analysis and clear guidelines are crucial for reliability in large systems.

He argues reliability comes first from simplification and good design, then from tools: language rules, coding guidelines (C++ Core Guidelines), and static analyzers that catch common errors and rule violations before runtime.

Get the full analysis with uListen AI

Generic programming with templates enables both code reuse and superior optimization.

Templates allow algorithms like sort or matrix operations to be written once and specialized per type at compile time, often generating faster code than manual C, while newer features like concepts add precise, compile-time constraints on template parameters.

Get the full analysis with uListen AI

Standardization via ISO is painful but essential for a widely used language.

An open, multi-vendor, consensus-driven process (ANSI/ISO committees) ensures C++ evolves predictably across platforms and avoids monocultures, even though it slows decisions and requires careful compromise on features like concepts.

Get the full analysis with uListen AI

Different domains need different tools, but share underlying design philosophies.

Stroustrup distinguishes precise, safety-critical engineering (where fuzziness is unacceptable) from probabilistic domains like machine learning, yet suggests that at a philosophical level—principles like avoiding unnecessary runtime errors or leaks—there can be convergence.

Get the full analysis with uListen AI

Notable Quotes

We want to raise the language to the human level, but we don't want to lose the efficiency.

Bjarne Stroustrup

In C++, as in Simula, a class is a user-defined type.

Bjarne Stroustrup

One of the clear answers is constructors and destructors. That is the key to C++.

Bjarne Stroustrup

There's what you can do in a language and what you should do.

Bjarne Stroustrup

Programming language design needs philosophy, because you are determining what people can express and how.

Bjarne Stroustrup

Questions Answered in This Episode

How can everyday C++ developers practically apply the zero-overhead principle in their own codebases?

Bjarne Stroustrup traces his personal journey through early languages like Algol, Simula, and C into the creation of C++, explaining how object-oriented and generic programming emerged from the need to express domain concepts as efficient user-defined types.

Get the full analysis with uListen AI

What are concrete examples where concepts dramatically improve template error messages and design clarity?

He emphasizes C++’s core philosophy: give programmers high-level abstractions that cost no more than hand-written low-level code (the “zero-overhead” principle), enabling both performance and reliability in long‑lived, safety- and cost-critical systems.

Get the full analysis with uListen AI

How far can static analysis realistically go toward preventing serious bugs in large C++ systems before runtime?

The conversation explores the history of programming languages, the role of strong but flexible type systems, templates and concepts, constructors/destructors (RAII), and the ISO standardization process that has guided C++’s evolution.

Get the full analysis with uListen AI

In which scenarios would Stroustrup now recommend choosing another language over C++, and why?

Stroustrup contrasts precise, systems-level engineering with fuzzier domains like machine learning, arguing that different problem areas demand different tools but can still share deep design principles and philosophies.

Get the full analysis with uListen AI

How might the philosophical design principles behind C++ inform the future design of languages for machine learning or safety-critical AI?

Get the full analysis with uListen AI

Transcript Preview

Lex Fridman

The following is a conversation with Bjarne Stroustrup. He's the creator of C++, a programming language that after 40 years is still one of the most popular and powerful languages in the world. Its focus on fast, stable, robust code underlies many of the biggest systems in the world that we have come to rely on as a society. If you're watching this on YouTube, for example, many of the critical backend components of YouTube are written in C++. Same goes for Google, Facebook, Amazon, Twitter, most Microsoft applications, Adobe applications, most database systems, and most physical systems that operate in the real world, like cars, robots, rockets that launch us into space and one day will land us on Mars. C++ also happens to be the language that I use more than any other in my life. I've written several hundred thousand lines of C++ source code. Of course, lines of source code don't mean much, but they do give hints of my personal journey through the world of software. I've enjoyed watching the development of C++ as a programming language, leading up to the big update in the standard in 2011 and those that followed in '14, '17 and toward the new C++ 20 standard hopefully coming out next year. This is The Artificial Intelligence Podcast. If you enjoy it, subscribe on YouTube, give it five stars on iTunes, support it on Patreon, or simply connect with me on Twitter @lexfridman, spelled F-R-I-D-M-A-N. And now, here's my conversation with Bjarne Stroustrup. What was the first program you've ever written? Do you remember?

Bjarne Stroustrup

It was my second year in university, first year of computer science. And it was in Algol 60. I calculated the shape of a super ellipse and then connected points on the, on the perimeter, uh, creating star patterns. It was with a- w- with a wet ink on a paper printer. (laughs)

Lex Fridman

And that was in college, in university?

Bjarne Stroustrup

Yeah, yeah. I learned to program the second year in university.

Lex Fridman

And what was the first programming language, if I may ask it this way, that you fell in love with?

Bjarne Stroustrup

I, I think Algol 60. And after that, I remember... I remember SNOBOL. I remember Fortran, didn't fall in love with that. I remember Pascal, didn't fall in love with that. It all got in the way of me. Uh, and then I discovered Assembler and that was much more fun. And from there, I went to micro, um, microcode.

Lex Fridman

So you were drawn to the... You found the low-level stuff beautiful.

Bjarne Stroustrup

I, I went through a lot of languages and then I spent significant time in, in Assembler and microcode. That was sort of the first really profitable things and that paid for my master's actually. And then I discovered Simula, which was absolutely great.

Lex Fridman

Simula?

Bjarne Stroustrup

Simula was the extension of Algol 60, uh, done primarily for simulation, but basically they invented object-oriented programming and inheritance and runtime polymorphism when they were, while they were doing it. And, uh, that was a language that taught me that you could have the, sort of the problems of a program grow with size of the program rather than with the square of the size of the program. That is, you can actually modularize very nicely. And that, that, that was a surprise to me. It was also a surprise to me that a stricter type system than Pascal's was helpful, whereas Pascal's type system got in my way all the time. So you need a, a strong type system to organize your code well, but it has to be extensible and flexible.

Install uListen to search the full transcript and get AI-powered insights

Get Full Transcript

Get more from every podcast

AI summaries, searchable transcripts, and fact-checking. Free forever.

Add to Chrome