Peter Wang is the co-founder & CEO of Anaconda and one of the most impactful leaders and developers in the Python community. Also, he is a physicist and philosopher. Please support this podcast by checking out our sponsors:
- Quip: https://getquip.com/lex to get first refill free
- Magic Spoon: https://magicspoon.com/lex and use code LEX to get $5 off
- GiveWell: https://www.givewell.org/ and use code LEX to get donation matched up to $1k
- Four Sigmatic: https://foursigmatic.com/lex and use code LexPod to get up to 60% off
- BetterHelp: https://betterhelp.com/lex to get 10% off

EPISODE LINKS:
Peter's Twitter: https://twitter.com/pwang
Anaconda's Website: https://www.anaconda.com/
Books & resources mentioned:
Zen and the Art of Motorcycle Maintenance (book): https://amzn.to/3EnCELK
Lila (book): https://amzn.to/30VKIpE

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:33 - Python
4:04 - Programming language design
24:07 - Virtuality
34:07 - Human layers
41:05 - Life
46:29 - Origin of ideas
49:01 - Eric Weinstein
54:00 - Human source code
57:58 - Love
1:12:16 - AI
1:25:39 - Meaning crisis
1:48:12 - Travis Oliphant
1:54:38 - Python continued
2:24:21 - Best setup
2:31:39 - Advice for the youth
2:40:12 - Meaning of Life

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

The following is a conversation with Peter Wang, 1 of the most impactful leaders and developers in the Python community, former physicist, current philosopher, and someone who many people told me about and praised as a truly special mind that I absolutely should talk to.

Recommendations ranging from Travis Oliphant to Eric Weinstein.

To support it, please check out our sponsors in the description.

And now, here's my conversation with Peter Wang.

You're 1 of the most impactful humans in the Python ecosystem.

So you're an engineer, leader of engineers, but you're also a philosopher.

So let's talk both in this conversation about programming and philosophy.

What to you is the best or maybe the most beautiful feature of Python?

Or maybe the thing that made you fall in love or stay in love with Python?

What I think is the most beautiful, what made me fall in love, what made me stay in love.

When I first started using it was when I was a C++ computer graphics performance nerd.

And that was my first job out of college.

And we kept trying to do more and more, like, abstract and higher order programming in C++, which at the time was quite difficult with templates.

So when I started playing around with Python, that was my first time encountering really first class support for types, for functions, and things like that, and it felt so incredibly expressive.

So that was what kind of made me fall in love with it a little bit.

And also, once you spend a lot of time in a C++ dev environment, the ability to just whip something together that basically runs and works the first time is amazing.

I mean, I knew Perl, I knew Bash, I was decent at both, but Python just made everything, it made the whole world accessible.

I could script this and that and the other network things, you know, little hard drive utilities.

I could write all of these things in the space of an afternoon.

Is there something specific you could put your finger on that you're not programming in Perl today?

I think there's not a specific thing as much as the design motif of both the creator of the language and the core group of people that built the standard library around him.

There was definitely, there was a taste to it.

I mean, Steve Jobs, you know, used that term, you know, in somewhat of a arrogant way, but I think it's a real thing that it was designed to fit.

A friend of mine actually expressed this really well.

And there's nothing better to say than that.

Now, people might argue modern Python, there's a lot more complexity, but certainly as of version 1.5.2, I think was my first version, that fit in my head very easily.

So that's what made me fall in love with it.

Okay, so the most beautiful feature of Python that made you stay in love?

It's like over the years, what has like, you know, you do a double take and you return too often as a thing that just brings you a smile.

I really still like the ability to play with meta classes and express higher order things when I have to create some new object model to model something, right?

It's easy for me, because I'm pretty expert as a Python programmer, I can easily put all sorts of lovely things together and use properties and decorators and other kinds of things and create something that feels very nice.

So that, to me, I would say that's tied with the NumPy and vectorization capabilities.

I love thinking in terms of the matrices and the vectors and these kind of data structures.

So I would say those 2 are kind of tied for me.

So the elegance of the NumPy data structure, like slicing through the different multi-dimensional.

It's like a very, it's a very simple, comfortable tool.

Just It's easy to reason about what it does when you don't stray too far afield.

Can you put your finger on how to design a language such that it fits in your head?

Certain things like the colon or the certain notation aspects of Python that just kind of work?

Is it something you have to kind of write out on paper, look and say, it's just right?

Is it a taste thing or is there a systematic process?

But 1 thing that should be said is that you have to pick your audience, right?

So the better defined the user audience is or the users are, the easier it is to build something that fits in their minds because their needs will be more compact and coherent.

It is possible to find a projection, right?

The more diverse the user base, the harder that is.

