searchlore

Back to Resource

All Segments

Guido van Rossum: Python and the Future of Programming | Lex Fridman Podcast #341

Guido van Rossum: Python and the Future of Programming | Lex Fridman Podcast #341

81 segments available

Guido van Rossum is the creator of Python programming language. Please support this podcast by checking out our sponsors: - GiveDirectly: https://givedirectly.org/lex to get gift matched up to $1000 - Eight Sleep: https://www.eightsleep.com/lex to get special savings - Fundrise: https://fundrise.com/lex - InsideTracker: https://insidetracker.com/lex to get 20% off - Athletic Greens: https://athleticgreens.com/lex to get 1 month of fish oil EPISODE LINKS: Guido's Twitter: https://twitter.com/gvanrossum Guido's Website: https://gvanrossum.github.io/ Python's Website: https://python.org PODCAST INFO: Podcast website: https://lexfridman.com/podcast Apple Podcasts: https://apple.co/2lwqZIr Spotify: https://spoti.fi/2nEwCF8 RSS: https://lexfridman.com/feed/podcast/ Full episodes playlist: https://www.youtube.com/playlist?list=PLrAXtmErZgOdP_8GztsuKi9nrraNbKKp4 Clips playlist: https://www.youtube.com/playlist?list=PLrAXtmErZgOeciFP3CBCIEElOJeitOr41 OUTLINE: 0:00 - Introduction 0:48 - CPython 6:01 - Code readability 10:22 - Indentation 26:58 - Bugs 38:26 - Programming fads 53:37 - Speed of Python 3.11 1:18:31 - Type hinting 1:23:49 - mypy 1:29:05 - TypeScript vs JavaScript 1:45:05 - Best IDE for Python 1:55:05 - Parallelism 2:12:58 - Global Interpreter Lock (GIL) 2:22:36 - Python 4.0 2:34:53 - Machine learning 2:44:35 - Benevolent Dictator for Life (BDFL) 2:56:11 - Advice for beginners 3:02:43 - GitHub Copilot 3:06:10 - Future of Python SOCIAL: - Twitter: https://twitter.com/lexfridman - LinkedIn: https://www.linkedin.com/in/lexfridman - Facebook: https://www.facebook.com/lexfridman - Instagram: https://www.instagram.com/lexfridman - Medium: https://medium.com/@lexfridman - Reddit: https://reddit.com/r/lexfridman - Support on Patreon: https://www.patreon.com/lexfridman

Segments Timeline

1
0:00 - 0:25
0:25 duration47 words

The Journey to Python 4.0

Guido van Rossum reflects on the challenges and triumphs of transitioning from Python 2 to Python 3, setting the stage for the anticipated features of Python 4.0. He discusses the complexities involved in such a significant version change and the expectations surrounding it.

"can you imagine possible features that python 4.0 might have that would necessitate the creation of the new 4.0 given the amount of pain and joy suffering and Triumph that was involved in the move bet..."

2
0:25 - 1:02
0:37 duration96 words

Understanding CPython

Guido explains CPython, the original and most widely used implementation of Python, which he created over 30 years ago. He discusses its significance and the performance improvements expected in Python 3.11, claiming it to be 10 to 60 percent faster.

"the following is a conversation with Guido van Rossum his second time on this podcast he is the creator of the Python programming language and is Python's Emeritus pdfo benevolent dictator for life th..."

3
1:02 - 2:01
0:58 duration187 words

Programming for Everyone

In a humorous analogy, Guido describes the diverse audience of Python programmers, from novices to experts. He emphasizes the importance of making programming accessible to all, using relatable examples to bridge the gap between different levels of expertise.

"python implementation standing also the first one that was ever created the original python implementation that I started over 30 years ago so what does it mean that python the programming language is..."

4
2:01 - 3:02
1:01 duration180 words

The Complexity of Programming Languages

Guido discusses the intricacies of programming languages, comparing them to human languages. He highlights the importance of clarity and precision in programming, drawing parallels to how language can be ambiguous yet effective in communication.

"make him mad I'm sure he has a cell phone so uh he's probably very suspicious about what goes on in that cell phone but he must have heard that inside his cell phone is a tiny computer and a programmi..."

5
3:02 - 4:41
1:39 duration249 words

Programming Languages as Recipes

Guido likens programming languages to recipes, emphasizing the need for clear instructions. He explains how programming requires unambiguous statements, contrasting it with the inherent ambiguity found in human languages, which can lead to misunderstandings.

"a difference and it could be that there are Regional variations in how China native Chinese speakers pronounce that one sound that sounds to L to some like L to some of them like R to others so it's b..."

6
4:41 - 6:01
1:19 duration191 words

The Importance of Code Readability

Guido introduces the concept of code readability, discussing the significance of writing clear and understandable code. He explains how readability benefits collaboration among programmers and enhances the debugging process.

"languages I think ambiguity is a feature not a bug in human spoken languages like uh that's the dance of communication between humans well for lawyers ambiguity certainly is a feature uh for plenty of..."

7
6:01 - 7:29
1:28 duration218 words

