diff --git "a/vtt/episode_021_small.vtt" "b/vtt/episode_021_small.vtt"
new file mode 100644--- /dev/null
+++ "b/vtt/episode_021_small.vtt"
@@ -0,0 +1,5168 @@
+WEBVTT
+
+00:00.000 --> 00:02.680
+ The following is a conversation with Chris Latner.
+
+00:02.680 --> 00:05.680
+ Currently, he's a senior director of Google working
+
+00:05.680 --> 00:09.560
+ on several projects, including CPU, GPU, TPU accelerators
+
+00:09.560 --> 00:12.080
+ for TensorFlow, Swift for TensorFlow,
+
+00:12.080 --> 00:14.400
+ and all kinds of machine learning compiler magic
+
+00:14.400 --> 00:16.360
+ going on behind the scenes.
+
+00:16.360 --> 00:18.440
+ He's one of the top experts in the world
+
+00:18.440 --> 00:20.640
+ on compiler technologies, which means
+
+00:20.640 --> 00:23.960
+ he deeply understands the intricacies of how
+
+00:23.960 --> 00:26.280
+ hardware and software come together
+
+00:26.280 --> 00:27.960
+ to create efficient code.
+
+00:27.960 --> 00:31.480
+ He created the LLVM compiler infrastructure project
+
+00:31.480 --> 00:33.400
+ and the Clang compiler.
+
+00:33.400 --> 00:36.040
+ He led major engineering efforts at Apple,
+
+00:36.040 --> 00:39.040
+ including the creation of the Swift programming language.
+
+00:39.040 --> 00:42.600
+ He also briefly spent time at Tesla as vice president
+
+00:42.600 --> 00:45.920
+ of autopilot software during the transition from autopilot
+
+00:45.920 --> 00:49.640
+ hardware one to hardware two, when Tesla essentially
+
+00:49.640 --> 00:52.640
+ started from scratch to build an in house software
+
+00:52.640 --> 00:54.880
+ infrastructure for autopilot.
+
+00:54.880 --> 00:58.040
+ I could have easily talked to Chris for many more hours.
+
+00:58.040 --> 01:01.240
+ Compiling code down across the level's abstraction
+
+01:01.240 --> 01:04.120
+ is one of the most fundamental and fascinating aspects
+
+01:04.120 --> 01:07.160
+ of what computers do, and he is one of the world experts
+
+01:07.160 --> 01:08.640
+ in this process.
+
+01:08.640 --> 01:12.920
+ It's rigorous science, and it's messy, beautiful art.
+
+01:12.920 --> 01:15.920
+ This conversation is part of the Artificial Intelligence
+
+01:15.920 --> 01:16.760
+ podcast.
+
+01:16.760 --> 01:18.920
+ If you enjoy it, subscribe on YouTube,
+
+01:18.920 --> 01:21.560
+ iTunes, or simply connect with me on Twitter
+
+01:21.560 --> 01:25.760
+ at Lex Friedman, spelled F R I D. And now, here's
+
+01:25.760 --> 01:29.400
+ my conversation with Chris Ladner.
+
+01:29.400 --> 01:33.240
+ What was the first program you've ever written?
+
+01:33.240 --> 01:34.680
+ My first program back.
+
+01:34.680 --> 01:35.400
+ And when was it?
+
+01:35.400 --> 01:39.160
+ I think I started as a kid, and my parents
+
+01:39.160 --> 01:41.640
+ got a basic programming book.
+
+01:41.640 --> 01:45.400
+ And so when I started, it was typing out programs from a book
+
+01:45.400 --> 01:49.320
+ and seeing how they worked, and then typing them in wrong
+
+01:49.320 --> 01:51.600
+ and trying to figure out why they were not working right,
+
+01:51.600 --> 01:52.960
+ and that kind of stuff.
+
+01:52.960 --> 01:54.880
+ So basic, what was the first language
+
+01:54.880 --> 01:58.360
+ that you remember yourself maybe falling in love with,
+
+01:58.360 --> 01:59.960
+ like really connecting with?
+
+01:59.960 --> 02:00.480
+ I don't know.
+
+02:00.480 --> 02:02.480
+ I mean, I feel like I've learned a lot along the way,
+
+02:02.480 --> 02:06.720
+ and each of them have a different, special thing about them.
+
+02:06.720 --> 02:09.880
+ So I started in basic, and then went like GW basic, which
+
+02:09.880 --> 02:11.440
+ was the thing back in the DOS days,
+
+02:11.440 --> 02:15.320
+ and then upgraded to Q basic, and eventually Quick basic,
+
+02:15.320 --> 02:17.760
+ which are all slightly more fancy versions
+
+02:17.760 --> 02:20.920
+ of Microsoft basic, made the jump to Pascal,
+
+02:20.920 --> 02:23.960
+ and started doing machine language programming and assembly
+
+02:23.960 --> 02:25.280
+ in Pascal, which was really cool.
+
+02:25.280 --> 02:28.120
+ Turbo Pascal was amazing for its day.
+
+02:28.120 --> 02:31.600
+ Eventually, gone to C, C++, and then kind of did
+
+02:31.600 --> 02:33.440
+ lots of other weird things.
+
+02:33.440 --> 02:36.640
+ I feel like you took the dark path, which is the,
+
+02:36.640 --> 02:41.520
+ you could have gone Lisp, you could have gone a higher level
+
+02:41.520 --> 02:44.600
+ sort of functional, philosophical, hippie route.
+
+02:44.600 --> 02:48.040
+ Instead, you went into like the dark arts of the C.
+
+02:48.040 --> 02:49.720
+ It was straight into the machine.
+
+02:49.720 --> 02:50.680
+ Straight into the machine.
+
+02:50.680 --> 02:53.880
+ So started with basic Pascal and then assembly,
+
+02:53.880 --> 02:58.120
+ and then wrote a lot of assembly, and eventually did
+
+02:58.120 --> 03:00.120
+ small talk and other things like that,
+
+03:00.120 --> 03:01.920
+ but that was not the starting point.
+
+03:01.920 --> 03:05.080
+ But so what is this journey to see?
+
+03:05.080 --> 03:06.360
+ Is that in high school?
+
+03:06.360 --> 03:07.560
+ Is that in college?
+
+03:07.560 --> 03:08.800
+ That was in high school, yeah.
+
+03:08.800 --> 03:13.760
+ So, and then that was really about trying
+
+03:13.760 --> 03:16.120
+ to be able to do more powerful things than what Pascal
+
+03:16.120 --> 03:18.920
+ could do and also to learn a different world.
+
+03:18.920 --> 03:20.720
+ So he was really confusing to me with pointers
+
+03:20.720 --> 03:22.800
+ and the syntax and everything, and it took a while,
+
+03:22.800 --> 03:28.720
+ but Pascal's much more principled in various ways,
+
+03:28.720 --> 03:33.360
+ sees more, I mean, it has its historical roots,
+
+03:33.360 --> 03:35.440
+ but it's not as easy to learn.
+
+03:35.440 --> 03:39.840
+ With pointers, there's this memory management thing
+
+03:39.840 --> 03:41.640
+ that you have to become conscious of.
+
+03:41.640 --> 03:43.880
+ Is that the first time you start to understand
+
+03:43.880 --> 03:46.480
+ that there's resources that you're supposed to manage?
+
+03:46.480 --> 03:48.480
+ Well, so you have that in Pascal as well,
+
+03:48.480 --> 03:51.920
+ but in Pascal, the carrot instead of the star,
+
+03:51.920 --> 03:53.160
+ there's some small differences like that,
+
+03:53.160 --> 03:55.640
+ but it's not about pointer arithmetic.
+
+03:55.640 --> 03:58.920
+ And see, you end up thinking about how things get laid
+
+03:58.920 --> 04:00.800
+ out in memory a lot more.
+
+04:00.800 --> 04:04.160
+ And so in Pascal, you have allocating and deallocating
+
+04:04.160 --> 04:07.520
+ and owning the memory, but just the programs are simpler
+
+04:07.520 --> 04:10.880
+ and you don't have to, well, for example,
+
+04:10.880 --> 04:12.600
+ Pascal has a string type.
+
+04:12.600 --> 04:14.040
+ And so you can think about a string
+
+04:14.040 --> 04:15.880
+ instead of an array of characters
+
+04:15.880 --> 04:17.680
+ which are consecutive in memory.
+
+04:17.680 --> 04:20.360
+ So it's a little bit of a higher level abstraction.
+
+04:20.360 --> 04:22.760
+ So let's get into it.
+
+04:22.760 --> 04:25.600
+ Let's talk about LLVM, Selang, and compilers.
+
+04:25.600 --> 04:26.520
+ Sure.
+
+04:26.520 --> 04:31.520
+ So can you tell me first what LLVM and Selang are,
+
+04:32.120 --> 04:34.560
+ and how is it that you find yourself the creator
+
+04:34.560 --> 04:37.720
+ and lead developer, one of the most powerful
+
+04:37.720 --> 04:40.080
+ compiler optimization systems in use today?
+
+04:40.080 --> 04:43.240
+ Sure, so I guess they're different things.
+
+04:43.240 --> 04:47.040
+ So let's start with what is a compiler?
+
+04:47.040 --> 04:48.840
+ Is that a good place to start?
+
+04:48.840 --> 04:50.200
+ What are the phases of a compiler?
+
+04:50.200 --> 04:51.040
+ Where are the parts?
+
+04:51.040 --> 04:51.880
+ Yeah, what is it?
+
+04:51.880 --> 04:53.400
+ So what is even a compiler used for?
+
+04:53.400 --> 04:57.560
+ So the way I look at this is you have a two sided problem
+
+04:57.560 --> 05:00.440
+ of you have humans that need to write code.
+
+05:00.440 --> 05:02.360
+ And then you have machines that need to run the program
+
+05:02.360 --> 05:03.360
+ that the human wrote.
+
+05:03.360 --> 05:05.720
+ And for lots of reasons, the humans don't want to be
+
+05:05.720 --> 05:08.320
+ writing in binary and want to think about every piece
+
+05:08.320 --> 05:09.160
+ of hardware.
+
+05:09.160 --> 05:12.080
+ So at the same time that you have lots of humans,
+
+05:12.080 --> 05:14.760
+ you also have lots of kinds of hardware.
+
+05:14.760 --> 05:17.760
+ And so compilers are the art of allowing humans
+
+05:17.760 --> 05:19.200
+ to think at a level of abstraction
+
+05:19.200 --> 05:20.880
+ that they want to think about.
+
+05:20.880 --> 05:23.600
+ And then get that program, get the thing that they wrote
+
+05:23.600 --> 05:26.040
+ to run on a specific piece of hardware.
+
+05:26.040 --> 05:29.480
+ And the interesting and exciting part of all this
+
+05:29.480 --> 05:31.960
+ is that there's now lots of different kinds of hardware,
+
+05:31.960 --> 05:35.880
+ chips like x86 and PowerPC and ARM and things like that,
+
+05:35.880 --> 05:37.720
+ but also high performance accelerators for machine
+
+05:37.720 --> 05:39.920
+ learning and other things like that are also just different
+
+05:39.920 --> 05:42.880
+ kinds of hardware, GPUs, these are new kinds of hardware.
+
+05:42.880 --> 05:45.600
+ And at the same time on the programming side of it,
+
+05:45.600 --> 05:48.640
+ you have basic, you have C, you have JavaScript,
+
+05:48.640 --> 05:51.480
+ you have Python, you have Swift, you have like lots
+
+05:51.480 --> 05:54.440
+ of other languages that are all trying to talk to the human
+
+05:54.440 --> 05:57.040
+ in a different way to make them more expressive
+
+05:57.040 --> 05:58.320
+ and capable and powerful.
+
+05:58.320 --> 06:02.080
+ And so compilers are the thing that goes from one
+
+06:02.080 --> 06:03.440
+ to the other now.
+
+06:03.440 --> 06:05.200
+ And to end from the very beginning to the very end.
+
+06:05.200 --> 06:08.120
+ And to end, and so you go from what the human wrote
+
+06:08.120 --> 06:12.600
+ and programming languages end up being about expressing intent,
+
+06:12.600 --> 06:15.960
+ not just for the compiler and the hardware,
+
+06:15.960 --> 06:20.320
+ but the programming language's job is really to capture
+
+06:20.320 --> 06:22.640
+ an expression of what the programmer wanted
+
+06:22.640 --> 06:25.080
+ that then can be maintained and adapted
+
+06:25.080 --> 06:28.240
+ and evolved by other humans, as well as by the,
+
+06:28.240 --> 06:29.680
+ interpreted by the compiler.
+
+06:29.680 --> 06:31.520
+ So when you look at this problem,
+
+06:31.520 --> 06:34.160
+ you have on the one hand humans, which are complicated,
+
+06:34.160 --> 06:36.720
+ you have hardware, which is complicated.
+
+06:36.720 --> 06:39.880
+ And so compilers typically work in multiple phases.
+
+06:39.880 --> 06:42.720
+ And so the software engineering challenge
+
+06:42.720 --> 06:44.960
+ that you have here is try to get maximum reuse
+
+06:44.960 --> 06:47.080
+ out of the amount of code that you write
+
+06:47.080 --> 06:49.720
+ because these compilers are very complicated.
+
+06:49.720 --> 06:51.840
+ And so the way it typically works out is that
+
+06:51.840 --> 06:54.440
+ you have something called a front end or a parser
+
+06:54.440 --> 06:56.600
+ that is language specific.
+
+06:56.600 --> 06:59.440
+ And so you'll have a C parser, that's what Clang is,
+
+07:00.360 --> 07:03.440
+ or C++ or JavaScript or Python or whatever,
+
+07:03.440 --> 07:04.960
+ that's the front end.
+
+07:04.960 --> 07:07.080
+ Then you'll have a middle part,
+
+07:07.080 --> 07:09.000
+ which is often the optimizer.
+
+07:09.000 --> 07:11.120
+ And then you'll have a late part,
+
+07:11.120 --> 07:13.320
+ which is hardware specific.
+
+07:13.320 --> 07:16.680
+ And so compilers end up, there's many different layers often,
+
+07:16.680 --> 07:20.880
+ but these three big groups are very common in compilers.
+
+07:20.880 --> 07:23.440
+ And what LLVM is trying to do is trying to standardize
+
+07:23.440 --> 07:25.360
+ that middle and last part.
+
+07:25.360 --> 07:27.880
+ And so one of the cool things about LLVM
+
+07:27.880 --> 07:29.760
+ is that there are a lot of different languages
+
+07:29.760 --> 07:31.080
+ that compile through to it.
+
+07:31.080 --> 07:35.640
+ And so things like Swift, but also Julia, Rust,
+
+07:36.520 --> 07:39.120
+ Clang for C, C++, Subjective C,
+
+07:39.120 --> 07:40.920
+ like these are all very different languages
+
+07:40.920 --> 07:43.800
+ and they can all use the same optimization infrastructure,
+
+07:43.800 --> 07:45.400
+ which gets better performance,
+
+07:45.400 --> 07:47.240
+ and the same code generation infrastructure
+
+07:47.240 --> 07:48.800
+ for hardware support.
+
+07:48.800 --> 07:52.240
+ And so LLVM is really that layer that is common,
+
+07:52.240 --> 07:55.560
+ that all these different specific compilers can use.
+
+07:55.560 --> 07:59.280
+ And is it a standard, like a specification,
+
+07:59.280 --> 08:01.160
+ or is it literally an implementation?
+
+08:01.160 --> 08:02.120
+ It's an implementation.
+
+08:02.120 --> 08:05.880
+ And so it's, I think there's a couple of different ways
+
+08:05.880 --> 08:06.720
+ of looking at it, right?
+
+08:06.720 --> 08:09.680
+ Because it depends on which angle you're looking at it from.
+
+08:09.680 --> 08:12.600
+ LLVM ends up being a bunch of code, okay?
+
+08:12.600 --> 08:14.440
+ So it's a bunch of code that people reuse
+
+08:14.440 --> 08:16.520
+ and they build compilers with.
+
+08:16.520 --> 08:18.040
+ We call it a compiler infrastructure
+
+08:18.040 --> 08:20.000
+ because it's kind of the underlying platform
+
+08:20.000 --> 08:22.520
+ that you build a concrete compiler on top of.
+
+08:22.520 --> 08:23.680
+ But it's also a community.
+
+08:23.680 --> 08:26.800
+ And the LLVM community is hundreds of people
+
+08:26.800 --> 08:27.920
+ that all collaborate.
+
+08:27.920 --> 08:30.560
+ And one of the most fascinating things about LLVM
+
+08:30.560 --> 08:34.280
+ over the course of time is that we've managed somehow
+
+08:34.280 --> 08:37.080
+ to successfully get harsh competitors
+
+08:37.080 --> 08:39.080
+ in the commercial space to collaborate
+
+08:39.080 --> 08:41.120
+ on shared infrastructure.
+
+08:41.120 --> 08:43.880
+ And so you have Google and Apple.
+
+08:43.880 --> 08:45.880
+ You have AMD and Intel.
+
+08:45.880 --> 08:48.880
+ You have NVIDIA and AMD on the graphics side.
+
+08:48.880 --> 08:52.640
+ You have Cray and everybody else doing these things.
+
+08:52.640 --> 08:55.400
+ And like all these companies are collaborating together
+
+08:55.400 --> 08:57.480
+ to make that shared infrastructure
+
+08:57.480 --> 08:58.520
+ really, really great.
+
+08:58.520 --> 09:01.400
+ And they do this not out of the goodness of their heart
+
+09:01.400 --> 09:03.440
+ but they do it because it's in their commercial interest
+
+09:03.440 --> 09:05.160
+ of having really great infrastructure
+
+09:05.160 --> 09:06.800
+ that they can build on top of.
+
+09:06.800 --> 09:09.120
+ And facing the reality that it's so expensive
+
+09:09.120 --> 09:11.200
+ that no one company, even the big companies,
+
+09:11.200 --> 09:14.600
+ no one company really wants to implement it all themselves.
+
+09:14.600 --> 09:16.120
+ Expensive or difficult?
+
+09:16.120 --> 09:16.960
+ Both.
+
+09:16.960 --> 09:20.600
+ That's a great point because it's also about the skill sets.
+
+09:20.600 --> 09:25.600
+ And these, the skill sets are very hard to find.
+
+09:25.600 --> 09:27.960
+ How big is the LLVM?
+
+09:27.960 --> 09:30.400
+ It always seems like with open source projects,
+
+09:30.400 --> 09:33.480
+ the kind, and LLVM is open source?
+
+09:33.480 --> 09:34.440
+ Yes, it's open source.
+
+09:34.440 --> 09:36.320
+ It's about, it's 19 years old now.
+
+09:36.320 --> 09:38.640
+ So it's fairly old.
+
+09:38.640 --> 09:40.960
+ It seems like the magic often happens
+
+09:40.960 --> 09:43.040
+ within a very small circle of people.
+
+09:43.040 --> 09:43.880
+ Yes.
+
+09:43.880 --> 09:46.080
+ At least at early birth and whatever.
+
+09:46.080 --> 09:46.920
+ Yes.
+
+09:46.920 --> 09:49.640
+ So the LLVM came from a university project.
+
+09:49.640 --> 09:51.640
+ And so I was at the University of Illinois.
+
+09:51.640 --> 09:53.880
+ And there it was myself, my advisor,
+
+09:53.880 --> 09:57.480
+ and then a team of two or three research students
+
+09:57.480 --> 09:58.360
+ in the research group.
+
+09:58.360 --> 10:02.080
+ And we built many of the core pieces initially.
+
+10:02.080 --> 10:03.720
+ I then graduated and went to Apple.
+
+10:03.720 --> 10:06.480
+ And then Apple brought it to the products,
+
+10:06.480 --> 10:09.320
+ first in the OpenGL graphics stack,
+
+10:09.320 --> 10:11.600
+ but eventually to the C compiler realm
+
+10:11.600 --> 10:12.760
+ and eventually built Clang
+
+10:12.760 --> 10:14.640
+ and eventually built Swift and these things.
+
+10:14.640 --> 10:16.360
+ Along the way, building a team of people
+
+10:16.360 --> 10:18.600
+ that are really amazing compiler engineers
+
+10:18.600 --> 10:20.120
+ that helped build a lot of that.
+
+10:20.120 --> 10:21.840
+ And so as it was gaining momentum
+
+10:21.840 --> 10:24.800
+ and as Apple was using it, being open source and public
+
+10:24.800 --> 10:27.040
+ and encouraging contribution, many others,
+
+10:27.040 --> 10:30.400
+ for example, at Google, came in and started contributing.
+
+10:30.400 --> 10:33.680
+ And in some cases, Google effectively owns Clang now
+
+10:33.680 --> 10:35.520
+ because it cares so much about C++
+
+10:35.520 --> 10:37.280
+ and the evolution of that ecosystem.
+
+10:37.280 --> 10:41.400
+ And so it's investing a lot in the C++ world
+
+10:41.400 --> 10:42.960
+ and the tooling and things like that.
+
+10:42.960 --> 10:47.840
+ And so likewise, NVIDIA cares a lot about CUDA.
+
+10:47.840 --> 10:52.840
+ And so CUDA uses Clang and uses LVM for graphics and GPGPU.
+
+10:54.960 --> 10:59.880
+ And so when you first started as a master's project, I guess,
+
+10:59.880 --> 11:02.920
+ did you think it was gonna go as far as it went?
+
+11:02.920 --> 11:06.280
+ Were you crazy ambitious about it?
+
+11:06.280 --> 11:07.120
+ No.
+
+11:07.120 --> 11:09.760
+ It seems like a really difficult undertaking, a brave one.
+
+11:09.760 --> 11:11.280
+ Yeah, no, no, it was nothing like that.
+
+11:11.280 --> 11:13.640
+ So I mean, my goal when I went to University of Illinois
+
+11:13.640 --> 11:16.120
+ was to get in and out with the non thesis masters
+
+11:16.120 --> 11:18.680
+ in a year and get back to work.
+
+11:18.680 --> 11:22.160
+ So I was not planning to stay for five years
+
+11:22.160 --> 11:24.440
+ and build this massive infrastructure.
+
+11:24.440 --> 11:27.400
+ I got nerd sniped into staying.
+
+11:27.400 --> 11:29.480
+ And a lot of it was because LVM was fun
+
+11:29.480 --> 11:30.920
+ and I was building cool stuff
+
+11:30.920 --> 11:33.400
+ and learning really interesting things
+
+11:33.400 --> 11:36.880
+ and facing both software engineering challenges
+
+11:36.880 --> 11:38.520
+ but also learning how to work in a team
+
+11:38.520 --> 11:40.120
+ and things like that.
+
+11:40.120 --> 11:43.600
+ I had worked at many companies as interns before that,
+
+11:43.600 --> 11:45.840
+ but it was really a different thing
+
+11:45.840 --> 11:48.120
+ to have a team of people that were working together
+
+11:48.120 --> 11:50.480
+ and trying to collaborate in version control
+
+11:50.480 --> 11:52.400
+ and it was just a little bit different.
+
+11:52.400 --> 11:54.080
+ Like I said, I just talked to Don Knuth
+
+11:54.080 --> 11:56.840
+ and he believes that 2% of the world population
+
+11:56.840 --> 11:59.600
+ have something weird with their brain, that they're geeks,
+
+11:59.600 --> 12:02.560
+ they understand computers, they're connected with computers.
+
+12:02.560 --> 12:04.360
+ He put it at exactly 2%.
+
+12:04.360 --> 12:05.560
+ Okay, so...
+
+12:05.560 --> 12:06.560
+ Is this a specific act?
+
+12:06.560 --> 12:08.760
+ It's very specific.
+
+12:08.760 --> 12:10.200
+ Well, he says, I can't prove it,
+
+12:10.200 --> 12:11.800
+ but it's very empirically there.
+
+12:13.040 --> 12:14.480
+ Is there something that attracts you
+
+12:14.480 --> 12:16.920
+ to the idea of optimizing code?
+
+12:16.920 --> 12:19.120
+ And he seems like that's one of the biggest,
+
+12:19.120 --> 12:20.920
+ coolest things about LVM.
+
+12:20.920 --> 12:22.480
+ Yeah, that's one of the major things it does.
+
+12:22.480 --> 12:26.440
+ So I got into that because of a person, actually.
+
+12:26.440 --> 12:28.200
+ So when I was in my undergraduate,
+
+12:28.200 --> 12:32.040
+ I had an advisor or a professor named Steve Vegdahl
+
+12:32.040 --> 12:35.760
+ and I went to this little tiny private school.
+
+12:35.760 --> 12:38.280
+ There were like seven or nine people
+
+12:38.280 --> 12:40.320
+ in my computer science department,
+
+12:40.320 --> 12:43.080
+ students in my class.
+
+12:43.080 --> 12:47.440
+ So it was a very tiny, very small school.
+
+12:47.440 --> 12:49.960
+ It was kind of a work on the side of the math department
+
+12:49.960 --> 12:51.240
+ kind of a thing at the time.
+
+12:51.240 --> 12:53.800
+ I think it's evolved a lot in the many years since then,
+
+12:53.800 --> 12:58.280
+ but Steve Vegdahl was a compiler guy
+
+12:58.280 --> 12:59.600
+ and he was super passionate
+
+12:59.600 --> 13:02.720
+ and his passion rubbed off on me
+
+13:02.720 --> 13:04.440
+ and one of the things I like about compilers
+
+13:04.440 --> 13:09.120
+ is that they're large, complicated software pieces.
+
+13:09.120 --> 13:12.920
+ And so one of the culminating classes
+
+13:12.920 --> 13:14.520
+ that many computer science departments
+
+13:14.520 --> 13:16.680
+ at least at the time did was to say
+
+13:16.680 --> 13:18.400
+ that you would take algorithms and data structures
+
+13:18.400 --> 13:19.480
+ and all these core classes,
+
+13:19.480 --> 13:20.720
+ but then the compilers class
+
+13:20.720 --> 13:22.160
+ was one of the last classes you take
+
+13:22.160 --> 13:24.360
+ because it pulls everything together
+
+13:24.360 --> 13:27.000
+ and then you work on one piece of code
+
+13:27.000 --> 13:28.680
+ over the entire semester.
+
+13:28.680 --> 13:32.080
+ And so you keep building on your own work,
+
+13:32.080 --> 13:34.800
+ which is really interesting and it's also very challenging
+
+13:34.800 --> 13:37.520
+ because in many classes, if you don't get a project done,
+
+13:37.520 --> 13:39.320
+ you just forget about it and move on to the next one
+
+13:39.320 --> 13:41.320
+ and get your B or whatever it is,
+
+13:41.320 --> 13:43.880
+ but here you have to live with the decisions you make
+
+13:43.880 --> 13:45.280
+ and continue to reinvest in it.
+
+13:45.280 --> 13:46.880
+ And I really like that.
+
+13:46.880 --> 13:51.080
+ And so I did a extra study project with him
+
+13:51.080 --> 13:53.960
+ the following semester and he was just really great
+
+13:53.960 --> 13:56.920
+ and he was also a great mentor in a lot of ways.
+
+13:56.920 --> 13:59.560
+ And so from him and from his advice,
+
+13:59.560 --> 14:01.520
+ he encouraged me to go to graduate school.
+
+14:01.520 --> 14:03.200
+ I wasn't super excited about going to grad school.
+
+14:03.200 --> 14:05.240
+ I wanted the master's degree,
+
+14:05.240 --> 14:07.440
+ but I didn't want to be an academic.
+
+14:09.000 --> 14:11.160
+ But like I said, I kind of got tricked into saying
+
+14:11.160 --> 14:14.560
+ I was having a lot of fun and I definitely do not regret it.
+
+14:14.560 --> 14:15.840
+ Well, the aspects of compilers
+
+14:15.840 --> 14:17.960
+ were the things you connected with.
+
+14:17.960 --> 14:22.120
+ So LVM, there's also the other part
+
+14:22.120 --> 14:23.440
+ that's just really interesting
+
+14:23.440 --> 14:27.640
+ if you're interested in languages is parsing and just analyzing
+
+14:27.640 --> 14:29.640
+ like, yeah, analyzing the language,
+
+14:29.640 --> 14:31.240
+ breaking it down, parsing and so on.
+
+14:31.240 --> 14:32.280
+ Was that interesting to you
+
+14:32.280 --> 14:34.080
+ or were you more interested in optimization?
+
+14:34.080 --> 14:37.400
+ For me, it was more, so I'm not really a math person.
+
+14:37.400 --> 14:39.600
+ I can do math, I understand some bits of it
+
+14:39.600 --> 14:41.600
+ when I get into it,
+
+14:41.600 --> 14:43.960
+ but math is never the thing that attracted me.
+
+14:43.960 --> 14:46.160
+ And so a lot of the parser part of the compiler
+
+14:46.160 --> 14:48.960
+ has a lot of good formal theories that Dawn, for example,
+
+14:48.960 --> 14:50.440
+ knows quite well.
+
+14:50.440 --> 14:51.920
+ Still waiting for his book on that.
+
+14:51.920 --> 14:56.080
+ But I just like building a thing
+
+14:56.080 --> 14:59.200
+ and seeing what it could do and exploring
+
+14:59.200 --> 15:00.800
+ and getting it to do more things
+
+15:00.800 --> 15:02.880
+ and then setting new goals and reaching for them.
+
+15:02.880 --> 15:08.880
+ And in the case of LVM, when I started working on that,
+
+15:08.880 --> 15:13.360
+ my research advisor that I was working for was a compiler guy.
+
+15:13.360 --> 15:15.600
+ And so he and I specifically found each other
+
+15:15.600 --> 15:16.920
+ because we both interested in compilers
+
+15:16.920 --> 15:19.480
+ and so I started working with them and taking his class.
+
+15:19.480 --> 15:21.800
+ And a lot of LVM initially was it's fun
+
+15:21.800 --> 15:23.560
+ implementing all the standard algorithms
+
+15:23.560 --> 15:26.360
+ and all the things that people had been talking about
+
+15:26.360 --> 15:28.920
+ and were well known and they were in the curricula
+
+15:28.920 --> 15:31.320
+ for advanced studies in compilers.
+
+15:31.320 --> 15:34.560
+ And so just being able to build that was really fun
+
+15:34.560 --> 15:36.160
+ and I was learning a lot
+
+15:36.160 --> 15:38.640
+ by instead of reading about it, just building.
+
+15:38.640 --> 15:40.200
+ And so I enjoyed that.
+
+15:40.200 --> 15:42.800
+ So you said compilers are these complicated systems.
+
+15:42.800 --> 15:47.240
+ Can you even just with language try to describe
+
+15:48.240 --> 15:52.240
+ how you turn a C++ program into code?
+
+15:52.240 --> 15:53.480
+ Like what are the hard parts?
+
+15:53.480 --> 15:54.640
+ Why is it so hard?
+
+15:54.640 --> 15:56.840
+ So I'll give you examples of the hard parts along the way.
+
+15:56.840 --> 16:01.040
+ So C++ is a very complicated programming language.
+
+16:01.040 --> 16:03.480
+ It's something like 1,400 pages in the spec.
+
+16:03.480 --> 16:06.120
+ So C++ by itself is crazy complicated.
+
+16:06.120 --> 16:07.160
+ Can we just, sorry, pause.
+
+16:07.160 --> 16:08.720
+ What makes the language complicated
+
+16:08.720 --> 16:11.520
+ in terms of what's syntactically?
+
+16:11.520 --> 16:14.320
+ Like, so it's what they call syntax.
+
+16:14.320 --> 16:16.280
+ So the actual how the characters are arranged.
+
+16:16.280 --> 16:20.080
+ Yes, it's also semantics, how it behaves.
+
+16:20.080 --> 16:21.720
+ It's also in the case of C++.
+
+16:21.720 --> 16:23.400
+ There's a huge amount of history.
+
+16:23.400 --> 16:25.560
+ C++ build on top of C.
+
+16:25.560 --> 16:28.720
+ You play that forward and then a bunch of suboptimal
+
+16:28.720 --> 16:30.360
+ in some cases decisions were made
+
+16:30.360 --> 16:33.400
+ and they compound and then more and more and more things
+
+16:33.400 --> 16:35.080
+ keep getting added to C++
+
+16:35.080 --> 16:37.040
+ and it will probably never stop.
+
+16:37.040 --> 16:39.440
+ But the language is very complicated from that perspective.
+
+16:39.440 --> 16:41.200
+ And so the interactions between subsystems
+
+16:41.200 --> 16:42.360
+ is very complicated.
+
+16:42.360 --> 16:43.560
+ There's just a lot there.
+
+16:43.560 --> 16:45.640
+ And when you talk about the front end,
+
+16:45.640 --> 16:48.560
+ one of the major challenges which playing as a project,
+
+16:48.560 --> 16:52.280
+ the C++ compiler that I built, I and many people built.
+
+16:53.320 --> 16:57.560
+ One of the challenges we took on was we looked at GCC.
+
+16:57.560 --> 17:01.120
+ I think GCC at the time was like a really good
+
+17:01.120 --> 17:05.320
+ industry standardized compiler that had really consolidated
+
+17:05.320 --> 17:06.760
+ a lot of the other compilers in the world
+
+17:06.760 --> 17:08.360
+ and was a standard.
+
+17:08.360 --> 17:10.640
+ But it wasn't really great for research.
+
+17:10.640 --> 17:12.600
+ The design was very difficult to work with
+
+17:12.600 --> 17:16.640
+ and it was full of global variables and other things
+
+17:16.640 --> 17:18.120
+ that made it very difficult to reuse
+
+17:18.120 --> 17:20.400
+ in ways that it wasn't originally designed for.
+
+17:20.400 --> 17:22.560
+ And so with Clang, one of the things that we wanted to do
+
+17:22.560 --> 17:25.520
+ is push forward on better user interface.
+
+17:25.520 --> 17:28.160
+ So make error messages that are just better than GCCs.
+
+17:28.160 --> 17:29.920
+ And that's actually hard because you have to do
+
+17:29.920 --> 17:31.880
+ a lot of bookkeeping in an efficient way
+
+17:32.800 --> 17:33.640
+ to be able to do that.
+
+17:33.640 --> 17:35.160
+ We want to make compile time better.
+
+17:35.160 --> 17:37.520
+ And so compile time is about making it efficient,
+
+17:37.520 --> 17:38.920
+ which is also really hard when you're keeping
+
+17:38.920 --> 17:40.520
+ track of extra information.
+
+17:40.520 --> 17:43.400
+ We wanted to make new tools available.
+
+17:43.400 --> 17:46.400
+ So refactoring tools and other analysis tools
+
+17:46.400 --> 17:48.400
+ that the GCC never supported,
+
+17:48.400 --> 17:51.160
+ also leveraging the extra information we kept,
+
+17:52.200 --> 17:54.080
+ but enabling those new classes of tools
+
+17:54.080 --> 17:55.960
+ that then get built into IDEs.
+
+17:55.960 --> 17:58.560
+ And so that's been one of the areas
+
+17:58.560 --> 18:01.320
+ that Clang has really helped push the world forward in
+
+18:01.320 --> 18:05.080
+ is in the tooling for C and C++ and things like that.
+
+18:05.080 --> 18:07.760
+ But C++ in the front end piece is complicated
+
+18:07.760 --> 18:09.040
+ and you have to build syntax trees
+
+18:09.040 --> 18:11.360
+ and you have to check every rule in the spec
+
+18:11.360 --> 18:14.000
+ and you have to turn that back into an error message
+
+18:14.000 --> 18:16.040
+ to the human that the human can understand
+
+18:16.040 --> 18:17.840
+ when they do something wrong.
+
+18:17.840 --> 18:20.760
+ But then you start doing what's called lowering.
+
+18:20.760 --> 18:23.440
+ So going from C++ in the way that it represents code
+
+18:23.440 --> 18:24.960
+ down to the machine.
+
+18:24.960 --> 18:25.800
+ And when you do that,
+
+18:25.800 --> 18:28.240
+ there's many different phases you go through.
+
+18:29.640 --> 18:33.040
+ Often there are, I think LVM has something like 150
+
+18:33.040 --> 18:36.240
+ different, what are called passes in the compiler
+
+18:36.240 --> 18:38.760
+ that the code passes through
+
+18:38.760 --> 18:41.880
+ and these get organized in very complicated ways,
+
+18:41.880 --> 18:44.360
+ which affect the generated code and the performance
+
+18:44.360 --> 18:46.000
+ and compile time and many of the things.
+
+18:46.000 --> 18:47.320
+ What are they passing through?
+
+18:47.320 --> 18:51.840
+ So after you do the Clang parsing,
+
+18:51.840 --> 18:53.960
+ what's the graph?
+
+18:53.960 --> 18:54.800
+ What does it look like?
+
+18:54.800 --> 18:55.960
+ What's the data structure here?
+
+18:55.960 --> 18:59.040
+ Yeah, so in the parser, it's usually a tree
+
+18:59.040 --> 19:01.040
+ and it's called an abstract syntax tree.
+
+19:01.040 --> 19:04.560
+ And so the idea is you have a node for the plus
+
+19:04.560 --> 19:06.800
+ that the human wrote in their code
+
+19:06.800 --> 19:09.000
+ or the function call, you'll have a node for call
+
+19:09.000 --> 19:11.840
+ with the function that they call in the arguments they pass.
+
+19:11.840 --> 19:12.680
+ Things like that.
+
+19:14.440 --> 19:16.840
+ This then gets lowered into what's called
+
+19:16.840 --> 19:18.600
+ an intermediate representation
+
+19:18.600 --> 19:22.080
+ and intermediate representations are like LVM has one.
+
+19:22.080 --> 19:26.920
+ And there it's a, it's what's called a control flow graph.
+
+19:26.920 --> 19:31.200
+ And so you represent each operation in the program
+
+19:31.200 --> 19:34.480
+ as a very simple, like this is gonna add two numbers.
+
+19:34.480 --> 19:35.880
+ This is gonna multiply two things.
+
+19:35.880 --> 19:37.480
+ This maybe we'll do a call,
+
+19:37.480 --> 19:40.280
+ but then they get put in what are called blocks.
+
+19:40.280 --> 19:43.600
+ And so you get blocks of these straight line operations
+
+19:43.600 --> 19:45.320
+ where instead of being nested like in a tree,
+
+19:45.320 --> 19:46.920
+ it's straight line operations.
+
+19:46.920 --> 19:47.920
+ And so there's a sequence
+
+19:47.920 --> 19:49.760
+ in ordering to these operations.
+
+19:49.760 --> 19:51.840
+ So within the block or outside the block?
+
+19:51.840 --> 19:53.240
+ That's within the block.
+
+19:53.240 --> 19:55.000
+ And so it's a straight line sequence of operations
+
+19:55.000 --> 19:55.840
+ within the block.
+
+19:55.840 --> 19:57.520
+ And then you have branches,
+
+19:57.520 --> 20:00.160
+ like conditional branches between blocks.
+
+20:00.160 --> 20:02.760
+ And so when you write a loop, for example,
+
+20:04.120 --> 20:07.080
+ in a syntax tree, you would have a four node
+
+20:07.080 --> 20:09.080
+ like for a four statement in a C like language,
+
+20:09.080 --> 20:10.840
+ you'd have a four node.
+
+20:10.840 --> 20:12.200
+ And you have a pointer to the expression
+
+20:12.200 --> 20:14.120
+ for the initializer, a pointer to the expression
+
+20:14.120 --> 20:15.840
+ for the increment, a pointer to the expression
+
+20:15.840 --> 20:18.720
+ for the comparison, a pointer to the body.
+
+20:18.720 --> 20:21.040
+ Okay, and these are all nested underneath it.
+
+20:21.040 --> 20:22.880
+ In a control flow graph, you get a block
+
+20:22.880 --> 20:25.960
+ for the code that runs before the loop.
+
+20:25.960 --> 20:27.600
+ So the initializer code.
+
+20:27.600 --> 20:30.280
+ Then you have a block for the body of the loop.
+
+20:30.280 --> 20:33.760
+ And so the body of the loop code goes in there,
+
+20:33.760 --> 20:35.520
+ but also the increment and other things like that.
+
+20:35.520 --> 20:37.800
+ And then you have a branch that goes back to the top
+
+20:37.800 --> 20:39.840
+ and a comparison and a branch that goes out.
+
+20:39.840 --> 20:44.000
+ And so it's more of a assembly level kind of representation.
+
+20:44.000 --> 20:46.040
+ But the nice thing about this level of representation
+
+20:46.040 --> 20:48.680
+ is it's much more language independent.
+
+20:48.680 --> 20:51.880
+ And so there's lots of different kinds of languages
+
+20:51.880 --> 20:54.520
+ with different kinds of, you know,
+
+20:54.520 --> 20:56.600
+ JavaScript has a lot of different ideas
+
+20:56.600 --> 20:58.160
+ of what is false, for example,
+
+20:58.160 --> 21:00.760
+ and all that can stay in the front end,
+
+21:00.760 --> 21:04.200
+ but then that middle part can be shared across all of those.
+
+21:04.200 --> 21:07.520
+ How close is that intermediate representation
+
+21:07.520 --> 21:10.280
+ to new networks, for example?
+
+21:10.280 --> 21:14.320
+ Are they, because everything you describe as a kind of
+
+21:14.320 --> 21:16.080
+ a close of a neural network graph,
+
+21:16.080 --> 21:18.920
+ are they neighbors or what?
+
+21:18.920 --> 21:20.960
+ They're quite different in details,
+
+21:20.960 --> 21:22.480
+ but they're very similar in idea.
+
+21:22.480 --> 21:24.000
+ So one of the things that normal networks do
+
+21:24.000 --> 21:26.880
+ is they learn representations for data
+
+21:26.880 --> 21:29.120
+ at different levels of abstraction, right?
+
+21:29.120 --> 21:32.360
+ And then they transform those through layers, right?
+
+21:33.920 --> 21:35.680
+ So the compiler does very similar things,
+
+21:35.680 --> 21:37.120
+ but one of the things the compiler does
+
+21:37.120 --> 21:40.640
+ is it has relatively few different representations.
+
+21:40.640 --> 21:42.480
+ Where a neural network, often as you get deeper,
+
+21:42.480 --> 21:44.800
+ for example, you get many different representations
+
+21:44.800 --> 21:47.400
+ and each, you know, layer or set of ops
+
+21:47.400 --> 21:50.200
+ is transforming between these different representations.
+
+21:50.200 --> 21:53.080
+ In a compiler, often you get one representation
+
+21:53.080 --> 21:55.240
+ and they do many transformations to it.
+
+21:55.240 --> 21:59.520
+ And these transformations are often applied iteratively.
+
+21:59.520 --> 22:02.920
+ And for programmers, they're familiar types of things.
+
+22:02.920 --> 22:06.160
+ For example, trying to find expressions inside of a loop
+
+22:06.160 --> 22:07.320
+ and pulling them out of a loop.
+
+22:07.320 --> 22:08.560
+ So if they execute fairer times
+
+22:08.560 --> 22:10.760
+ or find redundant computation
+
+22:10.760 --> 22:15.360
+ or find constant folding or other simplifications
+
+22:15.360 --> 22:19.040
+ turning, you know, two times X into X shift left by one
+
+22:19.040 --> 22:21.960
+ and things like this are all the examples
+
+22:21.960 --> 22:23.360
+ of the things that happen.
+
+22:23.360 --> 22:26.200
+ But compilers end up getting a lot of theorem proving
+
+22:26.200 --> 22:27.640
+ and other kinds of algorithms
+
+22:27.640 --> 22:29.960
+ that try to find higher level properties of the program
+
+22:29.960 --> 22:32.320
+ that then can be used by the optimizer.
+
+22:32.320 --> 22:35.920
+ Cool, so what's like the biggest bang for the buck
+
+22:35.920 --> 22:37.680
+ with optimization?
+
+22:37.680 --> 22:38.720
+ What's a day?
+
+22:38.720 --> 22:39.560
+ Yeah.
+
+22:39.560 --> 22:40.920
+ Well, no, not even today.
+
+22:40.920 --> 22:42.800
+ At the very beginning, the 80s, I don't know.
+
+22:42.800 --> 22:43.960
+ Yeah, so for the 80s,
+
+22:43.960 --> 22:46.440
+ a lot of it was things like register allocation.
+
+22:46.440 --> 22:51.000
+ So the idea of in a modern, like a microprocessor,
+
+22:51.000 --> 22:52.760
+ what you'll end up having is you'll end up having memory,
+
+22:52.760 --> 22:54.320
+ which is relatively slow.
+
+22:54.320 --> 22:57.080
+ And then you have registers relatively fast,
+
+22:57.080 --> 22:59.920
+ but registers, you don't have very many of them.
+
+22:59.920 --> 23:02.600
+ Okay, and so when you're writing a bunch of code,
+
+23:02.600 --> 23:04.200
+ you're just saying like, compute this,
+
+23:04.200 --> 23:05.520
+ put in temporary variable, compute this,
+
+23:05.520 --> 23:07.800
+ compute this, put in temporary variable,
+
+23:07.800 --> 23:09.760
+ I have a loop, I have some other stuff going on.
+
+23:09.760 --> 23:11.680
+ Well, now you're running on an x86,
+
+23:11.680 --> 23:13.920
+ like a desktop PC or something.
+
+23:13.920 --> 23:16.160
+ Well, it only has, in some cases,
+
+23:16.160 --> 23:18.720
+ some modes, eight registers, right?
+
+23:18.720 --> 23:20.800
+ And so now the compiler has to choose
+
+23:20.800 --> 23:22.800
+ what values get put in what registers,
+
+23:22.800 --> 23:24.840
+ at what points in the program.
+
+23:24.840 --> 23:26.480
+ And this is actually a really big deal.
+
+23:26.480 --> 23:28.560
+ So if you think about, you have a loop,
+
+23:28.560 --> 23:31.640
+ an inner loop that executes millions of times maybe.
+
+23:31.640 --> 23:33.600
+ If you're doing loads and stores inside that loop,
+
+23:33.600 --> 23:34.920
+ then it's gonna be really slow.
+
+23:34.920 --> 23:37.080
+ But if you can somehow fit all the values
+
+23:37.080 --> 23:40.200
+ inside that loop in registers, now it's really fast.
+
+23:40.200 --> 23:43.400
+ And so getting that right requires a lot of work,
+
+23:43.400 --> 23:44.960
+ because there's many different ways to do that.
+
+23:44.960 --> 23:47.000
+ And often what the compiler ends up doing
+
+23:47.000 --> 23:48.880
+ is it ends up thinking about things
+
+23:48.880 --> 23:51.920
+ in a different representation than what the human wrote.
+
+23:51.920 --> 23:53.320
+ All right, you wrote into x.
+
+23:53.320 --> 23:56.800
+ Well, the compiler thinks about that as four different values,
+
+23:56.800 --> 23:58.360
+ each which have different lifetimes
+
+23:58.360 --> 24:00.400
+ across the function that it's in.
+
+24:00.400 --> 24:02.640
+ And each of those could be put in a register
+
+24:02.640 --> 24:05.840
+ or memory or different memory, or maybe in some parts
+
+24:05.840 --> 24:08.760
+ of the code, recompute it instead of stored and reloaded.
+
+24:08.760 --> 24:10.000
+ And there are many of these different kinds
+
+24:10.000 --> 24:11.440
+ of techniques that can be used.
+
+24:11.440 --> 24:14.840
+ So it's adding almost like a time dimension
+
+24:14.840 --> 24:18.320
+ to it's trying to optimize across time.
+
+24:18.320 --> 24:20.360
+ So it's considering when you're programming,
+
+24:20.360 --> 24:21.920
+ you're not thinking in that way.
+
+24:21.920 --> 24:23.200
+ Yeah, absolutely.
+
+24:23.200 --> 24:28.200
+ And so the risk era made things, so risk chips, RISC,
+
+24:28.200 --> 24:33.200
+ RISC, the risk chips as opposed to SISC chips,
+
+24:33.680 --> 24:36.000
+ the risk chips made things more complicated
+
+24:36.000 --> 24:39.720
+ for the compiler because what they ended up doing
+
+24:39.720 --> 24:42.360
+ is ending up adding pipelines to the processor
+
+24:42.360 --> 24:45.000
+ where the processor can do more than one thing at a time.
+
+24:45.000 --> 24:47.600
+ But this means that the order of operations matters a lot.
+
+24:47.600 --> 24:49.720
+ And so one of the classical compiler techniques
+
+24:49.720 --> 24:52.000
+ that you use is called scheduling.
+
+24:52.000 --> 24:54.200
+ And so moving the instructions around
+
+24:54.200 --> 24:57.400
+ so that the processor can like keep its pipelines full
+
+24:57.400 --> 24:59.600
+ instead of stalling and getting blocked.
+
+24:59.600 --> 25:00.960
+ And so there's a lot of things like that
+
+25:00.960 --> 25:03.600
+ that are kind of bread and butter or compiler techniques
+
+25:03.600 --> 25:06.240
+ that have been studied a lot over the course of decades now.
+
+25:06.240 --> 25:08.520
+ But the engineering side of making them real
+
+25:08.520 --> 25:10.680
+ is also still quite hard.
+
+25:10.680 --> 25:12.400
+ And you talk about machine learning,
+
+25:12.400 --> 25:14.400
+ this is a huge opportunity for machine learning
+
+25:14.400 --> 25:16.520
+ because many of these algorithms
+
+25:16.520 --> 25:19.120
+ are full of these like hokey hand rolled heuristics
+
+25:19.120 --> 25:20.880
+ which work well on specific benchmarks
+
+25:20.880 --> 25:23.920
+ that don't generalize and full of magic numbers.
+
+25:23.920 --> 25:26.520
+ And I hear there's some techniques
+
+25:26.520 --> 25:28.000
+ that are good at handling that.
+
+25:28.000 --> 25:29.880
+ So what would be the,
+
+25:29.880 --> 25:33.040
+ if you were to apply machine learning to this,
+
+25:33.040 --> 25:34.720
+ what's the thing you try to optimize?
+
+25:34.720 --> 25:38.080
+ Is it ultimately the running time?
+
+25:38.080 --> 25:39.960
+ Yeah, you can pick your metric
+
+25:39.960 --> 25:42.240
+ and there's running time, there's memory use,
+
+25:42.240 --> 25:44.760
+ there's lots of different things that you can optimize
+
+25:44.760 --> 25:47.200
+ for code size is another one that some people care about
+
+25:47.200 --> 25:48.800
+ in the embedded space.
+
+25:48.800 --> 25:51.680
+ Is this like the thinking into the future
+
+25:51.680 --> 25:55.600
+ or has somebody actually been crazy enough to try
+
+25:55.600 --> 25:59.080
+ to have machine learning based parameter tuning
+
+25:59.080 --> 26:01.040
+ for optimization of compilers?
+
+26:01.040 --> 26:04.840
+ So this is something that is, I would say research right now.
+
+26:04.840 --> 26:06.800
+ There are a lot of research systems
+
+26:06.800 --> 26:09.080
+ that have been applying search in various forms
+
+26:09.080 --> 26:11.440
+ and using reinforcement learning as one form,
+
+26:11.440 --> 26:14.400
+ but also brute force search has been tried for quite a while.
+
+26:14.400 --> 26:18.160
+ And usually these are in small problem spaces.
+
+26:18.160 --> 26:21.480
+ So find the optimal way to code generate
+
+26:21.480 --> 26:23.680
+ a matrix multiply for a GPU, right?
+
+26:23.680 --> 26:25.480
+ Something like that where you say,
+
+26:25.480 --> 26:28.080
+ there there's a lot of design space
+
+26:28.080 --> 26:29.920
+ of do you unroll loops a lot?
+
+26:29.920 --> 26:32.600
+ Do you execute multiple things in parallel?
+
+26:32.600 --> 26:35.320
+ And there's many different confounding factors here
+
+26:35.320 --> 26:38.120
+ because graphics cards have different numbers of threads
+
+26:38.120 --> 26:41.040
+ and registers and execution ports and memory bandwidth
+
+26:41.040 --> 26:42.760
+ and many different constraints to interact
+
+26:42.760 --> 26:44.280
+ in nonlinear ways.
+
+26:44.280 --> 26:46.480
+ And so search is very powerful for that
+
+26:46.480 --> 26:49.840
+ and it gets used in certain ways,
+
+26:49.840 --> 26:51.240
+ but it's not very structured.
+
+26:51.240 --> 26:52.640
+ This is something that we need,
+
+26:52.640 --> 26:54.520
+ we as an industry need to fix.
+
+26:54.520 --> 26:56.240
+ So you said 80s, but like,
+
+26:56.240 --> 26:59.960
+ so have there been like big jumps in improvement
+
+26:59.960 --> 27:01.280
+ and optimization?
+
+27:01.280 --> 27:02.360
+ Yeah.
+
+27:02.360 --> 27:05.320
+ Yeah, since then, what's the coolest thing about it?
+
+27:05.320 --> 27:07.120
+ It's largely been driven by hardware.
+
+27:07.120 --> 27:09.880
+ So hardware and software.
+
+27:09.880 --> 27:13.880
+ So in the mid 90s, Java totally changed the world, right?
+
+27:13.880 --> 27:17.520
+ And I'm still amazed by how much change was introduced
+
+27:17.520 --> 27:19.320
+ by Java in a good way or in a good way.
+
+27:19.320 --> 27:20.600
+ So like reflecting back,
+
+27:20.600 --> 27:23.800
+ Java introduced things like all at once introduced things
+
+27:23.800 --> 27:25.680
+ like JIT compilation.
+
+27:25.680 --> 27:26.920
+ None of these were novel,
+
+27:26.920 --> 27:28.640
+ but it pulled it together and made it mainstream
+
+27:28.640 --> 27:30.600
+ and made people invest in it.
+
+27:30.600 --> 27:32.680
+ JIT compilation, garbage collection,
+
+27:32.680 --> 27:36.680
+ portable code, safe code, like memory safe code,
+
+27:37.680 --> 27:41.480
+ like a very dynamic dispatch execution model.
+
+27:41.480 --> 27:42.680
+ Like many of these things,
+
+27:42.680 --> 27:44.120
+ which had been done in research systems
+
+27:44.120 --> 27:46.960
+ and had been done in small ways in various places,
+
+27:46.960 --> 27:48.040
+ really came to the forefront
+
+27:48.040 --> 27:49.840
+ and really changed how things worked.
+
+27:49.840 --> 27:52.040
+ And therefore changed the way people thought
+
+27:52.040 --> 27:53.120
+ about the problem.
+
+27:53.120 --> 27:56.360
+ JavaScript was another major world change
+
+27:56.360 --> 27:57.780
+ based on the way it works.
+
+27:59.320 --> 28:01.240
+ But also on the hardware side of things,
+
+28:02.240 --> 28:05.200
+ multi core and vector instructions
+
+28:05.200 --> 28:07.520
+ really change the problem space
+
+28:07.520 --> 28:10.800
+ and are very, they don't remove any of the problems
+
+28:10.800 --> 28:12.360
+ that compilers faced in the past,
+
+28:12.360 --> 28:14.560
+ but they add new kinds of problems
+
+28:14.560 --> 28:16.400
+ of how do you find enough work
+
+28:16.400 --> 28:20.040
+ to keep a four wide vector busy, right?
+
+28:20.040 --> 28:22.640
+ Or if you're doing a matrix multiplication,
+
+28:22.640 --> 28:25.360
+ how do you do different columns out of that matrix
+
+28:25.360 --> 28:26.680
+ in at the same time?
+
+28:26.680 --> 28:30.160
+ And how do you maximum utilize the arithmetic compute
+
+28:30.160 --> 28:31.440
+ that one core has?
+
+28:31.440 --> 28:33.480
+ And then how do you take it to multiple cores?
+
+28:33.480 --> 28:35.040
+ How did the whole virtual machine thing
+
+28:35.040 --> 28:37.960
+ change the compilation pipeline?
+
+28:37.960 --> 28:40.440
+ Yeah, so what the Java virtual machine does
+
+28:40.440 --> 28:44.160
+ is it splits, just like I was talking about before,
+
+28:44.160 --> 28:46.280
+ where you have a front end that parses the code
+
+28:46.280 --> 28:47.960
+ and then you have an intermediate representation
+
+28:47.960 --> 28:49.400
+ that gets transformed.
+
+28:49.400 --> 28:50.960
+ What Java did was they said,
+
+28:50.960 --> 28:52.720
+ we will parse the code and then compile
+
+28:52.720 --> 28:55.480
+ to what's known as Java bytecode.
+
+28:55.480 --> 28:58.560
+ And that bytecode is now a portable code representation
+
+28:58.560 --> 29:02.400
+ that is industry standard and locked down and can't change.
+
+29:02.400 --> 29:05.040
+ And then the back part of the compiler
+
+29:05.040 --> 29:07.280
+ that does optimization and code generation
+
+29:07.280 --> 29:09.440
+ can now be built by different vendors.
+
+29:09.440 --> 29:12.080
+ Okay, and Java bytecode can be shipped around
+
+29:12.080 --> 29:15.840
+ across the wire, it's memory safe and relatively trusted.
+
+29:16.840 --> 29:18.680
+ And because of that it can run in the browser.
+
+29:18.680 --> 29:20.480
+ And that's why it runs in the browser, right?
+
+29:20.480 --> 29:22.960
+ And so that way you can be in, you know,
+
+29:22.960 --> 29:25.000
+ again, back in the day, you would write a Java applet
+
+29:25.000 --> 29:27.720
+ and you'd use it as a web developer,
+
+29:27.720 --> 29:30.840
+ you'd build this mini app that would run on a web page.
+
+29:30.840 --> 29:33.600
+ Well, a user of that is running a web browser
+
+29:33.600 --> 29:36.160
+ on their computer, you download that Java bytecode,
+
+29:36.160 --> 29:39.280
+ which can be trusted, and then you do
+
+29:39.280 --> 29:41.040
+ all the compiler stuff on your machine
+
+29:41.040 --> 29:42.400
+ so that you know that you trust that.
+
+29:42.400 --> 29:44.080
+ Is that a good idea or a bad idea?
+
+29:44.080 --> 29:44.920
+ It's a great idea, I mean,
+
+29:44.920 --> 29:46.200
+ it's a great idea for certain problems.
+
+29:46.200 --> 29:48.200
+ And I'm very much a believer
+
+29:48.200 --> 29:50.480
+ that the technology is itself neither good nor bad,
+
+29:50.480 --> 29:51.600
+ it's how you apply it.
+
+29:52.920 --> 29:54.600
+ You know, this would be a very, very bad thing
+
+29:54.600 --> 29:56.960
+ for very low levels of the software stack,
+
+29:56.960 --> 30:00.280
+ but in terms of solving some of these software portability
+
+30:00.280 --> 30:02.760
+ and transparency or portability problems,
+
+30:02.760 --> 30:04.200
+ I think it's been really good.
+
+30:04.200 --> 30:06.560
+ Now Java ultimately didn't win out on the desktop
+
+30:06.560 --> 30:09.400
+ and like there are good reasons for that,
+
+30:09.400 --> 30:13.200
+ but it's been very successful on servers and in many places,
+
+30:13.200 --> 30:16.280
+ it's been a very successful thing over decades.
+
+30:16.280 --> 30:21.280
+ So what has been LLVM's and Selang's improvements
+
+30:24.480 --> 30:28.720
+ and optimization that throughout its history,
+
+30:28.720 --> 30:31.080
+ what are some moments we had set back
+
+30:31.080 --> 30:33.280
+ and really proud of what's been accomplished?
+
+30:33.280 --> 30:36.200
+ Yeah, I think that the interesting thing about LLVM
+
+30:36.200 --> 30:40.120
+ is not the innovations in compiler research,
+
+30:40.120 --> 30:41.880
+ it has very good implementations
+
+30:41.880 --> 30:43.880
+ of very important algorithms, no doubt.
+
+30:43.880 --> 30:48.280
+ And a lot of really smart people have worked on it,
+
+30:48.280 --> 30:50.560
+ but I think that the thing that's most profound about LLVM
+
+30:50.560 --> 30:52.600
+ is that through standardization,
+
+30:52.600 --> 30:55.720
+ it made things possible that otherwise wouldn't have happened.
+
+30:55.720 --> 30:56.560
+ Okay.
+
+30:56.560 --> 30:59.120
+ And so interesting things that have happened with LLVM,
+
+30:59.120 --> 31:01.280
+ for example, Sony has picked up LLVM
+
+31:01.280 --> 31:03.920
+ and used it to do all the graphics compilation
+
+31:03.920 --> 31:06.080
+ in their movie production pipeline.
+
+31:06.080 --> 31:07.920
+ And so now they're able to have better special effects
+
+31:07.920 --> 31:09.680
+ because of LLVM.
+
+31:09.680 --> 31:11.200
+ That's kind of cool.
+
+31:11.200 --> 31:13.000
+ That's not what it was designed for, right?
+
+31:13.000 --> 31:15.480
+ But that's the sign of good infrastructure
+
+31:15.480 --> 31:18.800
+ when it can be used in ways it was never designed for
+
+31:18.800 --> 31:20.960
+ because it has good layering and software engineering
+
+31:20.960 --> 31:23.440
+ and it's composable and things like that.
+
+31:23.440 --> 31:26.120
+ Which is where, as you said, it differs from GCC.
+
+31:26.120 --> 31:28.240
+ Yes, GCC is also great in various ways,
+
+31:28.240 --> 31:31.800
+ but it's not as good as infrastructure technology.
+
+31:31.800 --> 31:36.120
+ It's really a C compiler, or it's a 4 train compiler.
+
+31:36.120 --> 31:39.200
+ It's not infrastructure in the same way.
+
+31:39.200 --> 31:40.400
+ Is it, now you can tell,
+
+31:40.400 --> 31:41.560
+ I don't know what I'm talking about
+
+31:41.560 --> 31:43.680
+ because I keep saying C lang.
+
+31:44.520 --> 31:48.080
+ You can always tell when a person is closed,
+
+31:48.080 --> 31:49.400
+ by the way, pronounce something.
+
+31:49.400 --> 31:52.600
+ I don't think, have I ever used Clang?
+
+31:52.600 --> 31:53.440
+ Entirely possible.
+
+31:53.440 --> 31:55.680
+ Have you, well, so you've used code,
+
+31:55.680 --> 31:58.200
+ it's generated probably.
+
+31:58.200 --> 32:01.760
+ So Clang is an LLVM or used to compile
+
+32:01.760 --> 32:05.240
+ all the apps on the iPhone effectively and the OSes.
+
+32:05.240 --> 32:09.360
+ It compiles Google's production server applications.
+
+32:09.360 --> 32:14.360
+ It's used to build GameCube games and PlayStation 4
+
+32:14.880 --> 32:16.720
+ and things like that.
+
+32:16.720 --> 32:17.920
+ Those are the user I have,
+
+32:17.920 --> 32:20.800
+ but just everything I've done that I experienced
+
+32:20.800 --> 32:23.600
+ with Linux has been, I believe, always GCC.
+
+32:23.600 --> 32:25.720
+ Yeah, I think Linux still defaults to GCC.
+
+32:25.720 --> 32:27.840
+ And is there a reason for that?
+
+32:27.840 --> 32:29.480
+ Or is it, I mean, is there a reason?
+
+32:29.480 --> 32:32.080
+ It's a combination of technical and social reasons.
+
+32:32.080 --> 32:36.000
+ Many Linux developers do use Clang,
+
+32:36.000 --> 32:40.600
+ but the distributions, for lots of reasons,
+
+32:40.600 --> 32:44.280
+ use GCC historically and they've not switched, yeah.
+
+32:44.280 --> 32:46.680
+ Because it's just anecdotally online,
+
+32:46.680 --> 32:50.680
+ it seems that LLVM has either reached the level of GCC
+
+32:50.680 --> 32:53.560
+ or superseded on different features or whatever.
+
+32:53.560 --> 32:55.240
+ The way I would say it is that they're so close
+
+32:55.240 --> 32:56.080
+ it doesn't matter.
+
+32:56.080 --> 32:56.920
+ Yeah, exactly.
+
+32:56.920 --> 32:58.160
+ Like they're slightly better in some ways,
+
+32:58.160 --> 32:59.200
+ slightly worse than otherwise,
+
+32:59.200 --> 33:03.320
+ but it doesn't actually really matter anymore at that level.
+
+33:03.320 --> 33:06.320
+ So in terms of optimization, breakthroughs,
+
+33:06.320 --> 33:09.200
+ it's just been solid incremental work.
+
+33:09.200 --> 33:12.200
+ Yeah, yeah, which describes a lot of compilers.
+
+33:12.200 --> 33:14.360
+ The hard thing about compilers,
+
+33:14.360 --> 33:16.000
+ in my experience, is the engineering,
+
+33:16.000 --> 33:18.680
+ the software engineering, making it
+
+33:18.680 --> 33:20.920
+ so that you can have hundreds of people collaborating
+
+33:20.920 --> 33:25.400
+ on really detailed low level work and scaling that.
+
+33:25.400 --> 33:27.880
+ And that's really hard.
+
+33:27.880 --> 33:30.720
+ And that's one of the things I think LLVM has done well.
+
+33:30.720 --> 33:34.160
+ And that kind of goes back to the original design goals
+
+33:34.160 --> 33:37.160
+ with it to be modular and things like that.
+
+33:37.160 --> 33:38.840
+ And incidentally, I don't want to take all the credit
+
+33:38.840 --> 33:39.680
+ for this, right?
+
+33:39.680 --> 33:41.760
+ I mean, some of the best parts about LLVM
+
+33:41.760 --> 33:43.600
+ is that it was designed to be modular.
+
+33:43.600 --> 33:44.960
+ And when I started, I would write,
+
+33:44.960 --> 33:46.840
+ for example, a register allocator,
+
+33:46.840 --> 33:49.040
+ and then somebody much smarter than me would come in
+
+33:49.040 --> 33:51.320
+ and pull it out and replace it with something else
+
+33:51.320 --> 33:52.640
+ that they would come up with.
+
+33:52.640 --> 33:55.160
+ And because it's modular, they were able to do that.
+
+33:55.160 --> 33:58.240
+ And that's one of the challenges with GCC, for example,
+
+33:58.240 --> 34:01.240
+ is replacing subsystems is incredibly difficult.
+
+34:01.240 --> 34:04.640
+ It can be done, but it wasn't designed for that.
+
+34:04.640 --> 34:06.040
+ And that's one of the reasons that LLVM has been
+
+34:06.040 --> 34:08.720
+ very successful in the research world as well.
+
+34:08.720 --> 34:11.040
+ But in the community sense,
+
+34:11.040 --> 34:12.960
+ Guido van Rasen, right?
+
+34:12.960 --> 34:16.880
+ From Python, just retired from,
+
+34:18.080 --> 34:20.480
+ what is it, benevolent, dictated for life, right?
+
+34:20.480 --> 34:24.720
+ So in managing this community of brilliant compiler folks,
+
+34:24.720 --> 34:28.640
+ is there, did it, for a time at least,
+
+34:28.640 --> 34:31.480
+ fall on you to approve things?
+
+34:31.480 --> 34:34.240
+ Oh yeah, so I mean, I still have something like
+
+34:34.240 --> 34:38.000
+ an order of magnitude more patches in LLVM
+
+34:38.000 --> 34:39.000
+ than anybody else.
+
+34:40.000 --> 34:42.760
+ And many of those I wrote myself.
+
+34:42.760 --> 34:43.840
+ But you're still right.
+
+34:43.840 --> 34:48.360
+ I mean, you're still close to the,
+
+34:48.360 --> 34:50.040
+ I don't know what the expression is to the metal.
+
+34:50.040 --> 34:51.040
+ You're still right, Ko.
+
+34:51.040 --> 34:52.200
+ Yeah, I'm still right, Ko.
+
+34:52.200 --> 34:54.240
+ Not as much as I was able to in grad school,
+
+34:54.240 --> 34:56.760
+ but that's an important part of my identity.
+
+34:56.760 --> 34:58.880
+ But the way that LLVM has worked over time
+
+34:58.880 --> 35:00.440
+ is that when I was a grad student,
+
+35:00.440 --> 35:03.000
+ I could do all the work and steer everything
+
+35:03.000 --> 35:05.800
+ and review every patch and make sure everything was done
+
+35:05.800 --> 35:09.040
+ exactly the way my opinionated sense
+
+35:09.040 --> 35:10.640
+ felt like it should be done.
+
+35:10.640 --> 35:11.760
+ And that was fine.
+
+35:11.760 --> 35:14.320
+ But as things scale, you can't do that, right?
+
+35:14.320 --> 35:18.040
+ And so what ends up happening is LLVM has a hierarchical
+
+35:18.040 --> 35:20.520
+ system of what's called code owners.
+
+35:20.520 --> 35:22.880
+ These code owners are given the responsibility
+
+35:22.880 --> 35:24.920
+ not to do all the work,
+
+35:24.920 --> 35:26.680
+ not necessarily to review all the patches,
+
+35:26.680 --> 35:28.840
+ but to make sure that the patches do get reviewed
+
+35:28.840 --> 35:30.360
+ and make sure that the right thing's happening
+
+35:30.360 --> 35:32.200
+ architecturally in their area.
+
+35:32.200 --> 35:34.200
+ And so what you'll see is you'll see
+
+35:34.200 --> 35:37.760
+ that for example, hardware manufacturers
+
+35:37.760 --> 35:40.920
+ end up owning the hardware specific parts
+
+35:40.920 --> 35:44.520
+ of their hardware, that's very common.
+
+35:45.560 --> 35:47.760
+ Leaders in the community that have done really good work
+
+35:47.760 --> 35:50.920
+ naturally become the de facto owner of something.
+
+35:50.920 --> 35:53.440
+ And then usually somebody else is like,
+
+35:53.440 --> 35:55.520
+ how about we make them the official code owner?
+
+35:55.520 --> 35:58.600
+ And then we'll have somebody to make sure
+
+35:58.600 --> 36:00.320
+ that all the patches get reviewed in a timely manner.
+
+36:00.320 --> 36:02.080
+ And then everybody's like, yes, that's obvious.
+
+36:02.080 --> 36:03.240
+ And then it happens, right?
+
+36:03.240 --> 36:06.080
+ And usually this is a very organic thing, which is great.
+
+36:06.080 --> 36:08.720
+ And so I'm nominally the top of that stack still,
+
+36:08.720 --> 36:11.560
+ but I don't spend a lot of time reviewing patches.
+
+36:11.560 --> 36:16.520
+ What I do is I help negotiate a lot of the technical
+
+36:16.520 --> 36:18.080
+ disagreements that end up happening
+
+36:18.080 --> 36:19.680
+ and making sure that the community as a whole
+
+36:19.680 --> 36:22.080
+ makes progress and is moving in the right direction
+
+36:22.080 --> 36:23.960
+ and doing that.
+
+36:23.960 --> 36:28.280
+ So we also started a nonprofit six years ago,
+
+36:28.280 --> 36:30.880
+ seven years ago, time's gone away.
+
+36:30.880 --> 36:34.640
+ And the LVM Foundation nonprofit helps oversee
+
+36:34.640 --> 36:36.480
+ all the business sides of things and make sure
+
+36:36.480 --> 36:39.680
+ that the events that the LVM community has are funded
+
+36:39.680 --> 36:42.840
+ and set up and run correctly and stuff like that.
+
+36:42.840 --> 36:45.200
+ But the foundation is very much stays out
+
+36:45.200 --> 36:49.080
+ of the technical side of where the project is going.
+
+36:49.080 --> 36:53.200
+ Right, so it sounds like a lot of it is just organic, just.
+
+36:53.200 --> 36:55.720
+ Yeah, well, and this is LVM is almost 20 years old,
+
+36:55.720 --> 36:56.640
+ which is hard to believe.
+
+36:56.640 --> 37:00.360
+ Somebody pointed out to me recently that LVM is now older
+
+37:00.360 --> 37:04.640
+ than GCC was when LVM started, right?
+
+37:04.640 --> 37:06.880
+ So time has a way of getting away from you.
+
+37:06.880 --> 37:10.440
+ But the good thing about that is it has a really robust,
+
+37:10.440 --> 37:13.560
+ really amazing community of people that are
+
+37:13.560 --> 37:14.720
+ in their professional lives,
+
+37:14.720 --> 37:16.320
+ spread across lots of different companies,
+
+37:16.320 --> 37:19.320
+ but it's a community of people
+
+37:19.320 --> 37:21.160
+ that are interested in similar kinds of problems
+
+37:21.160 --> 37:23.720
+ and have been working together effectively for years
+
+37:23.720 --> 37:26.480
+ and have a lot of trust and respect for each other.
+
+37:26.480 --> 37:28.960
+ And even if they don't always agree that, you know,
+
+37:28.960 --> 37:31.200
+ we're able to find a path forward.
+
+37:31.200 --> 37:34.520
+ So then in a slightly different flavor of effort,
+
+37:34.520 --> 37:38.920
+ you started at Apple in 2005 with the task of making,
+
+37:38.920 --> 37:41.840
+ I guess, LVM production ready.
+
+37:41.840 --> 37:44.680
+ And then eventually 2013 through 2017,
+
+37:44.680 --> 37:48.400
+ leading the entire developer tools department.
+
+37:48.400 --> 37:53.000
+ We're talking about LLVM, Xcode, Objective C to Swift.
+
+37:53.960 --> 37:58.600
+ So in a quick overview of your time there,
+
+37:58.600 --> 37:59.640
+ what were the challenges?
+
+37:59.640 --> 38:03.280
+ First of all, leading such a huge group of developers.
+
+38:03.280 --> 38:06.560
+ What was the big motivator dream mission
+
+38:06.560 --> 38:11.440
+ behind creating Swift, the early birth of it
+
+38:11.440 --> 38:13.440
+ from Objective C and so on and Xcode?
+
+38:13.440 --> 38:14.280
+ What are some challenges?
+
+38:14.280 --> 38:15.920
+ So these are different questions.
+
+38:15.920 --> 38:16.760
+ Yeah, I know.
+
+38:16.760 --> 38:19.560
+ But I want to talk about the other stuff too.
+
+38:19.560 --> 38:21.240
+ I'll stay on the technical side,
+
+38:21.240 --> 38:23.440
+ then we can talk about the big team pieces.
+
+38:23.440 --> 38:24.280
+ That's okay?
+
+38:24.280 --> 38:25.120
+ Sure.
+
+38:25.120 --> 38:27.760
+ So it's to really oversimplify many years of hard work.
+
+38:27.760 --> 38:32.440
+ LVM started, joined Apple, became a thing,
+
+38:32.440 --> 38:34.600
+ became successful and became deployed.
+
+38:34.600 --> 38:36.760
+ But then there was a question about
+
+38:36.760 --> 38:38.880
+ how do we actually parse the source code?
+
+38:38.880 --> 38:40.320
+ So LVM is that back part,
+
+38:40.320 --> 38:42.320
+ the optimizer and the code generator.
+
+38:42.320 --> 38:44.640
+ And LVM is really good for Apple as it went through
+
+38:44.640 --> 38:46.040
+ a couple of hardware transitions.
+
+38:46.040 --> 38:47.920
+ I joined right at the time of the Intel transition,
+
+38:47.920 --> 38:51.800
+ for example, and 64 bit transitions
+
+38:51.800 --> 38:53.480
+ and then the transition to ARM with the iPhone.
+
+38:53.480 --> 38:54.680
+ And so LVM was very useful
+
+38:54.680 --> 38:56.920
+ for some of these kinds of things.
+
+38:56.920 --> 38:57.760
+ But at the same time,
+
+38:57.760 --> 39:00.080
+ there's a lot of questions around developer experience.
+
+39:00.080 --> 39:01.880
+ And so if you're a programmer pounding out
+
+39:01.880 --> 39:03.400
+ at the time Objective C code,
+
+39:04.400 --> 39:06.440
+ the error message you get, the compile time,
+
+39:06.440 --> 39:09.680
+ the turnaround cycle, the tooling and the IDE
+
+39:09.680 --> 39:12.960
+ were not great, were not as good as they could be.
+
+39:12.960 --> 39:17.960
+ And so, as I occasionally do, I'm like,
+
+39:17.960 --> 39:20.080
+ well, okay, how hard is it to write a C compiler?
+
+39:20.080 --> 39:20.920
+ Right.
+
+39:20.920 --> 39:22.520
+ And so I'm not gonna commit to anybody.
+
+39:22.520 --> 39:23.360
+ I'm not gonna tell anybody.
+
+39:23.360 --> 39:25.960
+ I'm just gonna just do it on nights and weekends
+
+39:25.960 --> 39:27.400
+ and start working on it.
+
+39:27.400 --> 39:30.120
+ And then I built up and see there's this thing
+
+39:30.120 --> 39:32.960
+ called the preprocessor, which people don't like,
+
+39:32.960 --> 39:35.440
+ but it's actually really hard and complicated
+
+39:35.440 --> 39:37.640
+ and includes a bunch of really weird things
+
+39:37.640 --> 39:39.240
+ like try graphs and other stuff like that
+
+39:39.240 --> 39:40.880
+ that are really nasty.
+
+39:40.880 --> 39:44.000
+ And it's the crux of a bunch of the performance issues
+
+39:44.000 --> 39:46.560
+ in the compiler, start working on the parser
+
+39:46.560 --> 39:47.720
+ and kind of got to the point where I'm like,
+
+39:47.720 --> 39:49.840
+ oh, you know what, we could actually do this.
+
+39:49.840 --> 39:51.400
+ Everybody's saying that this is impossible to do,
+
+39:51.400 --> 39:52.800
+ but it's actually just hard.
+
+39:52.800 --> 39:53.880
+ It's not impossible.
+
+39:53.880 --> 39:57.520
+ And eventually told my manager about it
+
+39:57.520 --> 39:59.160
+ and he's like, oh, wow, this is great.
+
+39:59.160 --> 40:00.280
+ We do need to solve this problem.
+
+40:00.280 --> 40:01.120
+ Oh, this is great.
+
+40:01.120 --> 40:04.360
+ We can get you one other person to work with you on this.
+
+40:04.360 --> 40:08.240
+ And so the team is formed and it starts taking off.
+
+40:08.240 --> 40:11.960
+ And C++, for example, huge complicated language.
+
+40:11.960 --> 40:14.280
+ People always assume that it's impossible to implement
+
+40:14.280 --> 40:16.160
+ and it's very nearly impossible,
+
+40:16.160 --> 40:18.640
+ but it's just really, really hard.
+
+40:18.640 --> 40:20.760
+ And the way to get there is to build it
+
+40:20.760 --> 40:22.360
+ one piece at a time incrementally.
+
+40:22.360 --> 40:26.360
+ And that was only possible because we were lucky
+
+40:26.360 --> 40:28.080
+ to hire some really exceptional engineers
+
+40:28.080 --> 40:30.280
+ that knew various parts of it very well
+
+40:30.280 --> 40:32.600
+ and could do great things.
+
+40:32.600 --> 40:34.360
+ Swift was kind of a similar thing.
+
+40:34.360 --> 40:39.080
+ So Swift came from, we were just finishing off
+
+40:39.080 --> 40:42.520
+ the first version of C++ support in Clang.
+
+40:42.520 --> 40:47.160
+ And C++ is a very formidable and very important language,
+
+40:47.160 --> 40:49.240
+ but it's also ugly in lots of ways.
+
+40:49.240 --> 40:52.280
+ And you can't implement C++ without thinking
+
+40:52.280 --> 40:54.320
+ there has to be a better thing, right?
+
+40:54.320 --> 40:56.080
+ And so I started working on Swift again
+
+40:56.080 --> 40:58.520
+ with no hope or ambition that would go anywhere.
+
+40:58.520 --> 41:00.760
+ Just let's see what could be done.
+
+41:00.760 --> 41:02.560
+ Let's play around with this thing.
+
+41:02.560 --> 41:04.800
+ It was me in my spare time,
+
+41:04.800 --> 41:08.160
+ not telling anybody about it kind of a thing.
+
+41:08.160 --> 41:09.360
+ And it made some good progress.
+
+41:09.360 --> 41:11.240
+ I'm like, actually, it would make sense to do this.
+
+41:11.240 --> 41:14.760
+ At the same time, I started talking with the senior VP
+
+41:14.760 --> 41:17.680
+ of software at the time, a guy named Bertrand Sirle,
+
+41:17.680 --> 41:19.240
+ and Bertrand was very encouraging.
+
+41:19.240 --> 41:22.040
+ He was like, well, let's have fun, let's talk about this.
+
+41:22.040 --> 41:23.400
+ And he was a little bit of a language guy.
+
+41:23.400 --> 41:26.120
+ And so he helped guide some of the early work
+
+41:26.120 --> 41:30.360
+ and encouraged me and got things off the ground.
+
+41:30.360 --> 41:34.240
+ And eventually, I told my manager and told other people.
+
+41:34.240 --> 41:38.760
+ And it started making progress.
+
+41:38.760 --> 41:40.920
+ The complicating thing with Swift
+
+41:40.920 --> 41:43.840
+ was that the idea of doing a new language
+
+41:43.840 --> 41:47.760
+ is not obvious to anybody, including myself.
+
+41:47.760 --> 41:50.160
+ And the tone at the time was that the iPhone
+
+41:50.160 --> 41:53.360
+ was successful because of Objective C, right?
+
+41:53.360 --> 41:54.360
+ Oh, interesting.
+
+41:54.360 --> 41:55.200
+ In Objective C.
+
+41:55.200 --> 41:57.080
+ Not despite of or just because of.
+
+41:57.080 --> 42:01.080
+ And you have to understand that at the time,
+
+42:01.080 --> 42:05.360
+ Apple was hiring software people that loved Objective C, right?
+
+42:05.360 --> 42:07.920
+ And it wasn't that they came despite Objective C.
+
+42:07.920 --> 42:10.160
+ They loved Objective C, and that's why they got hired.
+
+42:10.160 --> 42:13.680
+ And so you had a software team that the leadership in many cases
+
+42:13.680 --> 42:18.440
+ went all the way back to Next, where Objective C really became
+
+42:18.440 --> 42:19.320
+ real.
+
+42:19.320 --> 42:23.200
+ And so they, quote unquote, grew up writing Objective C.
+
+42:23.200 --> 42:25.680
+ And many of the individual engineers
+
+42:25.680 --> 42:28.280
+ all were hired because they loved Objective C.
+
+42:28.280 --> 42:30.520
+ And so this notion of, OK, let's do new language
+
+42:30.520 --> 42:34.040
+ was kind of heretical in many ways, right?
+
+42:34.040 --> 42:36.960
+ Meanwhile, my sense was that the outside community wasn't really
+
+42:36.960 --> 42:38.520
+ in love with Objective C. Some people were.
+
+42:38.520 --> 42:40.200
+ And some of the most outspoken people were.
+
+42:40.200 --> 42:42.600
+ But other people were hitting challenges
+
+42:42.600 --> 42:46.760
+ because it has very sharp corners and it's difficult to learn.
+
+42:46.760 --> 42:50.040
+ And so one of the challenges of making Swift happen
+
+42:50.040 --> 42:54.640
+ that was totally non technical is the social part
+
+42:54.640 --> 42:57.760
+ of what do we do?
+
+42:57.760 --> 43:00.280
+ If we do a new language, which at Apple, many things
+
+43:00.280 --> 43:02.200
+ happen that don't ship, right?
+
+43:02.200 --> 43:05.520
+ So if we ship it, what is the metrics of success?
+
+43:05.520 --> 43:06.360
+ Why would we do this?
+
+43:06.360 --> 43:07.920
+ Why wouldn't we make Objective C better?
+
+43:07.920 --> 43:09.760
+ If Objective C has problems, let's
+
+43:09.760 --> 43:12.120
+ file off those rough corners and edges.
+
+43:12.120 --> 43:15.600
+ And one of the major things that became the reason to do this
+
+43:15.600 --> 43:18.960
+ was this notion of safety, memory safety.
+
+43:18.960 --> 43:22.880
+ And the way Objective C works is that a lot of the object
+
+43:22.880 --> 43:26.440
+ system and everything else is built on top of pointers
+
+43:26.440 --> 43:29.920
+ in C. Objective C is an extension on top of C.
+
+43:29.920 --> 43:32.640
+ And so pointers are unsafe.
+
+43:32.640 --> 43:34.600
+ And if you get rid of the pointers,
+
+43:34.600 --> 43:36.400
+ it's not Objective C anymore.
+
+43:36.400 --> 43:39.040
+ And so fundamentally, that was an issue
+
+43:39.040 --> 43:42.160
+ that you could not fix safety or memory safety
+
+43:42.160 --> 43:45.560
+ without fundamentally changing the language.
+
+43:45.560 --> 43:49.880
+ And so once we got through that part of the mental process
+
+43:49.880 --> 43:53.480
+ and the thought process, it became a design process of saying,
+
+43:53.480 --> 43:56.240
+ OK, well, if we're going to do something new, what is good?
+
+43:56.240 --> 43:57.400
+ Like, how do we think about this?
+
+43:57.400 --> 43:59.960
+ And what are we like, and what are we looking for?
+
+43:59.960 --> 44:02.400
+ And that was a very different phase of it.
+
+44:02.400 --> 44:05.880
+ So what are some design choices early on in Swift?
+
+44:05.880 --> 44:09.720
+ Like, we're talking about braces.
+
+44:09.720 --> 44:12.040
+ Are you making a type language or not?
+
+44:12.040 --> 44:13.200
+ All those kinds of things.
+
+44:13.200 --> 44:16.000
+ Yeah, so some of those were obvious given the context.
+
+44:16.000 --> 44:18.240
+ So a type language, for example, Objective C
+
+44:18.240 --> 44:22.480
+ is a type language, and going with an untyped language
+
+44:22.480 --> 44:24.280
+ wasn't really seriously considered.
+
+44:24.280 --> 44:26.920
+ We wanted the performance, and we wanted refactoring tools
+
+44:26.920 --> 44:29.600
+ and other things like that that go with type languages.
+
+44:29.600 --> 44:30.800
+ Quick dumb question.
+
+44:30.800 --> 44:31.400
+ Yeah.
+
+44:31.400 --> 44:32.920
+ Was it obvious?
+
+44:32.920 --> 44:34.600
+ I think this would be a dumb question.
+
+44:34.600 --> 44:36.520
+ But was it obvious that the language has
+
+44:36.520 --> 44:38.920
+ to be a compiled language?
+
+44:38.920 --> 44:40.120
+ Not an?
+
+44:40.120 --> 44:42.040
+ Yes, that's not a dumb question.
+
+44:42.040 --> 44:44.000
+ Earlier, I think late 90s, Apple
+
+44:44.000 --> 44:48.960
+ had seriously considered moving its development experience to Java.
+
+44:48.960 --> 44:53.120
+ But Swift started in 2010, which was several years
+
+44:53.120 --> 44:53.800
+ after the iPhone.
+
+44:53.800 --> 44:56.600
+ It was when the iPhone was definitely on an upper trajectory.
+
+44:56.600 --> 44:58.680
+ And the iPhone was still extremely
+
+44:58.680 --> 45:01.760
+ and is still a bit memory constrained.
+
+45:01.760 --> 45:05.480
+ And so being able to compile the code and then ship it
+
+45:05.480 --> 45:09.720
+ and then having standalone code that is not JIT compiled
+
+45:09.720 --> 45:11.320
+ is a very big deal.
+
+45:11.320 --> 45:15.200
+ And it's very much part of the Apple value system.
+
+45:15.200 --> 45:17.520
+ Now, JavaScript's also a thing.
+
+45:17.520 --> 45:19.360
+ I mean, it's not that this is exclusive,
+
+45:19.360 --> 45:23.880
+ and technologies are good, depending on how they're applied.
+
+45:23.880 --> 45:27.200
+ But in the design of Swift, saying how can we make
+
+45:27.200 --> 45:29.560
+ Objective C better, Objective C was statically compiled,
+
+45:29.560 --> 45:32.480
+ and that was the contiguous natural thing to do.
+
+45:32.480 --> 45:34.640
+ Just skip ahead a little bit.
+
+45:34.640 --> 45:37.600
+ Right back, just as a question, as you think about today
+
+45:37.600 --> 45:42.400
+ in 2019, in your work at Google, TensorFlow, and so on,
+
+45:42.400 --> 45:47.480
+ is, again, compilation, static compilation,
+
+45:47.480 --> 45:49.480
+ still the right thing.
+
+45:49.480 --> 45:52.560
+ Yeah, so the funny thing after working on compilers
+
+45:52.560 --> 45:56.480
+ for a really long time is that, and this
+
+45:56.480 --> 45:59.080
+ is one of the things that LLVM has helped with,
+
+45:59.080 --> 46:01.480
+ is that I don't look at compilations
+
+46:01.480 --> 46:05.320
+ being static or dynamic or interpreted or not.
+
+46:05.320 --> 46:09.160
+ This is a spectrum, and one of the cool things about Swift
+
+46:09.160 --> 46:12.200
+ is that Swift is not just statically compiled.
+
+46:12.200 --> 46:14.160
+ It's actually dynamically compiled as well.
+
+46:14.160 --> 46:16.000
+ And it can also be interpreted, though nobody's actually
+
+46:16.000 --> 46:17.560
+ done that.
+
+46:17.560 --> 46:20.360
+ And so what ends up happening when
+
+46:20.360 --> 46:22.760
+ you use Swift in a workbook, for example,
+
+46:22.760 --> 46:25.320
+ in Colab or in Jupyter, is it's actually dynamically
+
+46:25.320 --> 46:28.320
+ compiling the statements as you execute them.
+
+46:28.320 --> 46:32.840
+ And so this gets back to the software engineering problems,
+
+46:32.840 --> 46:34.960
+ where if you layer the stack properly,
+
+46:34.960 --> 46:37.280
+ you can actually completely change
+
+46:37.280 --> 46:39.320
+ how and when things get compiled because you
+
+46:39.320 --> 46:41.120
+ have the right abstractions there.
+
+46:41.120 --> 46:44.800
+ And so the way that a Colab workbook works with Swift
+
+46:44.800 --> 46:47.720
+ is that when you start typing into it,
+
+46:47.720 --> 46:50.320
+ it creates a process, a UNIX process.
+
+46:50.320 --> 46:52.240
+ And then each line of code you type in,
+
+46:52.240 --> 46:56.240
+ it compiles it through the Swift compiler, the front end part,
+
+46:56.240 --> 46:58.400
+ and then sends it through the optimizer,
+
+46:58.400 --> 47:01.120
+ JIT compiles machine code, and then
+
+47:01.120 --> 47:03.920
+ injects it into that process.
+
+47:03.920 --> 47:06.560
+ And so as you're typing new stuff,
+
+47:06.560 --> 47:09.360
+ it's like squirting in new code and overwriting and replacing
+
+47:09.360 --> 47:11.240
+ and updating code in place.
+
+47:11.240 --> 47:13.520
+ And the fact that it can do this is not an accident.
+
+47:13.520 --> 47:15.560
+ Like Swift was designed for this.
+
+47:15.560 --> 47:18.120
+ But it's an important part of how the language was set up
+
+47:18.120 --> 47:18.960
+ and how it's layered.
+
+47:18.960 --> 47:21.360
+ And this is a non obvious piece.
+
+47:21.360 --> 47:24.640
+ And one of the things with Swift that was, for me,
+
+47:24.640 --> 47:27.040
+ a very strong design point is to make it so that you
+
+47:27.040 --> 47:29.680
+ can learn it very quickly.
+
+47:29.680 --> 47:32.080
+ And so from a language design perspective,
+
+47:32.080 --> 47:34.520
+ the thing that I always come back to is this UI principle
+
+47:34.520 --> 47:37.880
+ of progressive disclosure of complexity.
+
+47:37.880 --> 47:41.680
+ And so in Swift, you can start by saying print, quote,
+
+47:41.680 --> 47:43.960
+ hello world, quote.
+
+47:43.960 --> 47:47.160
+ And there's no slash n, just like Python, one line of code,
+
+47:47.160 --> 47:51.560
+ no main, no header files, no public static class void,
+
+47:51.560 --> 47:55.600
+ blah, blah, blah string, like Java has, one line of code.
+
+47:55.600 --> 47:58.280
+ And you can teach that and it works great.
+
+47:58.280 --> 48:00.280
+ Then you can say, well, let's introduce variables.
+
+48:00.280 --> 48:02.400
+ And so you can declare a variable with var.
+
+48:02.400 --> 48:03.760
+ So var x equals four.
+
+48:03.760 --> 48:04.680
+ What is a variable?
+
+48:04.680 --> 48:06.280
+ You can use x, x plus one.
+
+48:06.280 --> 48:07.720
+ This is what it means.
+
+48:07.720 --> 48:09.480
+ Then you can say, well, how about control flow?
+
+48:09.480 --> 48:10.840
+ Well, this is one if statement is.
+
+48:10.840 --> 48:12.240
+ This is what a for statement is.
+
+48:12.240 --> 48:15.320
+ This is what a while statement is.
+
+48:15.320 --> 48:17.280
+ Then you can say, let's introduce functions.
+
+48:17.280 --> 48:20.000
+ And many languages like Python have
+
+48:20.000 --> 48:22.800
+ had this kind of notion of let's introduce small things.
+
+48:22.800 --> 48:24.360
+ And then you can add complexity.
+
+48:24.360 --> 48:25.720
+ Then you can introduce classes.
+
+48:25.720 --> 48:28.040
+ And then you can add generics in the case of Swift.
+
+48:28.040 --> 48:30.600
+ And then you can build in modules and build out in terms
+
+48:30.600 --> 48:32.200
+ of the things that you're expressing.
+
+48:32.200 --> 48:35.800
+ But this is not very typical for compiled languages.
+
+48:35.800 --> 48:38.000
+ And so this was a very strong design point.
+
+48:38.000 --> 48:40.960
+ And one of the reasons that Swift in general
+
+48:40.960 --> 48:43.480
+ is designed with this factoring of complexity in mind
+
+48:43.480 --> 48:46.440
+ so that the language can express powerful things.
+
+48:46.440 --> 48:49.240
+ You can write firmware in Swift if you want to.
+
+48:49.240 --> 48:52.800
+ But it has a very high level feel, which is really
+
+48:52.800 --> 48:53.760
+ this perfect blend.
+
+48:53.760 --> 48:57.440
+ Because often you have very advanced library writers
+
+48:57.440 --> 49:00.520
+ that want to be able to use the nitty gritty details.
+
+49:00.520 --> 49:02.960
+ But then other people just want to use the libraries
+
+49:02.960 --> 49:04.880
+ and work at a higher abstraction level.
+
+49:04.880 --> 49:07.200
+ It's kind of cool that I saw that you can just
+
+49:07.200 --> 49:09.200
+ enter a probability.
+
+49:09.200 --> 49:11.320
+ I don't think I pronounced that word enough.
+
+49:11.320 --> 49:14.920
+ But you can just drag in Python.
+
+49:14.920 --> 49:15.960
+ It's just a string.
+
+49:15.960 --> 49:18.840
+ You can import like, I saw this in the demo,
+
+49:18.840 --> 49:19.600
+ import number.
+
+49:19.600 --> 49:20.760
+ How do you make that happen?
+
+49:20.760 --> 49:21.240
+ Yeah, well.
+
+49:21.240 --> 49:22.520
+ What's up with that?
+
+49:22.520 --> 49:23.240
+ Yeah.
+
+49:23.240 --> 49:24.960
+ Is that as easy as it looks?
+
+49:24.960 --> 49:25.520
+ Or is it?
+
+49:25.520 --> 49:26.560
+ Yes, as easy as it looks.
+
+49:26.560 --> 49:29.440
+ That's not a stage magic hack or anything like that.
+
+49:29.440 --> 49:31.400
+ I don't mean from the user perspective.
+
+49:31.400 --> 49:33.200
+ I mean from the implementation perspective
+
+49:33.200 --> 49:34.120
+ to make it happen.
+
+49:34.120 --> 49:37.000
+ So it's easy once all the pieces are in place.
+
+49:37.000 --> 49:37.920
+ The way it works.
+
+49:37.920 --> 49:39.560
+ So if you think about a dynamically typed language
+
+49:39.560 --> 49:42.160
+ like Python, you can think about it in two different ways.
+
+49:42.160 --> 49:45.800
+ You can say it has no types, which
+
+49:45.800 --> 49:47.480
+ is what most people would say.
+
+49:47.480 --> 49:50.440
+ Or you can say it has one type.
+
+49:50.440 --> 49:53.360
+ And you can say it has one type and it's the Python object.
+
+49:53.360 --> 49:55.040
+ And the Python object is passed around.
+
+49:55.040 --> 49:56.280
+ And because there's only one type,
+
+49:56.280 --> 49:58.240
+ it's implicit.
+
+49:58.240 --> 50:01.320
+ And so what happens with Swift and Python talking to each other,
+
+50:01.320 --> 50:03.320
+ Swift has lots of types, has arrays,
+
+50:03.320 --> 50:07.040
+ and it has strings and all classes and that kind of stuff.
+
+50:07.040 --> 50:11.120
+ But it now has a Python object type.
+
+50:11.120 --> 50:12.800
+ So there is one Python object type.
+
+50:12.800 --> 50:16.440
+ And so when you say import numpy, what you get
+
+50:16.440 --> 50:19.880
+ is a Python object, which is the numpy module.
+
+50:19.880 --> 50:22.160
+ And then you say np.array.
+
+50:22.160 --> 50:24.960
+ It says, OK, hey Python object, I have no idea what you are.
+
+50:24.960 --> 50:27.280
+ Give me your array member.
+
+50:27.280 --> 50:27.960
+ OK, cool.
+
+50:27.960 --> 50:31.160
+ And it just uses dynamic stuff, talks to the Python interpreter
+
+50:31.160 --> 50:33.680
+ and says, hey Python, what's the dot array member
+
+50:33.680 --> 50:35.680
+ in that Python object?
+
+50:35.680 --> 50:37.400
+ It gives you back another Python object.
+
+50:37.400 --> 50:39.480
+ And now you say, parentheses for the call
+
+50:39.480 --> 50:40.960
+ and the arguments are going to pass.
+
+50:40.960 --> 50:43.640
+ And so then it says, hey, a Python object that
+
+50:43.640 --> 50:48.040
+ is the result of np.array, call with these arguments.
+
+50:48.040 --> 50:50.320
+ Again, calling into the Python interpreter to do that work.
+
+50:50.320 --> 50:53.680
+ And so right now, this is all really simple.
+
+50:53.680 --> 50:55.960
+ And if you dive into the code, what you'll see
+
+50:55.960 --> 50:58.440
+ is that the Python module in Swift
+
+50:58.440 --> 51:01.400
+ is something like 1,200 lines of code or something.
+
+51:01.400 --> 51:02.360
+ It's written in pure Swift.
+
+51:02.360 --> 51:03.560
+ It's super simple.
+
+51:03.560 --> 51:06.560
+ And it's built on top of the C interoperability
+
+51:06.560 --> 51:09.520
+ because it just talks to the Python interpreter.
+
+51:09.520 --> 51:11.200
+ But making that possible required us
+
+51:11.200 --> 51:13.480
+ to add two major language features to Swift
+
+51:13.480 --> 51:15.400
+ to be able to express these dynamic calls
+
+51:15.400 --> 51:17.200
+ and the dynamic member lookups.
+
+51:17.200 --> 51:19.480
+ And so what we've done over the last year
+
+51:19.480 --> 51:23.080
+ is we've proposed, implement, standardized,
+
+51:23.080 --> 51:26.160
+ and contributed new language features to the Swift language
+
+51:26.160 --> 51:29.560
+ in order to make it so it is really trivial.
+
+51:29.560 --> 51:31.360
+ And this is one of the things about Swift
+
+51:31.360 --> 51:35.000
+ that is critical to the Swift for TensorFlow work, which
+
+51:35.000 --> 51:37.200
+ is that we can actually add new language features.
+
+51:37.200 --> 51:39.160
+ And the bar for adding those is high,
+
+51:39.160 --> 51:42.160
+ but it's what makes it possible.
+
+51:42.160 --> 51:45.240
+ So you're now at Google doing incredible work
+
+51:45.240 --> 51:47.680
+ on several things, including TensorFlow.
+
+51:47.680 --> 51:52.240
+ So TensorFlow 2.0 or whatever leading up to 2.0
+
+51:52.240 --> 51:57.360
+ has, by default, in 2.0, has eager execution in yet
+
+51:57.360 --> 52:00.480
+ in order to make code optimized for GPU or GPU
+
+52:00.480 --> 52:04.080
+ or some of these systems computation
+
+52:04.080 --> 52:05.960
+ needs to be converted to a graph.
+
+52:05.960 --> 52:07.400
+ So what's that process like?
+
+52:07.400 --> 52:08.920
+ What are the challenges there?
+
+52:08.920 --> 52:11.680
+ Yeah, so I'm tangentially involved in this.
+
+52:11.680 --> 52:15.240
+ But the way that it works with Autograph
+
+52:15.240 --> 52:21.600
+ is that you mark your function with a decorator.
+
+52:21.600 --> 52:24.280
+ And when Python calls it, that decorator is invoked.
+
+52:24.280 --> 52:28.240
+ And then it says, before I call this function,
+
+52:28.240 --> 52:29.480
+ you can transform it.
+
+52:29.480 --> 52:32.400
+ And so the way Autograph works is, as far as I understand,
+
+52:32.400 --> 52:34.440
+ is it actually uses the Python parser
+
+52:34.440 --> 52:37.160
+ to go parse that, turn into a syntax tree,
+
+52:37.160 --> 52:39.400
+ and now apply compiler techniques to, again,
+
+52:39.400 --> 52:42.320
+ transform this down into TensorFlow graphs.
+
+52:42.320 --> 52:45.880
+ And so you can think of it as saying, hey, I have an if statement.
+
+52:45.880 --> 52:48.800
+ I'm going to create an if node in the graph, like you say,
+
+52:48.800 --> 52:51.080
+ tf.cond.
+
+52:51.080 --> 52:53.000
+ You have a multiply.
+
+52:53.000 --> 52:55.320
+ Well, I'll turn that into a multiply node in the graph.
+
+52:55.320 --> 52:57.720
+ And it becomes this tree transformation.
+
+52:57.720 --> 53:01.280
+ So where does the Swift for TensorFlow come in?
+
+53:01.280 --> 53:04.720
+ Which is parallels.
+
+53:04.720 --> 53:06.960
+ For one, Swift is an interface.
+
+53:06.960 --> 53:09.200
+ Like Python is an interface with TensorFlow.
+
+53:09.200 --> 53:11.200
+ But it seems like there's a lot more going on
+
+53:11.200 --> 53:13.120
+ than just a different language interface.
+
+53:13.120 --> 53:15.240
+ There's optimization methodology.
+
+53:15.240 --> 53:19.560
+ So the TensorFlow world has a couple of different, what
+
+53:19.560 --> 53:21.240
+ I'd call front end technologies.
+
+53:21.240 --> 53:25.400
+ And so Swift, and Python, and Go, and Rust, and Julian,
+
+53:25.400 --> 53:29.360
+ all these things share the TensorFlow graphs
+
+53:29.360 --> 53:32.760
+ and all the runtime and everything that's later.
+
+53:32.760 --> 53:36.680
+ And so Swift for TensorFlow is merely another front end
+
+53:36.680 --> 53:40.680
+ for TensorFlow, just like any of these other systems are.
+
+53:40.680 --> 53:43.120
+ There's a major difference between, I would say,
+
+53:43.120 --> 53:44.640
+ three camps of technologies here.
+
+53:44.640 --> 53:46.920
+ There's Python, which is a special case,
+
+53:46.920 --> 53:49.280
+ because the vast majority of the community efforts
+
+53:49.280 --> 53:51.160
+ go into the Python interface.
+
+53:51.160 --> 53:53.000
+ And Python has its own approaches
+
+53:53.000 --> 53:55.800
+ for automatic differentiation, has its own APIs,
+
+53:55.800 --> 53:58.200
+ and all this kind of stuff.
+
+53:58.200 --> 54:00.240
+ There's Swift, which I'll talk about in a second.
+
+54:00.240 --> 54:02.080
+ And then there's kind of everything else.
+
+54:02.080 --> 54:05.440
+ And so the everything else are effectively language bindings.
+
+54:05.440 --> 54:08.000
+ So they call into the TensorFlow runtime.
+
+54:08.000 --> 54:10.960
+ But they usually don't have automatic differentiation,
+
+54:10.960 --> 54:14.760
+ or they usually don't provide anything other than APIs that
+
+54:14.760 --> 54:16.480
+ call the C APIs in TensorFlow.
+
+54:16.480 --> 54:18.400
+ And so they're kind of wrappers for that.
+
+54:18.400 --> 54:19.840
+ Swift is really kind of special.
+
+54:19.840 --> 54:22.800
+ And it's a very different approach.
+
+54:22.800 --> 54:25.360
+ Swift for TensorFlow, that is, is a very different approach,
+
+54:25.360 --> 54:26.920
+ because there we're saying, let's
+
+54:26.920 --> 54:28.440
+ look at all the problems that need
+
+54:28.440 --> 54:34.120
+ to be solved in the full stack of the TensorFlow compilation
+
+54:34.120 --> 54:35.680
+ process, if you think about it that way.
+
+54:35.680 --> 54:38.200
+ Because TensorFlow is fundamentally a compiler.
+
+54:38.200 --> 54:42.760
+ It takes models, and then it makes them go fast on hardware.
+
+54:42.760 --> 54:43.800
+ That's what a compiler does.
+
+54:43.800 --> 54:47.560
+ And it has a front end, it has an optimizer,
+
+54:47.560 --> 54:49.320
+ and it has many back ends.
+
+54:49.320 --> 54:51.680
+ And so if you think about it the right way,
+
+54:51.680 --> 54:54.760
+ or if you look at it in a particular way,
+
+54:54.760 --> 54:55.800
+ it is a compiler.
+
+54:59.280 --> 55:02.120
+ And so Swift is merely another front end.
+
+55:02.120 --> 55:05.560
+ But it's saying, and the design principle is saying,
+
+55:05.560 --> 55:08.200
+ let's look at all the problems that we face as machine
+
+55:08.200 --> 55:11.200
+ learning practitioners, and what is the best possible way
+
+55:11.200 --> 55:13.840
+ we can do that, given the fact that we can change literally
+
+55:13.840 --> 55:15.920
+ anything in this entire stack.
+
+55:15.920 --> 55:18.440
+ And Python, for example, where the vast majority
+
+55:18.440 --> 55:22.600
+ of the engineering and effort has gone into,
+
+55:22.600 --> 55:25.280
+ is constrained by being the best possible thing you can do
+
+55:25.280 --> 55:27.280
+ with a Python library.
+
+55:27.280 --> 55:29.280
+ There are no Python language features
+
+55:29.280 --> 55:32.520
+ that are added because of machine learning that I'm aware of.
+
+55:32.520 --> 55:35.080
+ They added a matrix multiplication operator with that,
+
+55:35.080 --> 55:38.280
+ but that's as close as you get.
+
+55:38.280 --> 55:41.400
+ And so with Swift, it's hard, but you
+
+55:41.400 --> 55:43.800
+ can add language features to the language,
+
+55:43.800 --> 55:46.080
+ and there's a community process for that.
+
+55:46.080 --> 55:48.000
+ And so we look at these things and say,
+
+55:48.000 --> 55:49.680
+ well, what is the right division of labor
+
+55:49.680 --> 55:52.000
+ between the human programmer and the compiler?
+
+55:52.000 --> 55:55.280
+ And Swift has a number of things that shift that balance.
+
+55:55.280 --> 56:00.520
+ So because it has a type system, for example,
+
+56:00.520 --> 56:03.280
+ it makes certain things possible for analysis of the code,
+
+56:03.280 --> 56:05.520
+ and the compiler can automatically
+
+56:05.520 --> 56:08.800
+ build graphs for you without you thinking about them.
+
+56:08.800 --> 56:10.520
+ That's a big deal for a programmer.
+
+56:10.520 --> 56:11.640
+ You just get free performance.
+
+56:11.640 --> 56:14.360
+ You get clustering and fusion and optimization,
+
+56:14.360 --> 56:17.440
+ things like that, without you as a programmer having
+
+56:17.440 --> 56:20.040
+ to manually do it because the compiler can do it for you.
+
+56:20.040 --> 56:22.200
+ Automatic differentiation is another big deal,
+
+56:22.200 --> 56:25.440
+ and I think one of the key contributions of the Swift
+
+56:25.440 --> 56:29.600
+ for TensorFlow project is that there's
+
+56:29.600 --> 56:32.200
+ this entire body of work on automatic differentiation that
+
+56:32.200 --> 56:34.240
+ dates back to the Fortran days.
+
+56:34.240 --> 56:36.360
+ People doing a tremendous amount of numerical computing
+
+56:36.360 --> 56:39.800
+ in Fortran used to write what they call source to source
+
+56:39.800 --> 56:43.600
+ translators, where you take a bunch of code, shove it
+
+56:43.600 --> 56:47.280
+ into a mini compiler, and it would push out more Fortran
+
+56:47.280 --> 56:50.200
+ code, but it would generate the backwards passes
+
+56:50.200 --> 56:53.000
+ for your functions for you, the derivatives.
+
+56:53.000 --> 56:57.840
+ And so in that work in the 70s, a tremendous number
+
+56:57.840 --> 57:01.160
+ of optimizations, a tremendous number of techniques
+
+57:01.160 --> 57:02.920
+ for fixing numerical instability,
+
+57:02.920 --> 57:05.080
+ and other kinds of problems were developed,
+
+57:05.080 --> 57:07.600
+ but they're very difficult to port into a world
+
+57:07.600 --> 57:11.280
+ where in eager execution, you get an op by op at a time.
+
+57:11.280 --> 57:13.280
+ Like, you need to be able to look at an entire function
+
+57:13.280 --> 57:15.600
+ and be able to reason about what's going on.
+
+57:15.600 --> 57:18.360
+ And so when you have a language integrated
+
+57:18.360 --> 57:20.480
+ automatic differentiation, which is one of the things
+
+57:20.480 --> 57:22.760
+ that the Swift project is focusing on,
+
+57:22.760 --> 57:25.720
+ you can open all these techniques and reuse them
+
+57:25.720 --> 57:30.160
+ in familiar ways, but the language integration piece
+
+57:30.160 --> 57:33.280
+ has a bunch of design room in it, and it's also complicated.
+
+57:33.280 --> 57:34.920
+ The other piece of the puzzle here,
+
+57:34.920 --> 57:37.040
+ this kind of interesting is TPUs at Google.
+
+57:37.040 --> 57:37.880
+ Yes.
+
+57:37.880 --> 57:40.200
+ So, you know, we're in a new world with deep learning.
+
+57:40.200 --> 57:43.000
+ It's constantly changing, and I imagine
+
+57:43.000 --> 57:46.400
+ without disclosing anything, I imagine, you know,
+
+57:46.400 --> 57:48.480
+ you're still innovating on the TPU front too.
+
+57:48.480 --> 57:49.320
+ Indeed.
+
+57:49.320 --> 57:52.280
+ So how much sort of interplays there are
+
+57:52.280 --> 57:54.440
+ between software and hardware and trying to figure out
+
+57:54.440 --> 57:56.760
+ how to gather, move towards an optimized solution.
+
+57:56.760 --> 57:57.800
+ There's an incredible amount.
+
+57:57.800 --> 57:59.520
+ So we're on our third generation of TPUs,
+
+57:59.520 --> 58:02.800
+ which are now 100 petaflops in a very large
+
+58:02.800 --> 58:07.800
+ liquid cooled box, virtual box with no cover.
+
+58:07.800 --> 58:11.320
+ And as you might imagine, we're not out of ideas yet.
+
+58:11.320 --> 58:14.400
+ The great thing about TPUs is that they're
+
+58:14.400 --> 58:17.640
+ a perfect example of hardware software co design.
+
+58:17.640 --> 58:19.840
+ And so it's about saying, what hardware
+
+58:19.840 --> 58:23.280
+ do we build to solve certain classes of machine learning
+
+58:23.280 --> 58:23.920
+ problems?
+
+58:23.920 --> 58:26.360
+ Well, the algorithms are changing.
+
+58:26.360 --> 58:30.480
+ Like the hardware takes some cases years to produce, right?
+
+58:30.480 --> 58:34.160
+ And so you have to make bets and decide what is going to happen.
+
+58:34.160 --> 58:37.280
+ And so what is the best way to spend the transistors
+
+58:37.280 --> 58:41.560
+ to get the maximum performance per watt or area per cost
+
+58:41.560 --> 58:44.120
+ or whatever it is that you're optimizing for?
+
+58:44.120 --> 58:46.600
+ And so one of the amazing things about TPUs
+
+58:46.600 --> 58:50.040
+ is this numeric format called B Float 16.
+
+58:50.040 --> 58:54.160
+ B Float 16 is a compressed 16 bit floating point format,
+
+58:54.160 --> 58:56.120
+ but it puts the bits in different places.
+
+58:56.120 --> 58:59.000
+ In numeric terms, it has a smaller mantissa
+
+58:59.000 --> 59:00.480
+ and a larger exponent.
+
+59:00.480 --> 59:03.000
+ That means that it's less precise,
+
+59:03.000 --> 59:06.120
+ but it can represent larger ranges of values, which
+
+59:06.120 --> 59:08.640
+ in the machine learning context is really important and useful.
+
+59:08.640 --> 59:13.120
+ Because sometimes you have very small gradients
+
+59:13.120 --> 59:17.600
+ you want to accumulate and very, very small numbers that
+
+59:17.600 --> 59:20.520
+ are important to move things as you're learning.
+
+59:20.520 --> 59:23.240
+ But sometimes you have very large magnitude numbers as well.
+
+59:23.240 --> 59:26.880
+ And B Float 16 is not as precise.
+
+59:26.880 --> 59:28.240
+ The mantissa is small.
+
+59:28.240 --> 59:30.360
+ But it turns out the machine learning algorithms actually
+
+59:30.360 --> 59:31.640
+ want to generalize.
+
+59:31.640 --> 59:34.320
+ And so there's theories that this actually
+
+59:34.320 --> 59:36.440
+ increases the ability for the network
+
+59:36.440 --> 59:38.040
+ to generalize across data sets.
+
+59:38.040 --> 59:41.160
+ And regardless of whether it's good or bad,
+
+59:41.160 --> 59:42.640
+ it's much cheaper at the hardware level
+
+59:42.640 --> 59:48.160
+ to implement because the area and time of a multiplier
+
+59:48.160 --> 59:50.880
+ is n squared in the number of bits in the mantissa,
+
+59:50.880 --> 59:53.360
+ but it's linear with size of the exponent.
+
+59:53.360 --> 59:56.360
+ And you're connected to both efforts here, both on the hardware
+
+59:56.360 --> 59:57.200
+ and the software side?
+
+59:57.200 --> 59:59.240
+ Yeah, and so that was a breakthrough coming
+
+59:59.240 --> 1:00:01.800
+ from the research side and people working
+
+1:00:01.800 --> 1:00:06.000
+ on optimizing network transport of weights
+
+1:00:06.000 --> 1:00:08.280
+ across a network originally and trying
+
+1:00:08.280 --> 1:00:10.160
+ to find ways to compress that.
+
+1:00:10.160 --> 1:00:12.160
+ But then it got burned into silicon.
+
+1:00:12.160 --> 1:00:15.320
+ And it's a key part of what makes TPU performance so amazing.
+
+1:00:15.320 --> 1:00:17.880
+ And great.
+
+1:00:17.880 --> 1:00:20.640
+ Now, TPUs have many different aspects that are important.
+
+1:00:20.640 --> 1:00:25.080
+ But the co design between the low level compiler bits
+
+1:00:25.080 --> 1:00:27.360
+ and the software bits and the algorithms
+
+1:00:27.360 --> 1:00:28.640
+ is all super important.
+
+1:00:28.640 --> 1:00:32.880
+ And it's this amazing trifecta that only Google can do.
+
+1:00:32.880 --> 1:00:34.360
+ Yeah, that's super exciting.
+
+1:00:34.360 --> 1:00:38.440
+ So can you tell me about MLIR project,
+
+1:00:38.440 --> 1:00:41.400
+ previously the secretive one?
+
+1:00:41.400 --> 1:00:43.000
+ Yeah, so MLIR is a project that we
+
+1:00:43.000 --> 1:00:46.960
+ announced at a compiler conference three weeks ago
+
+1:00:46.960 --> 1:00:50.880
+ or something at the Compilers for Machine Learning Conference.
+
+1:00:50.880 --> 1:00:53.280
+ Basically, again, if you look at TensorFlow as a compiler
+
+1:00:53.280 --> 1:00:55.040
+ stack, it has a number of compiler algorithms
+
+1:00:55.040 --> 1:00:56.000
+ within it.
+
+1:00:56.000 --> 1:00:57.480
+ It also has a number of compilers
+
+1:00:57.480 --> 1:00:58.880
+ that get embedded into it.
+
+1:00:58.880 --> 1:01:00.320
+ And they're made by different vendors.
+
+1:01:00.320 --> 1:01:04.640
+ For example, Google has XLA, which is a great compiler system.
+
+1:01:04.640 --> 1:01:08.680
+ NVIDIA has TensorFlow RT, Intel has NGraph.
+
+1:01:08.680 --> 1:01:10.640
+ There's a number of these different compiler systems.
+
+1:01:10.640 --> 1:01:13.600
+ And they're very hardware specific.
+
+1:01:13.600 --> 1:01:16.280
+ And they're trying to solve different parts of the problems.
+
+1:01:16.280 --> 1:01:18.920
+ But they're all kind of similar in a sense
+
+1:01:18.920 --> 1:01:20.680
+ of they want to integrate with TensorFlow.
+
+1:01:20.680 --> 1:01:22.720
+ Now, TensorFlow has an optimizer.
+
+1:01:22.720 --> 1:01:25.480
+ And it has these different code generation technologies
+
+1:01:25.480 --> 1:01:26.360
+ built in.
+
+1:01:26.360 --> 1:01:28.680
+ The idea of MLIR is to build a common infrastructure
+
+1:01:28.680 --> 1:01:31.040
+ to support all these different subsystems.
+
+1:01:31.040 --> 1:01:34.120
+ And initially, it's to be able to make it so that they all
+
+1:01:34.120 --> 1:01:34.840
+ plug in together.
+
+1:01:34.840 --> 1:01:37.800
+ And they can share a lot more code and can be reusable.
+
+1:01:37.800 --> 1:01:40.960
+ But over time, we hope that the industry will start
+
+1:01:40.960 --> 1:01:42.440
+ collaborating and sharing code.
+
+1:01:42.440 --> 1:01:45.200
+ And instead of reinventing the same things over and over again,
+
+1:01:45.200 --> 1:01:49.240
+ that we can actually foster some of that working together
+
+1:01:49.240 --> 1:01:51.520
+ to solve common problem energy that
+
+1:01:51.520 --> 1:01:54.440
+ has been useful in the compiler field before.
+
+1:01:54.440 --> 1:01:57.000
+ Beyond that, MLIR is some people have
+
+1:01:57.000 --> 1:01:59.240
+ joked that it's kind of LLVM2.
+
+1:01:59.240 --> 1:02:01.760
+ It learns a lot about what LLVM has been good
+
+1:02:01.760 --> 1:02:04.280
+ and what LLVM has done wrong.
+
+1:02:04.280 --> 1:02:06.800
+ And it's a chance to fix that.
+
+1:02:06.800 --> 1:02:09.320
+ And also, there are challenges in the LLVM ecosystem
+
+1:02:09.320 --> 1:02:11.840
+ as well, where LLVM is very good at the thing
+
+1:02:11.840 --> 1:02:12.680
+ it was designed to do.
+
+1:02:12.680 --> 1:02:15.480
+ But 20 years later, the world has changed.
+
+1:02:15.480 --> 1:02:17.560
+ And people are trying to solve higher level problems.
+
+1:02:17.560 --> 1:02:20.280
+ And we need some new technology.
+
+1:02:20.280 --> 1:02:24.680
+ And what's the future of open source in this context?
+
+1:02:24.680 --> 1:02:25.680
+ Very soon.
+
+1:02:25.680 --> 1:02:27.440
+ So it is not yet open source.
+
+1:02:27.440 --> 1:02:29.360
+ But it will be, hopefully, the next couple of months.
+
+1:02:29.360 --> 1:02:30.960
+ So you still believe in the value of open source
+
+1:02:30.960 --> 1:02:31.560
+ and these kinds of kinds?
+
+1:02:31.560 --> 1:02:32.400
+ Oh, yeah, absolutely.
+
+1:02:32.400 --> 1:02:36.080
+ And I think that the TensorFlow community at large
+
+1:02:36.080 --> 1:02:37.640
+ fully believes in open source.
+
+1:02:37.640 --> 1:02:40.080
+ So I mean, there is a difference between Apple,
+
+1:02:40.080 --> 1:02:43.480
+ where you were previously in Google, now in spirit and culture.
+
+1:02:43.480 --> 1:02:45.440
+ And I would say the open sourcing of TensorFlow
+
+1:02:45.440 --> 1:02:48.360
+ was a seminal moment in the history of software.
+
+1:02:48.360 --> 1:02:51.640
+ Because here's this large company releasing
+
+1:02:51.640 --> 1:02:55.880
+ a very large code base that's open sourcing.
+
+1:02:55.880 --> 1:02:57.880
+ What are your thoughts on that?
+
+1:02:57.880 --> 1:03:00.800
+ How happy or not were you to see that kind
+
+1:03:00.800 --> 1:03:02.880
+ of degree of open sourcing?
+
+1:03:02.880 --> 1:03:05.320
+ So between the two, I prefer the Google approach,
+
+1:03:05.320 --> 1:03:07.800
+ if that's what you're saying.
+
+1:03:07.800 --> 1:03:12.360
+ The Apple approach makes sense given the historical context
+
+1:03:12.360 --> 1:03:13.360
+ that Apple came from.
+
+1:03:13.360 --> 1:03:15.720
+ But that's been 35 years ago.
+
+1:03:15.720 --> 1:03:18.160
+ And I think that Apple is definitely adapting.
+
+1:03:18.160 --> 1:03:20.240
+ And the way I look at it is that there's
+
+1:03:20.240 --> 1:03:23.120
+ different kinds of concerns in the space, right?
+
+1:03:23.120 --> 1:03:24.840
+ It is very rational for a business
+
+1:03:24.840 --> 1:03:28.680
+ to care about making money.
+
+1:03:28.680 --> 1:03:31.600
+ That fundamentally is what a business is about, right?
+
+1:03:31.600 --> 1:03:34.280
+ But I think it's also incredibly realistic
+
+1:03:34.280 --> 1:03:36.320
+ to say it's not your string library that's
+
+1:03:36.320 --> 1:03:38.040
+ the thing that's going to make you money.
+
+1:03:38.040 --> 1:03:41.440
+ It's going to be the amazing UI product differentiating
+
+1:03:41.440 --> 1:03:42.880
+ features and other things like that
+
+1:03:42.880 --> 1:03:45.200
+ that you build on top of your string library.
+
+1:03:45.200 --> 1:03:49.480
+ And so keeping your string library proprietary and secret
+
+1:03:49.480 --> 1:03:53.480
+ and things like that isn't maybe not the important thing
+
+1:03:53.480 --> 1:03:54.680
+ anymore, right?
+
+1:03:54.680 --> 1:03:57.720
+ Or before, platforms were different, right?
+
+1:03:57.720 --> 1:04:01.480
+ And even 15 years ago, things were a little bit different.
+
+1:04:01.480 --> 1:04:02.880
+ But the world is changing.
+
+1:04:02.880 --> 1:04:05.280
+ So Google strikes a very good balance, I think.
+
+1:04:05.280 --> 1:04:08.680
+ And I think that TensorFlow being open source
+
+1:04:08.680 --> 1:04:12.000
+ really changed the entire machine learning field
+
+1:04:12.000 --> 1:04:14.080
+ and it caused a revolution in its own right.
+
+1:04:14.080 --> 1:04:17.560
+ And so I think it's amazingly forward looking
+
+1:04:17.560 --> 1:04:21.520
+ because I could have imagined, and I wasn't at Google at the time,
+
+1:04:21.520 --> 1:04:23.760
+ but I could imagine a different context in a different world
+
+1:04:23.760 --> 1:04:26.520
+ where a company says, machine learning is critical
+
+1:04:26.520 --> 1:04:27.960
+ to what we're doing, we're not going
+
+1:04:27.960 --> 1:04:29.600
+ to give it to other people, right?
+
+1:04:29.600 --> 1:04:35.840
+ And so that decision is a profoundly brilliant insight
+
+1:04:35.840 --> 1:04:38.320
+ that I think has really led to the world being better
+
+1:04:38.320 --> 1:04:40.160
+ and better for Google as well.
+
+1:04:40.160 --> 1:04:42.200
+ And has all kinds of ripple effects.
+
+1:04:42.200 --> 1:04:45.400
+ I think it is really, I mean, you can't
+
+1:04:45.400 --> 1:04:49.800
+ understate Google deciding how profound that is for software.
+
+1:04:49.800 --> 1:04:50.840
+ It's awesome.
+
+1:04:50.840 --> 1:04:54.880
+ Well, and again, I can understand the concern
+
+1:04:54.880 --> 1:04:57.640
+ about if we release our machine learning software,
+
+1:04:57.640 --> 1:05:00.400
+ our competitors could go faster.
+
+1:05:00.400 --> 1:05:02.480
+ But on the other hand, I think that open sourcing TensorFlow
+
+1:05:02.480 --> 1:05:03.960
+ has been fantastic for Google.
+
+1:05:03.960 --> 1:05:09.080
+ And I'm sure that decision was very nonobvious at the time,
+
+1:05:09.080 --> 1:05:11.480
+ but I think it's worked out very well.
+
+1:05:11.480 --> 1:05:13.200
+ So let's try this real quick.
+
+1:05:13.200 --> 1:05:15.600
+ You were at Tesla for five months
+
+1:05:15.600 --> 1:05:17.600
+ as the VP of autopilot software.
+
+1:05:17.600 --> 1:05:20.480
+ You led the team during the transition from H Hardware
+
+1:05:20.480 --> 1:05:22.320
+ 1 to Hardware 2.
+
+1:05:22.320 --> 1:05:23.480
+ I have a couple of questions.
+
+1:05:23.480 --> 1:05:26.320
+ So one, first of all, to me, that's
+
+1:05:26.320 --> 1:05:28.520
+ one of the bravest engineering decisions
+
+1:05:28.520 --> 1:05:33.320
+ undertaking sort of like, undertaking really ever
+
+1:05:33.320 --> 1:05:36.000
+ in the automotive industry to me, software wise,
+
+1:05:36.000 --> 1:05:37.440
+ starting from scratch.
+
+1:05:37.440 --> 1:05:39.320
+ It's a really brave engineering decision.
+
+1:05:39.320 --> 1:05:42.760
+ So my one question is there is, what was that like?
+
+1:05:42.760 --> 1:05:43.960
+ What was the challenge of that?
+
+1:05:43.960 --> 1:05:45.760
+ Do you mean the career decision of jumping
+
+1:05:45.760 --> 1:05:48.880
+ from a comfortable good job into the unknown?
+
+1:05:48.880 --> 1:05:51.560
+ That combined, so at the individual level,
+
+1:05:51.560 --> 1:05:54.640
+ you making that decision.
+
+1:05:54.640 --> 1:05:58.040
+ And then when you show up, it's a really hard engineering
+
+1:05:58.040 --> 1:05:58.840
+ problem.
+
+1:05:58.840 --> 1:06:04.880
+ So you could just stay, maybe slow down, say, Hardware 1,
+
+1:06:04.880 --> 1:06:06.560
+ or those kinds of decisions.
+
+1:06:06.560 --> 1:06:10.160
+ So just taking it full on, let's do this from scratch.
+
+1:06:10.160 --> 1:06:11.080
+ What was that like?
+
+1:06:11.080 --> 1:06:12.680
+ Well, so I mean, I don't think Tesla
+
+1:06:12.680 --> 1:06:15.720
+ has a culture of taking things slow and seeing how it goes.
+
+1:06:15.720 --> 1:06:18.080
+ So one of the things that attracted me about Tesla
+
+1:06:18.080 --> 1:06:19.240
+ is it's very much a gung ho.
+
+1:06:19.240 --> 1:06:20.200
+ Let's change the world.
+
+1:06:20.200 --> 1:06:21.640
+ Let's figure it out kind of a place.
+
+1:06:21.640 --> 1:06:25.680
+ And so I have a huge amount of respect for that.
+
+1:06:25.680 --> 1:06:28.720
+ Tesla has done very smart things with Hardware 1
+
+1:06:28.720 --> 1:06:29.440
+ in particular.
+
+1:06:29.440 --> 1:06:32.760
+ And the Hardware 1 design was originally designed
+
+1:06:32.760 --> 1:06:37.280
+ to be very simple automation features in the car
+
+1:06:37.280 --> 1:06:39.840
+ for like traffic aware cruise control and things like that.
+
+1:06:39.840 --> 1:06:42.680
+ And the fact that they were able to effectively feature
+
+1:06:42.680 --> 1:06:47.760
+ creep it into lane holding and a very useful driver assistance
+
+1:06:47.760 --> 1:06:50.120
+ feature is pretty astounding, particularly given
+
+1:06:50.120 --> 1:06:52.560
+ the details of the hardware.
+
+1:06:52.560 --> 1:06:54.640
+ Hardware 2 built on that in a lot of ways.
+
+1:06:54.640 --> 1:06:56.800
+ And the challenge there was that they were transitioning
+
+1:06:56.800 --> 1:07:00.080
+ from a third party provided vision stack
+
+1:07:00.080 --> 1:07:01.760
+ to an in house built vision stack.
+
+1:07:01.760 --> 1:07:05.680
+ And so for the first step, which I mostly helped with,
+
+1:07:05.680 --> 1:07:08.520
+ was getting onto that new vision stack.
+
+1:07:08.520 --> 1:07:10.880
+ And that was very challenging.
+
+1:07:10.880 --> 1:07:14.000
+ And it was time critical for various reasons.
+
+1:07:14.000 --> 1:07:15.000
+ And it was a big leap.
+
+1:07:15.000 --> 1:07:17.560
+ But it was fortunate that it built on a lot of the knowledge
+
+1:07:17.560 --> 1:07:20.880
+ and expertise in the team that had built Hardware 1's
+
+1:07:20.880 --> 1:07:22.920
+ driver assistance features.
+
+1:07:22.920 --> 1:07:25.400
+ So you spoke in a collected and kind way
+
+1:07:25.400 --> 1:07:26.720
+ about your time at Tesla.
+
+1:07:26.720 --> 1:07:30.280
+ But it was ultimately not a good fit Elon Musk.
+
+1:07:30.280 --> 1:07:33.440
+ We've talked on this podcast, several guests of the course.
+
+1:07:33.440 --> 1:07:36.480
+ Elon Musk continues to do some of the most bold and innovative
+
+1:07:36.480 --> 1:07:38.800
+ engineering work in the world at times
+
+1:07:38.800 --> 1:07:41.320
+ at the cost to some of the members of the Tesla team.
+
+1:07:41.320 --> 1:07:45.120
+ What did you learn about this working in this chaotic world
+
+1:07:45.120 --> 1:07:46.720
+ with Elon?
+
+1:07:46.720 --> 1:07:50.560
+ Yeah, so I guess I would say that when I was at Tesla,
+
+1:07:50.560 --> 1:07:54.480
+ I experienced and saw the highest degree of turnover
+
+1:07:54.480 --> 1:07:58.280
+ I'd ever seen in a company, which was a bit of a shock.
+
+1:07:58.280 --> 1:08:00.520
+ But one of the things I learned and I came to respect
+
+1:08:00.520 --> 1:08:03.400
+ is that Elon's able to attract amazing talent
+
+1:08:03.400 --> 1:08:05.640
+ because he has a very clear vision of the future.
+
+1:08:05.640 --> 1:08:07.200
+ And he can get people to buy into it
+
+1:08:07.200 --> 1:08:09.840
+ because they want that future to happen.
+
+1:08:09.840 --> 1:08:11.840
+ And the power of vision is something
+
+1:08:11.840 --> 1:08:14.200
+ that I have a tremendous amount of respect for.
+
+1:08:14.200 --> 1:08:17.600
+ And I think that Elon is fairly singular in the world
+
+1:08:17.600 --> 1:08:22.320
+ in terms of the things he's able to get people to believe in.
+
+1:08:22.320 --> 1:08:27.360
+ And there are many people that stand in the street corner
+
+1:08:27.360 --> 1:08:29.320
+ and say, ah, we're going to go to Mars, right?
+
+1:08:29.320 --> 1:08:31.600
+ But then there are a few people that
+
+1:08:31.600 --> 1:08:35.200
+ can get others to buy into it and believe in, build the path
+
+1:08:35.200 --> 1:08:36.160
+ and make it happen.
+
+1:08:36.160 --> 1:08:39.120
+ And so I respect that.
+
+1:08:39.120 --> 1:08:41.000
+ I don't respect all of his methods,
+
+1:08:41.000 --> 1:08:44.960
+ but I have a huge amount of respect for that.
+
+1:08:44.960 --> 1:08:46.840
+ You've mentioned in a few places,
+
+1:08:46.840 --> 1:08:50.400
+ including in this context, working hard.
+
+1:08:50.400 --> 1:08:51.960
+ What does it mean to work hard?
+
+1:08:51.960 --> 1:08:53.480
+ And when you look back at your life,
+
+1:08:53.480 --> 1:08:59.040
+ what were some of the most brutal periods of having
+
+1:08:59.040 --> 1:09:03.360
+ to really put everything you have into something?
+
+1:09:03.360 --> 1:09:05.040
+ Yeah, good question.
+
+1:09:05.040 --> 1:09:07.480
+ So working hard can be defined a lot of different ways.
+
+1:09:07.480 --> 1:09:08.680
+ So a lot of hours.
+
+1:09:08.680 --> 1:09:12.440
+ And so that is true.
+
+1:09:12.440 --> 1:09:14.480
+ The thing to me that's the hardest
+
+1:09:14.480 --> 1:09:18.720
+ is both being short term focused on delivering and executing
+
+1:09:18.720 --> 1:09:21.080
+ and making a thing happen, while also thinking
+
+1:09:21.080 --> 1:09:24.360
+ about the longer term and trying to balance that, right?
+
+1:09:24.360 --> 1:09:28.480
+ Because if you are myopically focused on solving a task
+
+1:09:28.480 --> 1:09:31.920
+ and getting that done and only think about that incremental
+
+1:09:31.920 --> 1:09:34.640
+ next step, you will miss the next big hill
+
+1:09:34.640 --> 1:09:36.360
+ you should jump over to, right?
+
+1:09:36.360 --> 1:09:38.000
+ And so I've been really fortunate
+
+1:09:38.000 --> 1:09:42.080
+ that I've been able to kind of oscillate between the two.
+
+1:09:42.080 --> 1:09:45.600
+ And historically at Apple, for example,
+
+1:09:45.600 --> 1:09:47.080
+ that was made possible because I was
+
+1:09:47.080 --> 1:09:49.080
+ able to work with some really amazing people and build up
+
+1:09:49.080 --> 1:09:53.760
+ teams and leadership structures and allow
+
+1:09:53.760 --> 1:09:57.120
+ them to grow in their careers and take on responsibility,
+
+1:09:57.120 --> 1:10:00.080
+ thereby freeing up me to be a little bit crazy
+
+1:10:00.080 --> 1:10:02.960
+ and thinking about the next thing.
+
+1:10:02.960 --> 1:10:04.640
+ And so it's a lot of that.
+
+1:10:04.640 --> 1:10:06.760
+ But it's also about with the experience
+
+1:10:06.760 --> 1:10:10.120
+ you make connections that other people don't necessarily make.
+
+1:10:10.120 --> 1:10:12.960
+ And so I think that's a big part as well.
+
+1:10:12.960 --> 1:10:16.040
+ But the bedrock is just a lot of hours.
+
+1:10:16.040 --> 1:10:19.720
+ And that's OK with me.
+
+1:10:19.720 --> 1:10:21.480
+ There's different theories on work life balance.
+
+1:10:21.480 --> 1:10:25.160
+ And my theory for myself, which I do not project onto the team,
+
+1:10:25.160 --> 1:10:28.480
+ but my theory for myself is that I
+
+1:10:28.480 --> 1:10:30.400
+ want to love what I'm doing and work really hard.
+
+1:10:30.400 --> 1:10:33.960
+ And my purpose, I feel like, and my goal
+
+1:10:33.960 --> 1:10:36.240
+ is to change the world and make it a better place.
+
+1:10:36.240 --> 1:10:40.000
+ And that's what I'm really motivated to do.
+
+1:10:40.000 --> 1:10:44.760
+ So last question, LLVM logo is a dragon.
+
+1:10:44.760 --> 1:10:46.760
+ You explained that this is because dragons
+
+1:10:46.760 --> 1:10:50.320
+ have connotations of power, speed, intelligence.
+
+1:10:50.320 --> 1:10:53.320
+ It can also be sleek, elegant, and modular,
+
+1:10:53.320 --> 1:10:56.280
+ though you remove the modular part.
+
+1:10:56.280 --> 1:10:58.920
+ What is your favorite dragon related character
+
+1:10:58.920 --> 1:11:01.480
+ from fiction, video, or movies?
+
+1:11:01.480 --> 1:11:03.840
+ So those are all very kind ways of explaining it.
+
+1:11:03.840 --> 1:11:06.200
+ Do you want to know the real reason it's a dragon?
+
+1:11:06.200 --> 1:11:07.000
+ Yeah.
+
+1:11:07.000 --> 1:11:07.920
+ Is that better?
+
+1:11:07.920 --> 1:11:11.040
+ So there is a seminal book on compiler design
+
+1:11:11.040 --> 1:11:12.480
+ called The Dragon Book.
+
+1:11:12.480 --> 1:11:16.280
+ And so this is a really old now book on compilers.
+
+1:11:16.280 --> 1:11:22.040
+ And so the Dragon logo for LLVM came about because at Apple,
+
+1:11:22.040 --> 1:11:24.720
+ we kept talking about LLVM related technologies,
+
+1:11:24.720 --> 1:11:26.960
+ and there's no logo to put on a slide.
+
+1:11:26.960 --> 1:11:28.440
+ And we're like, what do we do?
+
+1:11:28.440 --> 1:11:30.000
+ And somebody's like, well, what kind of logo
+
+1:11:30.000 --> 1:11:32.160
+ should a compiler technology have?
+
+1:11:32.160 --> 1:11:33.320
+ And I'm like, I don't know.
+
+1:11:33.320 --> 1:11:37.280
+ I mean, the dragon is the best thing that we've got.
+
+1:11:37.280 --> 1:11:40.600
+ And Apple somehow magically came up with the logo.
+
+1:11:40.600 --> 1:11:43.240
+ And it was a great thing, and the whole community
+
+1:11:43.240 --> 1:11:44.000
+ rallied around it.
+
+1:11:44.000 --> 1:11:46.840
+ And then it got better as other graphic designers got
+
+1:11:46.840 --> 1:11:47.320
+ involved.
+
+1:11:47.320 --> 1:11:49.280
+ But that's originally where it came from.
+
+1:11:49.280 --> 1:11:50.080
+ The story.
+
+1:11:50.080 --> 1:11:53.960
+ Is there dragons from fiction that you connect with?
+
+1:11:53.960 --> 1:11:58.000
+ That Game of Thrones, Lord of the Rings, that kind of thing?
+
+1:11:58.000 --> 1:11:59.120
+ Lord of the Rings is great.
+
+1:11:59.120 --> 1:12:01.440
+ I also like role playing games and things like computer
+
+1:12:01.440 --> 1:12:02.160
+ role playing games.
+
+1:12:02.160 --> 1:12:03.600
+ And so dragons often show up in there.
+
+1:12:03.600 --> 1:12:07.080
+ But it really comes back to the book.
+
+1:12:07.080 --> 1:12:08.480
+ Oh, no, we need a thing.
+
+1:12:08.480 --> 1:12:09.880
+ We need a lot to do.
+
+1:12:09.880 --> 1:12:13.640
+ And hilariously, one of the funny things about LLVM
+
+1:12:13.640 --> 1:12:19.400
+ is that my wife, who's amazing, runs the LLVM foundation.
+
+1:12:19.400 --> 1:12:21.040
+ And she goes to Grace Hopper, and is
+
+1:12:21.040 --> 1:12:22.480
+ trying to get more women involved.
+
+1:12:22.480 --> 1:12:24.600
+ And she's also a compiler engineer.
+
+1:12:24.600 --> 1:12:26.040
+ So she's trying to get other women
+
+1:12:26.040 --> 1:12:28.120
+ to get interested in compilers and things like this.
+
+1:12:28.120 --> 1:12:29.960
+ And so she hands out the stickers.
+
+1:12:29.960 --> 1:12:34.240
+ And people like the LLVM sticker because of Game of Thrones.
+
+1:12:34.240 --> 1:12:36.800
+ And so sometimes culture has this helpful effect
+
+1:12:36.800 --> 1:12:41.040
+ to get the next generation of compiler engineers engaged
+
+1:12:41.040 --> 1:12:42.320
+ with the cause.
+
+1:12:42.320 --> 1:12:43.240
+ OK, awesome.
+
+1:12:43.240 --> 1:12:44.680
+ Grace, thanks so much for talking with us.
+
+1:12:44.680 --> 1:13:07.440
+ It's been great talking with you.
+