And so as Python has grown in popularity, that's also naturally created more complexity as people try to design any given thing.

There'll be multiple valid opinions about a particular design approach.

And so I do think that's the downside of popularity.

It's almost an intrinsic aspect of the complexity of the problem.

Well, at the very beginning, aren't you an audience of 1?

Isn't ultimately, aren't all the greatest projects in history were just solving a problem that you yourself

Well, so Clay Shirky in his book on crowdsourcing or in his kind of thoughts on crowdsourcing, he identifies the first step of crowdsourcing is me first collaboration.

You first have to make something that works well for yourself.

It's very telling that when you look at all of the impactful big projects, well, they're fundamental projects now in the SciPy and Pydata ecosystem, they all started with the people in the domain trying to scratch their own itch.

The whole idea of scratching your own itch is something that the open-source or the free software world has known for a long time.

But in the scientific computing areas, these are assistant professors or electrical engineering grad students.

They didn't have really a lot of programming skill necessarily, but Python was just good enough for them to put something together that fit in their domain.

So it's almost like it's a necessity is a mother of invention aspect, and also it was a really harsh filter for utility and compactness and expressiveness.

Like it was too hard to use, then they wouldn't have built it because there was just too much trouble, right?

And also necessity creates a kind of deadline.

It seems like a lot of these projects are quickly thrown together in the first step.

And that, even though it's flawed, that just seems to work well for software projects.

Well, it does work well for software projects in general.

And in this particular space, 1 of my colleagues, Stan Sieber, identified this, that all the projects in the SciPy ecosystem, if we just rattle them off, there's NumPy, there's SciPy, built by different collaborations of people, although Travis is the heart of both of them.

But NumPy coming from Numeric and NumRay, these are different people.

And then you've got pandas, you've got Jupiter or iPython, there's Matt Potlib, there's just so many others I'm not going to do justice if I try to name them all.

But all of them are actually different people.

And as they rolled out their projects, The fact that they had limited resources meant that they were humble about scope.

A great famous hacker, Jamie Zawiski, once said that every geek's dream is to build the ultimate middleware.

And the thing is with these scientists turned programmers, they had no such thing.

They were just trying to write something that was a little bit better for what they needed, the MATLAB, and they were gonna leverage what everyone else had built.

So naturally, almost in kind of this annealing process or whatever, we built a very modular cover of the basic needs of a scientific computing library.

If you look at the whole human story, how much of a leap is it?

We've developed all kinds of languages, all kinds of methodologies for communication, and it just kind of like grew this collective intelligence, civilization grew, it expanded,

wrote a bunch of books, and now we tweet.

How big of a leap is programming if programming's yet another language?

Is it just a nice little trick that's temporary in our human history, or is it like a big leap in the, almost us becoming another organism at a higher level of abstraction, something else?

I think the act of programming or using grammatical constructions of some underlying primitives, That is something that humans do learn, but every human learns this.

Anyone who can speak learns how to do this.

What makes programming different has been that up to this point, when we try to give instructions to computing systems, all of our computers, well, actually this is not quite true, but I'll first say it, and then I'll tell you why it's not true.

But for the most part, we can think of computers as being these iterated systems.

So when we program, we're giving very precise instructions to iterated systems that then run at incomprehensible speed and run those instructions.

In my experience, some people are just better equipped to model systematic iterated systems.

Well, whatever, iterated systems in their head.

Some people are really good at that and other people are not.

And so when you have, like, for instance, sometimes people have tried to build systems that make programming easier by making it visual drag and drop.

And the issue is you can have a drag and drop thing, but once you start having to iterate the system with conditional logic, handling case statements and branch statements and all these other things, the visual drag and drop part doesn't save you anything.

You still have to reason about this giant iterated system with all these different conditions around it.

So handling iterated logic, that's the hard part.

The languages we use then emerge to give us ability and capability over these things.

Now, the 1 exception to this rule, of course, is the most popular programming system in the world, which is Excel, which is a data flow and a data-driven, immediate mode data transformation oriented programming system.

And this actually not an accident that that system is the most popular programming system because it's so accessible to a much broader group of people.

I do think as we build future computing systems, you're actually already seeing this a little bit, it's much more about composition of modular blocks.

They themselves actually maintain all their internal state and the interfaces between them are well-defined data schemas.

And so to stitch these things together using like IFTTT or Zapier or any of these kinds of, you know, I would say compositional scripting kinds of things.

I mean, HyperCard was also a little bit in this vein.

That's much more accessible to most people.

It's really that implicit state that's so hard for people to track.

Yeah, okay, so that's modular stuff, but there's also an aspect where you're standing on the shoulders of giants.

So you're building like higher and higher levels of abstraction, but You do that a little bit with language.

So with language, you develop sort of ideas, philosophies from Plato and so on, and