The Social Nature of Software Development

Guido emphasizes that software development is a collaborative effort, not a solitary activity. He discusses how teams of programmers work together to improve code, highlighting the social aspect of programming and the importance of shared conventions.

"you go through and pepe the style guide for python code some ideas of what this language should look like feel like read like and the big idea there is that code readability counts what does that mean..."

8
7:29 - 8:54
1:24 duration161 words

The Cookbook Analogy

Continuing the recipe analogy, Guido explains how programming differs from cooking. He discusses the need for clarity in programming instructions and how the complexity of software requires ongoing refinement and collaboration.

"the instructions that he gives to the computer so that the thing is there is a difference between a cookbook recipe and a computer program The cookbook recipe the the author of The cookbook writes it ..."

9
8:54 - 10:30
1:35 duration249 words

Indentation in Python

Guido delves into Python's unique indentation style, explaining its role in enhancing code readability. He discusses the historical context of this design choice and how it sets Python apart from other programming languages.

"debugging and you end up with the activity of so debugging is trying to figure out why your code doesn't run the way you thought it should run that means brother could be stupid little errors or it co..."

10
10:30 - 12:01
1:31 duration245 words

The Magic of Indentation

Guido elaborates on the significance of indentation in Python, explaining how it structures code and improves readability. He contrasts Python's approach with other languages that use braces, discussing the trade-offs involved.

"but there's also like a spatial structure to it can you explain the indentation style of python and what is the magic to it space bases are important for readability of any kind of text if you take a ..."

11
12:01 - 13:43
1:41 duration256 words

Curly Braces vs. Indentation

In a thought-provoking discussion, Guido reflects on the possibility of using curly braces in Python. He shares his reasoning for choosing indentation and how it simplifies the learning process for new programmers.

"um but there is a strictness to the spacing that python defines so there's some a looser thing some stricter things but the four spaces for the for the indentation is really interesting it it really u..."

12
13:43 - 15:29
1:46 duration255 words

The Historical Context of Programming Syntax

Guido discusses the historical evolution of programming syntax, particularly the use of symbols like the dollar sign in languages like PHP. He explains how these conventions emerged and their impact on programming practices.

"think also all the Google C plus plus code is indented with only two spaces per block if you're not used to that it's harder to at a glance understand the code because the the sort of the the high lev..."

13
20:47 - 22:03
1:15 duration196 words

The Importance of Attention to Detail in Programming

Guido van Rossum discusses the significance of teaching beginning programmers the importance of attention to detail in coding. He emphasizes that programming requires a different mindset than writing in English, highlighting the necessity of understanding specific syntax and structure to avoid common pitfalls.

"you're also not sort of misled into putting them where they don't belong because you don't learn about them in the first place the flip side of that is forcing the strictness onto the beginning progra..."

14
22:03 - 23:39
1:36 duration229 words

Historical Context of the Dollar Sign in Programming

Van Rossum explains the historical reasons behind the use of the dollar sign in programming languages like PHP and Perl. He traces its origins to early scripting languages and discusses how it aids in distinguishing between variables and file names, illustrating the evolution of programming syntax.

"because a very earliest shells had a notion of scripting but they did not have a notion of parameterizing the scripting right and so a script is just a few lines of text where each line of text is a c..."

15
23:39 - 25:00
1:20 duration202 words

Parsing Challenges in Early Scripting Languages

In this segment, Guido elaborates on the challenges faced by early scripting languages in parsing commands and parameters. He describes how the conventions established in early shells influenced modern programming practices, emphasizing the need for clarity in variable identification.

"already has a meaning because that presumably means X itself is the file it's a file name it's not a variable name uh and so the inventors of of things like the unique shell and I'm sure job command l..."

16
25:00 - 26:06
1:06 duration181 words

Resilience in Modern Code

Van Rossum reflects on the resilience of modern programming code, discussing the prevalence of bugs and the mechanisms in place to handle errors. He highlights the importance of user experience in debugging and the common practices that developers adopt when encountering issues.

"and so it was was sort of invented as a clever way to make parsing of things that contain but contain both variable and fixed parts very easy in a very simple script processor it also helps even then ..."

17
26:06 - 27:15
1:09 duration166 words

The Cost of Debugging

This segment dives into the significant time and financial costs associated with debugging in software development. Van Rossum shares statistics on the average number of bugs per line of code and the extensive resources companies invest in fixing these issues.

"just like biological systems right I mean that the sort of the inner workings of DNA have been stable for well I don't know how long it was like 300 million years half a billion years yeah and there t..."

18
27:15 - 28:43
1:27 duration248 words

Understanding Bugs in Software Development

Guido discusses the nature of bugs in software, differentiating between simple typos and more complex logical errors. He emphasizes the iterative nature of programming and how mistakes can lead to deeper issues if not addressed promptly.

"and there are error correcting or self-correcting mechanisms at many levels including probably the user of the code well in the end the user who sort of is told well you got to reboot your your PC is ..."

19
28:43 - 30:02
1:18 duration183 words

Bugs Per Line of Code: Insights and Statistics