you kind of leverage those philosophies as you try to have deeper and deeper conversations.

But with programming, it seems like you can build much more complicated systems.

Like without knowing how everything works, you can build on top of the work of others.

And it seems like you're developing more and more sophisticated expressions, ability to express ideas in a computational space.

it's worth pondering the difference here between complexity and complication.

Well, not quite back to Excel, but the idea is, you know, when we have a human conversation, all languages for humans emerged to support human relational communications, which is that the person we're communicating with is a person and they would communicate back to us.

And so we sort of hit a resonance point, right?

So there's a messiness to it and there's a fluidity to it.

With computing systems, when we express something to the computer and it's wrong, we just try again.

So we can basically live many virtual worlds of having failed at expressing ourselves to the computer until the 1 time we expressed ourselves right.

Then we kind of put in production and then discover that it's still wrong, you know, a few days down the road.

So I think the sophistication of the things that we build with computing, 1 has to really pay attention to the difference between when an end user is expressing something onto a system that exists versus when they're extending the system to increase the system's capability for someone else to then interface with.

And we happen to use the same language for both of those things in most cases, but it doesn't have to be that.

And Excel is actually a great example of this, of kind of a counterpoint to that.

Okay, so what about the idea of, you said messiness.

Wouldn't you put the SoftRip 2.0 idea, this idea of machine learning, into the further and further steps into the world of messiness?

The same kind of beautiful messiness of human communication, isn't that what machine learning is?

Is building on levels of abstraction that don't have messiness in them, that at the operating system level, then there's Python, the programming languages that have more and more power, but then finally there's neural networks that ultimately work with data, and so the programming is almost in the space of data, and the data is allowed to be messy.

So the idea of software 2.0 is a lot of the programming happens in the space of data.

So back to Excel, all roads lead back to Excel.

In the space of data and also the hyperparameters of the neural networks and all of those allow the same kind of messiness that human communication allows?

So I don't have, now I did cram a bunch of CS in prep when I applied for grad school, but still I don't have a formal background in computer science, but what I have observed in studying programming languages and programming systems and things like that is that there seems to be this triangle.

It's 1 of these beautiful little iron triangles that you find in life sometimes.

And it's the connection between the code correctness and kind of expressiveness of code, the semantics of the data, and then the kind of correctness or parameters of the underlying hardware compute system.

So there's the algorithms that you wanna apply.

There's what the bits that are stored on whatever media actually represent.

So the semantics of the data within the representation, and then there's what the computer can actually do.

And every programming system, every information system, ultimately finds some spot in the middle of this little triangle.

Sometimes some systems collapse them into just 1 edge.

Are we including humans as a system in this?

No, no, I'm just thinking about computing systems here.

And the reason I bring this up is because I believe there's no free lunch around this stuff.

So if we build machine learning systems to sort of write the correct code that is at a certain level of performance, so it'll sort of select, right, with hyperparameters, we can tune kind of how we want the performance boundary and SLA to look like for transforming some set of inputs into certain kinds of outputs.

That training process itself is intrinsically sensitive to the kinds of inputs we put into it.

It's quite sensitive to the boundary conditions we put around the performance.

So I think even as we move to using automated systems to build this transformation, as opposed to humans explicitly from a top-down perspective, figuring out, well, this schema and this database and these columns get selected for this algorithm, And here we put a Fibonacci heap for some other thing.

Human design or computer design, ultimately what we hit, the boundaries that we hit with these information systems is when the representation of the data hits the real world is where there's a lot of slop and a lot of interpretation.

And that's where actually I think a lot of the work will go in the future is actually understanding kind of how to better in the view of these live data systems, how to better encode the semantics of the world for those things.

There'll be less of the details of how we write a particular SQL query.

Okay, but given the semantics of the real world and the messiness of that, what does the word correctness mean when you're talking about code?

There's a lot of dimensions to correctness.

Historically, and this is 1 of the reasons I say that we're coming to the end of the era of software.

Because for the last 40 years or so, software correctness was really defined about functional correctness.

I write a function, it's got some inputs, does it produce the right outputs?

If so, then I can turn it on, hook it up to the live database, and it goes.

And more and more now we have, I mean, in fact, I think the bright line in the sand between machine learning systems or modern data-driven systems versus classical software systems is that the values of the input actually have to be considered with the function together to say this whole thing is correct or not.

And usually there's a performance SLA as well.

You have a 10 millisecond time budget to return a prediction of this level of accuracy, right?

So these are things that were not traditionally in most business computing systems for the last 20 years at all, people didn't think about it.

But now we have value dependence on functional correctness.

So that question of correctness is becoming a bigger and bigger question.

What does that map to the end of software?