In this insightful segment, Van Rossum shares research findings on the average number of bugs per line of code across various software projects. He discusses the implications of these statistics for developers and the software industry as a whole.

"out there from the code that runs nuclear weapons to the code that runs all the amazing companies that you've been involved with and not the code that runs Twitter and Facebook and Dropbox and Google ..."

20
30:02 - 31:07
1:05 duration164 words

The Time Investment in Fixing Bugs

Van Rossum highlights the staggering amount of time developers spend on debugging, revealing that fixing a bug can take significantly longer than writing the original code. He discusses the impact this has on productivity and project timelines.

"mature software that that is considered interesting as good as it gets can I give you some facts here there's a lot of good papers so you said mature software right so here's uh a report from a uh lik..."

21
31:07 - 32:02
0:54 duration162 words

The Reality of Software Development Costs

This segment addresses the financial implications of software development, particularly the costs associated with identifying and fixing bugs. Van Rossum reflects on the industry's investment in debugging tools and the challenges of achieving error-free code.

"identifying and fixing bugs imagine this is marketing literature for someone who claims to have a golden bullet or a silver bullet that makes all that investment in fixing bugs go away but that that i..."

22
32:02 - 33:36
1:34 duration234 words

The Iterative Nature of Programming

Guido discusses the iterative process of software development, emphasizing that programming is rarely a linear task. He explains how developers often work in cycles, refining their code and addressing bugs as they arise.

"bugs oh absolutely isn't that scary that 70 bucks per 1000 lines of code so even 10 bucks per thousand lives well that's about one bug after every 15 lines and that's when you're first typing it in ye..."

23
33:36 - 34:37
1:00 duration147 words

Typing Challenges and Coding Efficiency

In this segment, Van Rossum shares his personal experiences with typing and coding efficiency. He discusses the impact of keyboard design on productivity and the common challenges developers face when correcting mistakes.

"my code watch anyone give you a little coding demonstration they'll have to produce like four lines of code and now see how many times they use the backspace key yeah because they made a mistake and a..."

24
34:37 - 36:02
1:25 duration233 words

Defining Bugs in Programming

Van Rossum explores the definition of bugs in programming, distinguishing between simple typos and more complex logical errors. He emphasizes the importance of understanding the context of errors to improve coding practices.

"so I don't know what your definition of bug is arguably mistyping a word and then correcting it immediately is not a bug on the other hand you you already do sort of lose time and every once in a whil..."

25
36:02 - 37:44
1:42 duration302 words

The Comfort of Familiar Tools

Guido reflects on the comfort and productivity that come from using familiar programming tools. He discusses the balance between sticking with traditional tools and embracing new technologies in the ever-evolving landscape of programming.

"way I should mention that I use the Kinesis keyboard which has the backspace under the thumb and one of the biggest reasons I use that keyboard is because you realize in order to use the backspace on ..."

26
37:44 - 39:29
1:44 duration289 words

Learning from Programming Fads

In this segment, Van Rossum shares insights on the transient nature of programming technologies and frameworks. He discusses how certain tools may fade away, but the concepts they introduced often remain relevant in the industry.

"you are um but also it's a you know for a lot of people for me certainly there's a comfort space where there's a certain kind of setups that are maximized productivity and um it's like some people hav..."

27
39:29 - 41:01
1:32 duration182 words

The Evolution of Programming Concepts

Guido concludes by discussing the evolution of programming concepts over time. He emphasizes that while specific technologies may become obsolete, the foundational ideas they introduced continue to shape the future of programming.

"not well you know in most cases like that the particular technology eventually gets replaced but many of the concepts that the technology introduced or made accessible first are preserved of course be..."

28
40:20 - 42:54
2:34 duration373 words

The Evolution of Programming Languages

Guido van Rossum discusses the evolution of programming languages, reflecting on how technologies like Flash were once innovative but eventually replaced by better alternatives like JavaScript. He emphasizes the importance of learning from past technologies, even if they become obsolete, and the necessity for programmers to adapt and explore new languages and systems as they progress in their careers.

"I mean flash was an innovation when it first came up and when it was replaced by JavaScript equivalence stuff it was a somewhat better way to do animations but those animations are still there not all..."

29
42:54 - 45:00
2:05 duration312 words

Embracing Risk in Learning

Van Rossum shares insights on the importance of experimentation in programming, especially for beginners. He encourages young programmers to take risks and make mistakes, as this is crucial for learning and discovering better methods. He draws parallels between personal life choices and programming language decisions, highlighting how early choices can shape one's career trajectory.

"ten times you sort of you discover something that's better or that's that somehow works I mean there are all sorts of crazy things that were invented uh by accident by people trying trying stuff toget..."

30
45:00 - 48:00
2:59 duration532 words

The Leap from C++ to Python

In this segment, Guido van Rossum recounts his personal journey of transitioning from C and C++ to Python. He reflects on the challenges of letting go of a familiar programming language and the existential crisis that can accompany such a decision. He discusses the advantages of Python for machine learning and the cultural shift that comes with adopting new technologies.

"I had a very difficult in my own head Brave leap that I had to take relevant to our discussion which is most of my life I programmed in C and C plus plus and so uh having that hammer everything looked..."

31
48:00 - 51:13
3:13 duration509 words

Choosing the Right Programming Language

Van Rossum explores the complexities of choosing a programming language, weighing the pros and cons of various options like PHP, Node.js, and Python. He emphasizes that there is no one-size-fits-all answer, as personal circumstances, community engagement, and project requirements all play a significant role in this decision-making process.

"face that kind of decision it was a difficult decision for me um when I made it at this time it's an obvious switch if you're into machine learning but at that time it wasn't quite yet so obvious so i..."

32
51:13 - 54:20
3:07 duration548 words

Simplicity vs. Performance in Python

In this segment, Guido van Rossum discusses the balance between simplicity and performance in programming. He explains how early decisions in Python's development prioritized simplicity, which has implications for performance. He shares insights on how algorithms can be optimized over time and the importance of understanding the trade-offs involved in programming.

"community about where you predict the community's headed what large systems are programmed in that but can you create that spreadsheet because that sort of you're mentioning a whole bunch of inputs th..."

33
54:20 - 1:02:13
7:53 duration1143 words

The Nature of Python as an Interpreter

Van Rossum elaborates on Python's role as an interpreter, explaining how it processes readable code. He describes the foundational aspects of Python's design and its approach to executing programs. This segment highlights the significance of Python's readability and its impact on the programming community.

"so 3.11 is coming out one of the big sexy things in it is it'll be much faster so how did you beyond hiring a great team or working with a great team make it faster what are some ideas uh that may mak..."

34
1:02:36 - 1:04:30
1:54 duration283 words

Performance Improvements in Python 3.11

Guido shares insights on the significant performance improvements in Python 3.11, focusing on the interpreter's efficiency. He explains how minor tweaks in the interpreter and bytecode can lead to substantial performance gains, emphasizing the importance of adaptive specialization in the interpreter's design.

"the chef yeah what are the algorithmically tricky things that happen to be low-hanging fruit that could be improved on maybe throughout the history of python but also now how is it possible that 3.11 ..."

35
1:04:30 - 1:06:30
1:59 duration260 words

Adaptive Specialization in Python

This segment delves into the concept of adaptive specialization in Python's interpreter. Guido explains how the interpreter optimizes operations based on the types of variables being used, allowing for more efficient execution of common operations like addition, while still maintaining Python's dynamic nature.

"efficient what's adjust in time compiler that is a thing from the Java World although it's now applied to almost all uh programming languages especially interpreted ones so you see the compile inside ..."

36
1:06:30 - 1:08:35
2:05 duration292 words

The Complexity of Type Handling

Guido discusses the intricacies of type handling in Python, particularly how the interpreter manages operations involving different data types. He explains the challenges of maintaining efficiency while allowing for Python's dynamic typing, and how the interpreter adapts to the types of variables used in operations.

"no such thing as adding two numbers there's just an the the compiler doesn't know that you're adding two numbers you might as well be adding two strings or two lists uh or two instances of some user-d..."

37
1:08:35 - 1:10:50
2:14 duration299 words

Optimizing Addition Operations

In this segment, Guido elaborates on how Python optimizes addition operations through type-specific handling. He explains the process of recognizing the types of operands and how this recognition allows for more efficient execution, while also addressing the potential pitfalls of type assumptions.

"the basics of ant and float and add who carries the knowledge of how to add two integers is it the integer it's the type integer versus it's the type integer and the type float what about the operator..."

38
1:10:50 - 1:12:43
1:53 duration269 words

Heuristics in Type Optimization

Guido explains the heuristics used in Python's type optimization, comparing it to predicting weather patterns. He discusses how the interpreter makes educated guesses about the types of variables based on previous executions, aiming to enhance performance while still accommodating Python's dynamic typing.

"in a particular line of code so now you you write your little Python program and you write a function and that function sort of takes a bunch of inputs and at some point it adds two of the inputs toge..."

39
1:12:43 - 1:14:41
1:57 duration297 words

Dynamic Typing and Performance Trade-offs

This segment addresses the trade-offs between dynamic typing and performance in Python. Guido discusses how the flexibility of Python's dynamic typing can lead to inefficiencies, and the ongoing challenge of optimizing performance without sacrificing the language's core principles.

"code if it's this if it's the same type all the time uh we say oh so this add operation even though it's the generic ad operation it might as well be the add integer operation and add integer operatio..."

40
1:14:41 - 1:16:30
1:49 duration268 words

Future of Type Hints in Python

Guido shares his thoughts on the future of type hints in Python, discussing their current role as documentation rather than enforced checks. He explores the potential for type hints to enhance performance in future versions of Python while maintaining the language's dynamic nature.

"waste that much time and statistically uh most of the time basically we were sort of hoping that most of the time we guess right because if we if it turns out that we guessed wrong too often uh or we ..."

41
1:16:30 - 1:18:30
2:00 duration267 words

Runtime Type Checking and Performance