We've thought about software as just this thing that you can do in isolation with some test trial inputs and in a very, you know, very sort of sandboxed environment.

How many nodes do we need to allocate if we want to scale this many inputs?

When we start turning this stuff into prediction systems, real cybernetic systems, you're going to find scenarios where you get inputs that you're gonna want to spend a little more time thinking about.

You're gonna find inputs that are not, it's not clear what you should do, right?

So then the software has a varying amount of runtime and correctness with regard to input.

And that is a different kind of system altogether.

It's a next generation information system that is not like traditional software systems.

Can you maybe describe what is a cybernetic system?

So is it, is it human in the loop kind of complex mess of the whole kind of interactivity of software with the real world, or is it something more concrete?

Well, When I say cybernetic, I really do mean that the software itself is closing the observe, orient, decide, act loop by itself.

So humans being out of the loop is the fact what for me makes it a cybernetic system.

When humans are out of the loop, when the machine is actually sort of deciding on its own what it should do next to get more information, that makes it a cybernetic system.

So we're just at the dawn of this, right?

I think everyone talking about MLAI, it's great, But really the thing we should be talking about is when we really enter the cybernetic era, and all of the questions of ethics and governance and correctness and all these things, they really are the most important questions.

What does it mean for the human to be out of the loop in a cybernetic system because isn't the cybernetic system that's ultimately accomplishing some kind of purpose that at the bottom, you know, the turtles all the way down at the bottom turtle is a human.

It's somehow- Well, the human may have set some criteria, but the human wasn't precise.

So for instance, I just read the other day that earlier this year, or maybe it was last year at some point, the Libyan army, I think, sent out some automated killer drones with explosives.

And there was no human in the loop at that point.

They basically put them in a geo-fenced area, said find any moving target, like a truck or vehicle that looks like this and boom.

So increasingly the less human there is in the loop, the more concerned you are about these kinds of systems because there's unintended consequences, like less the original designer and engineer of the system is able to predict, even 1 with good intent is able to predict the consequences of such a system.

There are some software systems, right, that run without humans in the loop that are quite complex.

We get in the heyday of high-frequency trading, there's a lot of market microstructure, people doing all sorts of weird stuff that the market designers had never really thought about, contemplated or intended.

So when we run these full-on systems with these automated trading bots, now they become automated, you know, killer drones, and then all sorts of other stuff.

That's what I mean by we're at the dawn of the cybernetic era, and the end of the era of just pure software.

Are you more concerned, if you're thinking about cybernetic systems or even like self-replicating systems, so systems that aren't just doing a particular task but are able to sort of multiply and scale in some dimension in the digital or even the physical world.

Are you more concerned about like the lobster being boiled?

So a gradual with us not noticing collapse of civilization or a big explosion?

Like, oops, kind of a big thing where everyone notices but it's too late.

I think that it will be a different experience for different people.

I do share a common point of view with some of the climate, you know, people who are concerned about climate change and just the big existential risks that we have.

But Unlike a lot of people who share my level of concern, I think the collapse will not be quite so dramatic as some of them think.

What I mean is that I think that for certain tiers of, let's say, economic class or certain locations in the world, people will experience dramatic collapse scenarios.

But for a lot of people, especially in the developed world, the realities of collapse will be managed.

There will be narrative management around it so that they essentially insulate, the middle class will be used to insulate the upper class from the pitchforks and the flaming torches and everything.

It's interesting, because my specific question wasn't as general.

My question is more about cybernetic systems or software.

It's interesting, but it would nevertheless perhaps be about class.

So the effect of algorithms might affect certain classes more than others.

I was more thinking about whether it's social media algorithms or actual robots, is there going to be a gradual effect on us where we wake up 1 day and don't recognize the humans we are?

Or is it something truly dramatic where there's like a meltdown of a nuclear reactor kind of thing, Chernobyl, catastrophic events that are almost bugs in a program that scaled itself too quickly?

Yeah, I'm not as concerned about the visible stuff.

And the reason is because the big visible explosions, I mean, this is the thing I said about social media is that, you know, at least with nuclear weapons, when a nuke goes off, you can see it and you're like, well, that's really, wow.

I mean, Oppenheimer was reciting the Bhagavad Gita, right?

He's not reciting anything about Twitter.

Well, but right, but then when you have social media, when you have all these different things that conspire to create a layer of virtual experience for people that alienates them from reality and from each other, that's very pernicious.

You've written about this idea of virtuality on

this topic, which you define as the subjective phenomenon of knowingly engaging with virtual sensation and perception and suspending or forgetting the context that it's a simulacrum.

See all Lex Fridman transcripts on Youtube

Peter Wang: Python and the Source Code of Humans, Computers, and Reality | Lex Fridman Podcast #250