In this concluding segment, Guido discusses the implications of runtime type checking in Python. He explains how third-party libraries can enforce type hints and the performance costs associated with such checks, emphasizing the balance between type safety and execution speed.

"understand how people are using the language right python is not the first language to do a thing like this this is a fairly well-known trick especially from other interpreted languages that had reaso..."

42
1:20:50 - 1:22:01
1:11 duration169 words

Runtime Type Checking in Python

Guido van Rossum discusses the potential for runtime type checking in Python, emphasizing the introspective capabilities of the language. He explains how type hints can be used to provide hints about variable types, while also acknowledging the performance trade-offs associated with runtime checks. This segment highlights the balance between static and dynamic typing in Python and the future possibilities for type enforcement.

"and so we made we made a choice of not using the annotations there there is a possible future where eventually three four five releases in the future we could start using those annotations to sort of ..."

43
1:22:01 - 1:24:03
2:02 duration320 words

The MyPy Project and Static Typing

In this segment, Guido introduces MyPy, the original static type checker for Python, and its development alongside PEP 484. He shares insights into the collaboration that led to the creation of a syntax for type annotations that integrates seamlessly with Python. This discussion sheds light on the evolution of static typing in Python and the significance of MyPy in enhancing code reliability.

"libraries that uh are in that business so it's possible to do that kind of thing it's possible to for a third party library to take a hint and enforce it it seems like a tricky thing what what well wh..."

44
1:24:03 - 1:27:14
3:10 duration445 words

Comparing TypeScript and JavaScript

Guido van Rossum compares the static typing systems of TypeScript and JavaScript, discussing the cultural and technical differences between the two communities. He highlights the evolution of JavaScript and the potential future integration of type annotations directly into the language. This segment provides valuable insights into how different programming languages handle types and the implications for developers.

"well so my pie uh was started by a Finnish uh developer ukulele so many cool things out of Finland I gotta say just that part of the world I guess people have nothing better to do in those long cold W..."

45
1:27:14 - 1:30:17
3:03 duration419 words

The Evolution of JavaScript

In this segment, Guido reflects on the chaotic yet fascinating evolution of JavaScript as a language primarily used for web applications. He discusses the rapid development cycles of JavaScript engines and how this affects the community's approach to coding standards and practices. This exploration of JavaScript's history offers a contrast to Python's more stable development environment.

"JavaScript old school JavaScript AES whatever well in the JavaScript world transpilers are sort of the standard way of working anyway which is why typescript being a transpiler itself is not a big dea..."

46
1:30:17 - 1:34:17
4:00 duration539 words

Static Type Checkers: A Competitive Landscape

Guido discusses the competitive landscape of static type checkers in Python, including MyPy, Pyre, and Pytype. He explains how these tools have evolved and the different approaches taken by companies like Facebook and Google. This segment highlights the ongoing interest in static typing and the potential for future developments in type checking within the Python ecosystem.

"yeah just to look at it as almost like a biological system that's evolving it's fascinating to see JavaScript evolve the way it does well maybe we should consider that biological systems are just the ..."

47
1:34:17 - 1:40:13
5:55 duration871 words

Future of Static Typing in Python

In this concluding segment, Guido shares his thoughts on the future of static typing in Python and the challenges of integrating type checkers into the language itself. He emphasizes the rapid evolution of static type checkers compared to Python's slower development pace. This discussion provides a forward-looking perspective on how Python's typing system may continue to evolve.

"Facebook was one of the first they decided that they wanted to use the same technology that they had successfully used for hhvm because they they sort of they had a bunch of compiler writers and and s..."

48
1:41:36 - 1:43:01
1:25 duration209 words

The Challenge of Introducing New Syntax

Guido van Rossum discusses the complexities involved in adding new syntax to Python. He explains that once a new feature is introduced, it cannot be easily removed due to user adoption. The process of deprecating features is lengthy and requires careful communication with the community, highlighting the balance between innovation and stability in programming languages.

"syntax that they're trying to push uh and worse once we've all agreed that we are going to put some new syntax in we can never take it back at least a sort of deprecating an existing feature takes man..."

49
1:43:01 - 1:44:51
1:49 duration263 words

The Rise of Static Type Checkers

In this segment, van Rossum explores the growing interest in static type checkers within the Python community. He notes that many developers are adopting type hints, with estimates suggesting that 20-30% of Python 3 codebases utilize them. The discussion touches on the evolution of type checkers and their role in enhancing code quality and developer productivity.

"laboratory of experiments yep Microsoft Google and all and you get to see and you see that everywhere right because there's not one single uh JavaScript in engine either there is one in Chrome there i..."

50
1:44:51 - 1:46:30
1:39 duration216 words

Choosing the Best IDE for Python

Guido van Rossum shares his personal journey with various Integrated Development Environments (IDEs) for Python, including Vim, Emacs, and PyCharm. He contrasts the user experience of these tools, emphasizing the importance of comfort and efficiency in coding. The conversation also touches on the evolution of IDEs and the impact of features on developer workflow.

"wow I wonder how they measured that did they just scan all of GitHub yeah that's what it looks like yeah they did a quick sentence all of but like a random sampling so you mentioned pie charm let me a..."

51
1:46:30 - 1:48:29
1:59 duration356 words

The Future of Typing and Technology

In this reflective segment, van Rossum discusses the importance of adapting to new technologies, such as typing versus handwriting. He argues that investing time in learning modern tools, like advanced IDEs, can significantly enhance productivity and prepare developers for future challenges in programming.

"I didn't have very good Tooling in emacs for finding a definition of a function got it when I was at Dropbox exploring a 5 million line python code base uh just grabbing all that code for where they'r..."

52
1:48:29 - 1:50:01
1:32 duration247 words

The Spiritual Successor: VS Code and Emacs

Van Rossum draws parallels between VS Code and Emacs, suggesting that VS Code serves as a modern evolution of Emacs' extensibility and customization. He discusses the architectural similarities and the importance of a robust package ecosystem, highlighting how these tools cater to the evolving needs of developers.

"practice typing you can actually estimate back to the spreadsheet the number of paragraphs sentences or words you write for the rest of your life yes I mean all of that is not actual like converting t..."

53
1:50:01 - 1:52:55
2:53 duration370 words

Understanding Locks and Semaphores

In this segment, van Rossum explains the concepts of locks and semaphores in programming, using metaphors to illustrate their functionality. He discusses the challenges of implementing synchronization primitives and the cognitive load on programmers when managing concurrent processes, emphasizing the complexity of ensuring correct execution.

"going to stop you uh I I think that that sort of everybody has to decide for themselves which one they want to to invest more time in I actually ended up giving vs code a very tentative try when I sta..."

54
1:52:55 - 2:04:15
11:20 duration1725 words

Async IO and Its Evolution

Guido van Rossum delves into the evolution of async IO in Python since version 3.4. He discusses its significance in handling concurrent operations and the improvements made to the library over time. This segment provides insights into the future of asynchronous programming in Python and its implications for developers.

"what other peripherals you have and and so the sort of the the extreme extensibility and the package ecosystem that you that you see in vs code is a is a mirror of very similar architectural features ..."

55
2:05:05 - 2:07:05
1:59 duration294 words

Design Challenges in Asynchronous Programming

In this segment, Guido van Rossum delves into the architectural challenges of implementing asynchronous programming in Python. He contrasts different paradigms for handling parallel IO, discussing the complexities and debates surrounding the design of the async IO library and its impact on Python's evolution.

"like a typical web server does so iOS input and outputs you're writing either to the network network connection or reading and writing to a hard drive the story also possible and you can do uh the ide..."

56
2:07:05 - 2:09:30
2:24 duration357 words

Understanding the Global Interpreter Lock (GIL)

Van Rossum provides insights into the Global Interpreter Lock (GIL) in Python, explaining its origins and how it affects concurrency. He discusses the implications of the GIL on multi-threading and the challenges it presents for Python developers, particularly in the context of modern multi-core processors.

"proposed and you were deeply involved with that at the time I was very much involved with that I was like the lead architect uh I ended up talking to people who had already developed Syria's third-par..."

57
2:09:30 - 2:12:55
3:24 duration530 words

Future Directions for Python: Sub-Interpreters

In this segment, Guido van Rossum explores potential future developments for Python, particularly the idea of implementing multiple sub-interpreters. He discusses the benefits and challenges of this approach, including the trade-offs between performance and complexity in managing concurrent Python programs.

"a paradigm where there is sort of notionally a threat of control whether it's an actual operating system thread or more an abstraction in async IO we call them tasks but a task in async IO or a thread..."

58
2:12:55 - 2:25:44
12:49 duration1646 words

Reflections on Python 4.0 and the End of Python 2

Van Rossum reflects on the transition from Python 2 to Python 3, discussing the lessons learned and the community's reluctance to move to Python 4. He shares his thoughts on the symbolic end of Python 2 support and the importance of planning future transitions carefully to avoid past mistakes.

"to callbacks okay beautiful so how does that all interplay with the infamous Gill the goal the global interpreter lock maybe can you say what the Gill is and how does the dance beautifully with Ace in..."

59
2:25:14 - 2:26:49
1:35 duration216 words

Transitioning to Python 4: A New Approach

Discussing the potential transition to Python 4, van Rossum outlines the need for a different process compared to the previous version. He highlights the importance of preparing the community and extension developers for changes that may come with a new version.

"did you shed a single tier while looking out over the horizon I'm not not a very poetic person and I don't shed tears like that but no yeah we we actually had planned a party but the party was planned..."

60
2:26:49 - 2:28:50
2:00 duration224 words

Breaking Backward Compatibility

Van Rossum contemplates the implications of breaking backward compatibility in Python 4. He suggests that while the core language may remain compatible, C extensions would require recompilation, impacting many users who rely on third-party libraries.

"is heavily based on C extensions and that is like the entire machine learning data science Scientific Python world is all based on C extensions for python and so those people would likely feel the pai..."

61
2:28:50 - 2:30:41
1:50 duration248 words

Preparing for Python 4: A Gradual Transition

Van Rossum proposes a gradual transition to Python 4, suggesting that developers might need to prepare for changes well in advance. He discusses the potential for a no-GIL (Global Interpreter Lock) version and the challenges that would entail for extension developers.

"for something significant is using third-party extensions they're like I don't know several hundreds of thousands of third-party extensions on uh the Pi Pi service and I'm not saying they're old they'..."

62
2:30:41 - 2:32:00
1:18 duration186 words

Must-Have Python Libraries

In response to a question about essential Python libraries, van Rossum admits he doesn't frequently use third-party packages. He emphasizes the importance of the standard library and discusses how the ecosystem has evolved with many libraries available for various needs.

"to test the waters see what they need to syntactically to be able to compile at all maybe they're using functions that are defined by the Python 3 runtime that won't be in the python 4 runtime those f..."

63
2:32:00 - 2:34:10
2:10 duration296 words

Python's Dominance in Machine Learning

Van Rossum explains why Python has become the dominant language in the machine learning community. He attributes this to its compatibility, ease of use, and the extensive library ecosystem that supports data science and AI applications.

"uh out of the Pi Pi packages Pi Pi packages uh do you have uh do you have ones you like do you in your opinion other must have Pi Pi libraries or ones you use all the time constantly oh my that I shou..."

64
2:34:10 - 2:36:00
1:49 duration263 words

The Evolution of Scientific Computing

Reflecting on the evolution of scientific computing, van Rossum discusses how Python emerged as a higher-level language that allowed scientists to work more efficiently with complex mathematical libraries, moving away from older languages like Fortran and C++.

"alternative anyway and we're sort of slowly removing those that often those are things that I sort of I spiked somewhere in 1992 or 1993 and if you look look through the commit history it's very sad l..."

65
2:36:00 - 2:38:30
2:30 duration297 words

Community and Collaboration in Python

Van Rossum highlights the importance of community in the growth of Python, noting how collaboration among scientists led to the development of libraries that addressed specific needs. He emphasizes the role of shared knowledge and resources in advancing the language.

"because DNA search was all based on regular expressions and pearl has the fastest and most comprehensive regular expression engine still does I spent quite a long time with pearl that was another lett..."

66
2:38:30 - 2:40:50
2:20 duration310 words

The Role of Open Source in Python's Success

Discussing the impact of open source, van Rossum explains how Python's accessibility and community-driven development have contributed to its widespread adoption. He contrasts this with other languages that have not fostered similar collaborative environments.

"fundamental mathematical algorithms of linear algebra and and other stuff and so gradually some libraries started appearing that did very fundamental stuff with arrays of numbers in Python I mean when..."

67
2:40:50 - 2:43:00
2:10 duration299 words

Reflections on Leadership as BDFL

Van Rossum reflects on his experience as the Benevolent Dictator for Life (BDFL) of Python, discussing the stress and responsibilities that came with the role. He shares insights on the benefits and drawbacks of having a central figure in the community.

"why why start from scratch in Pearl or JavaScript where there's not that infrastructure for arrays of numbers yet whereas in Python you have it and so more and more scientists at different places doin..."

68
2:44:28 - 2:45:03
0:35 duration72 words

Reflections on Leadership as BDFL

Guido van Rossum reflects on his time as the Benevolent Dictator for Life (BDFL) of Python, discussing the stress and challenges he faced. He acknowledges that he may have held onto the role too long and shares insights on the benefits and drawbacks of having a central leadership figure in the Python community.

"forks out uh is to community fostering things So speaking of egalitarian last time we talked four years ago it was just after you stepped down from your role as the benevolent dictator for life pdfo l..."

69
2:45:03 - 2:46:30
1:26 duration159 words

Community Growth and Clarity of Vision

Van Rossum explains how his leadership provided clarity of vision for the Python community, allowing for a steady direction amidst evolving complexities. He discusses the importance of modeling problem-solving approaches and how his active role contributed to community growth, despite the personal stress it caused him.

"I probably held on to the position too long I remember being just extremely stressed for a long time and it wasn't very clear to me what was leading what was causing the stress and looking back uh I I..."

70
2:46:30 - 2:48:02
1:31 duration217 words

The Transition to a Steering Council

Guido discusses the transition from his leadership to a steering council structure in the Python community. He highlights the benefits of this new leadership model, which maintains a steady direction while allowing him to focus on specific areas of interest, such as async I/O and interpreter speed.

"it's still hard to say what are Python's core principles but the fact that I was playing that role and sort of always very active grew the community in a certain way it modeled to the community how to..."

71
2:48:02 - 2:49:36
1:34 duration232 words

Cultural Differences in Tech Companies

Van Rossum shares his observations on the cultural differences between tech companies like Google, Dropbox, and Microsoft from a Python programming perspective. He notes how Dropbox's smaller size leads to a more focused approach but also to challenges with annual engineering reorganizations.

"are things I can just ignore yeah oh yeah there's a bug in multi-processing let someone else decide whether that's important to solve or not I'll I'll stick to typing in the async io and the faster in..."

72
2:49:36 - 2:51:18
1:42 duration303 words

The Power of Seamless Services

Guido reflects on the engineering behind Dropbox's seamless syncing service, emphasizing the complexity hidden behind its user-friendly interface. He discusses the importance of maintaining product quality despite internal turmoil and how companies like Google focus on their core strengths.

"guy was in charge of of infrastructure one year and the next year he was made in charge of I don't know product development it's fascinating because like you don't think about these companies internal..."

73
2:51:18 - 2:52:53
1:34 duration222 words

Microsoft's Shift to Open Source

Van Rossum comments on Microsoft's transformation under CEO Satya Nadella, highlighting the company's embrace of open source culture. He discusses the challenges of pivoting a large organization and the potential for positive change in the tech industry.

"well and in what ways do you provide value and happiness to the world make sure you do that well um is there something else to say about Google and Microsoft Microsoft has said a very fascinating shif..."

74
2:52:53 - 2:54:40
1:47 duration295 words

The Entrepreneurial Dilemma for Programmers

Guido addresses the choice programmers face between working for large companies or pursuing entrepreneurial ventures. He emphasizes the importance of finding a balance between individual contributions and leadership roles within organizations.

"is that I've never learned how to use Excel well I mean it just always felt like so many features are there it's similar with ideas like pie charm it feels like I I converge quickly to the dumbest way..."

75
2:54:40 - 3:01:16
6:35 duration941 words

Advice for Learning Python

Van Rossum offers practical advice for beginners learning Python, stressing the importance of finding a personal project that excites them. He encourages aspiring programmers to engage with real-world problems and explore machine learning as a way to spark interest in coding.

"pivot a company towards open source or develop a culture is there something you could see about like how what's the role of leadership in such a pivot and definition of a new vision I've never met him..."

76
3:01:16 - 3:07:42
6:26 duration962 words

The Future of Python and Programming

Guido shares his vision for the future of Python, predicting it will become a legacy language that underpins many technologies. He discusses the evolution of programming and the importance of foundational knowledge, while also reflecting on the changing landscape of coding practices.

"the basics right yeah you can't expect to Learn Python from a one hour video recording blanking out on the name of of someone who who wrote a very funny blog post where he said I see all these ads for..."

77
3:07:01 - 3:08:27
1:26 duration212 words

Understanding the Layers of Technology

Guido shares his journey of learning about computer architecture, from basic digital circuits to higher-level programming concepts. He discusses the importance of understanding the foundational layers of technology, such as NAND gates, while acknowledging that most programmers today operate at a higher abstraction level. This segment emphasizes the beauty of building on previous knowledge and the interconnectedness of technology.

"you guys you build layers of abstractions I mean most programmers nowadays rarely need to do binary arithmetic right yeah or even think about it or even learn about it or they could go quite far witho..."

78
3:08:27 - 3:09:19
0:51 duration125 words

The Joy of Problem Solving

In this segment, Guido van Rossum reminisces about a mental exercise involving building a flip-flop circuit with relays. He reflects on the satisfaction of engaging with fundamental concepts of electronics and computing. This discussion highlights the joy of problem-solving and the intellectual curiosity that drives innovation in programming and technology.

"it's nice the other day as a sort of a mental exercise I was trying to figure out if I could build a a flip-flop circuit out of uh relays it was just sort of trying to remember oh how does it really r..."

79
3:09:19 - 3:10:05
0:46 duration134 words

The Parallel Nature of Human Thought

Guido explores the fascinating parallelism of human cognition compared to sequential processing in programming. He discusses how our brains perform complex tasks simultaneously, such as image recognition, while our thought processes often feel linear. This segment delves into the nature of consciousness and how it relates to programming and artificial intelligence.

"that I I could still do a little bit of problem solving and thinking at that level and it's cool how we build on top of each other so there's people that are just you you stood on the shoulders of gia..."

80
3:10:05 - 3:12:29
2:23 duration344 words

Abstraction Across Life and Technology

In this philosophical discussion, Guido van Rossum draws parallels between biological systems and programming languages. He reflects on how both life forms and programming constructs replicate and evolve, creating layers of complexity. This segment emphasizes the interconnectedness of all systems, from single-cell organisms to human civilization, and how abstraction plays a crucial role in understanding these systems.

"figures out how it itself Works maybe maybe not yeah I did I mean it's it's possible I mean if you think of human consciousness if that's even the right concept it's it's interesting that that sort of..."

81
3:12:29 - 3:15:40
3:11 duration465 words

Reflections on Life and Learning

As the conversation wraps up, Lex Fridman expresses his admiration for Guido van Rossum and reflects on the journey of learning and growth. The segment concludes with a quote from Oscar Wilde about experience and mistakes, encapsulating the essence of the discussion on programming, technology, and the human experience. This closing moment highlights the importance of reflection in both personal and professional development.

"over time it goes on that way and those computers when they go to college try to figure out how to program and they built their own little computers they're increasingly more intelligent increasingly ..."