Bjarne Stroustrup: C++ | Lex Fridman Podcast #48
the following is a conversation with BR install stroke he's the creator of C++ programming language that after 40 years is still one of the most popular and powerful languages in the world it's focused on fast stable robust code underlies many of the biggest systems in the world that we have come to rely on as a society if you're watching this on YouTube for example many of the critical backend components of YouTube are written in C++ same goes for Google Facebook Amazon Twitter most Microsoft applications Adobe applications most database systems and most physical systems that operate in the real world like cars robots rockets that launches into space and one day when landis on Mars C++ also happens to be the language that I used more than any other in my life I've written several hundred thousand lines of C++ source code of course lines of source code don't mean much but they do give hints of my personal journey through the world of software I've enjoyed watching the development of C++ as a programming language leading up to the big update in a standard in 2011 and those that followed in 1417 and told me the new C++ 20 standard hopefully coming out next year this is the artificial intelligence podcast if you enjoy it subscribe I knew to give it five stars and iTunes supported on patreon or simply connect with me on Twitter Alex Friedman spelled Fri D ma a.m. and now here's my conversation with Bjorn straw stroke what was the first program you've ever written do you remember it was my second year in university first year of computer science and it was an alcohol 60 I calculated the shape of super lips and then connected points on the on the perimeter creating star patterns it was with a with a wedding on paper printer and I was in college university yeah yeah I learned to program the second year in university and what was the first programming language if I may ask it this way that you fell in love with I I think I'll call 60 and after that I remember I remember snowboard I remember Fortran didn't fall in love with that I remember Pascal didn't fall in love with that it all gotten away of me and then I just covered a simpler and that was much more fun and from there I went to micro micro code so you were drawn to the you found the low level stuff beautiful I went through a lot of languages and then I spent significant time in in a simpler and micro code that was sort of the first really profitable things I paid for my Master's actually and then I discovered Simula which was absolutely great Simula simulation of Albert 60 done primarily for simulation but basically they invented up to Tory into programming at inheritance and runtime polymorphism when they were while they were doing it and that was a language that taught me that you could have the sort of the problems of a program grow with size of the program rather than with the square of the size of program that is you can actually module arise very nicely and that that that was a surprise to me it was also a surprise to me that a stricter type system than Pascal's was helpful whereas Pascal's type system got in my way all the time so you need a strong type system to organize your code well which has to be extensible and flexible let's get into the details a little bit what kind of if you remember what kind of type system to Pascal have what type system typing system did the Algol 60 have basically Pascal was sort of the simplest language that Niklaus yet could define that served the needs of Niklaus Viet at the time and it has a sort of our highly moral tone to it that is if you can say it in Pascal it's good and if you can't it's not so good whereas Simula large is basically to build your own type system so instead of trying to fit yourself into Niklaus pierce'sworld Christ knew God's language and Orion dance language allowed you to build your own so it's sort of close to the original idea of you you you build a domain-specific language as a matter of fact what you build is a set of types and relations among types that allows you to express something that suitable for an application the when you say types the stuff you're saying has echoes of object-oriented programming Kjetil they invented it every language that uses the word class for type is a descendant of Simula directly or indirectly Christ knew gone orientale were mathematicians and they didn't think in terms of type C but they understood sets and classes of elements and so they caught their types classes and basically in C++ as in similar classes are user defined type so can you try the impossible task and give a brief history of programming languages from your perspective so we started with Algol 60 Simula Pascal but that's just the 60s and seven I can try the most sort of interesting and major improvement of programming languages was Fortran the first Fortran because before that all code was written for a specific machine and each specific machine had a language a simply language or cross embro or some extension of that idea but it you are writing for a specific machine in the term in the language of that machine and parker's and his team at IBM built a language that would allow you to to write what you really wanted that is you can write it in a language that was natural for people now these people happen to be engineers and physicists so the language I came out was somewhat unusual for the rest of the world but basically they said formula translation because they wanted to have the mathematical formulas translated into the machine and as a side effect they got portability because now they are writing in the terms that the humans used and the way humans thought and then they had a program that translated it into the machines needs and that was new and that was great and it's something to remember we want to raise the language to the human level but we don't want to lose the efficiency so and the last first step towards the human that was the first step and of course they were very particular kind of humans business people MIT is different so they got COBOL instead and etc etc and simular came out no let's not go to simulate yet let's go to Al Gore Fortran didn't have at the time the notions of not a precise notion of type not a precise notion of scope not a set of translation phases that was what we have today lexical since heck semantics it was sort of a bit of a model in the early days but hey they're just done the biggest breakthrough and history of programming right so you can't criticize them for not having gotten all the technical details right so we got alcohol that was very pretty and most people in Commerce and science considered it useless because it was not flexible enough and it wasn't efficient enough and etc etc but that was the breakthrough from a technical point of view then similar came along to make that idea more flexible and you could define your own types and that's where where I got very interested first Nicole was the main idea and behind Simula I was late 60s this was late 60s was a visiting professor in Oz and so I learned object-oriented programming by sitting around well in theory discussing with with Christ Mughal but Kristin once you get started and then full flow it's very hard to get a word in edgeways where you're just listed so it was great I learned it from them not to romanticize the notion but it seems like a big leap to think about object-oriented programming it's really a leap of abstraction it's yes and was that as big and beautiful of a leap as it seems from now in retrospect I was in an obvious one at the time it was not obvious and many people have tried to do something like that and most people didn't come up with something as wonderful as similar lots of people got their PhDs and made their careers out of forgetting about Simula or never knowing it for me the key idea was basically I could get my own types and that's the idea that goes for a lines of C++ where I can get better types and more flexible types and more efficient types but it's still the fundamental idea when I want to write a program I want to write it with my types that is appropriate to my problem and under the constraints that I'm under with hardware software environment etc and that's that's the key idea people picked up on hierarchy is in the virtual functions and the inheritance and that was only part of it it was an interesting and major part and still a major part and a lot of graphic stuff but it was not the most fundamental it it was when you wanted to relate one type to another you don't want the more to be independent that the classical example is that you don't actually want to write city simulation with vehicles where you say well if it's a buy signal to write the code for turning a bicycle to the left if it's a normal car turn right a normal car way if it's a fire engine and right the fire engine way da da da da da you get these big case statements and bunches of if statement and such instead you tell the other the base class that that's the Viacom saying turn turn left the way you want to and this is actually a real example they they used it to simulate and optimize the emergency the emergency services for somewhere Norway back in the 60s Wow so this was one of the early examples for why you needed inheritance and and you needed runtime polymorphism because you wanted to handle this set of vehicles in a manageable way you you you can't just rewrite your code each time a new kind of vehicle comes along yeah that's a beautiful powerful idea and of course that it stretches through your work who C++ as we'll talk about but I think you structured it nicely what other breakthroughs came along in the history of programming languages they if we were to tell the history in that way obviously I'm bitter telling the part of the history that that is the path I'm on as opposed to all the path yeah you skipped the hippy John McCarthy and Lisp or my favorite languages but listen what Lisp is not one of my favorite language yes it's obviously important it's obviously interesting lots of people write code in it and then they rewrite it into C or C++ when they want to go to production yes it's in the world I met which are constrained by performance reliability issues deployability cost of hardware I I don't like things to be too dynamic it is really hard to write a piece of code that's perfectly flexible that you can also deploy on a small computer and that you can also put in say a telephone switch in Bogota what's the chance if you get an error and you find yourself in the debugger that the telephone switch in pockets are on late Sunday night has a programmer around right their chance is zero and so a lot of things I think most about can't afford that flexibility and I'm quite aware that maybe 70 80 percent of all code are not under the kind of constraints I'm interested in but somebody has to do the job I'm doing because you have to get from these high level flexible languages to the hardware the stuff that lasts for 10 20 30 years is robust yeah operates under very constrained conditions yes absolutely that's right and it's fascinating and beautiful in its own way it's C++ is one of my favorite languages and so is Lisp so I can I can embody two for different reasons as as a programmer I understand why it is popular and I can see the beauty of the ideas and similarly with this more talk it's just know this relative thank it it's not as relevant in my world and by the way I distinguish between those and the functional languages where I go to things like ml and Hesco different different kind of languages they have a different kind of huge in there very interesting and I actually try to learn from all the languages I encounter to see what is layer that would make working on the kind of problems I'm interested in with the kind of constraints that that I'm interested in what can actually be done better because we can surely do better than we do today you've you've said that it's good for any professional programmer to know at least five languages speaking about a variety of languages that you've taken inspiration from and you've listed the yours as being at least at the time C++ obviously Java Python Ruby and JavaScript can you first of all update that list modify it if you don't have to be constrained to just five but can you describe what you picked up also from each of these languages how you see them as inspirations for even you're working with C++ this is a very hard question to answer so about languages you should know languages I I reckon I knew about twenty-five or there abouts when I did C++ it was easier than those days because the languages were smaller and you didn't have to learn a whole programming environment and such to do it you you could learn the language quite easily and it's good to learn so many languages and I imagine just like with natural language for communication there's different paradigms that emerge in all of them yeah that there's commonalities and so on so I picked fire out of a head so far ahead obviously well the important thing that the number is not one that's right it's like I don't like I mean if you're mono clot you are likely to think that your own culture is the only ones peer is everybody else's a good learning of a foreign language and a foreign culture is important it helps you think and be a better person with programming languages you become a better programmer better designer with the second language now once you've got to the wage of five is not that long it's the second one that's most important and then when I had to pick five I sort of thinking what kinds of languages are there well there's a really low level stuff it's good it's actually good to know machine code movie very still sorry even today even today the C++ optimizer is right there a machine code than I do yes but I don't think I could appreciate them if I actually didn't understand machine code and machine architecture at least in in my position I have to understand a bit of it because you mess up the cash and you're off in performance by a factor of a hundred right shouldn't be that if you are interested in higher performance or the size of the computer you have to deploy so so I would go there's a simpler I used to mention C but these days going low-level is not actually what gives you the performance it is to express your ideas so cleanly that you can think about it and the optimizer can understand what you're up to my favorite way of optimizing these days is to throw out the clever bits and see if it's dawn runs fast and sometimes it runs faster so I need the abstraction mechanisms or something like C++ to write compact high-performance code there was a beautiful keynote by Jason Turner the CPP con a couple of years ago where he decided he was going to program pong on Motorola 6800 I think it was and he says well this is relevant because it looks like a microcontroller it has specialized hardware it has not very much memory and it's relatively slow and so he shows in real time how he writes pong starting with fairly straightforward low-level stuff improving his abstractions and what he's doing he's writing C++ and it translate into in 286 assembler which you can do with playing and you can see it in real-time it's the compiled explora which you can use on the web and then he wrote a little program that translated 86 assembler into Motorola has simpler and so he types and you can see this thing in real time while you can see it in real time and even if you can't read the assembly code you can just see it his code gets better the code the assembler gets Kimura he increases the abstraction level uses C++ 11 as it were better this code gets clean that gets easier maintain the code shrinks and it keeps shrinking and I could not in any reasonable amount of time write that a simpler as good as the compiler generated from really a quite nice modern C++ and I'll go as far as to say the the thing that looked like C was significantly uglier and and smaller when it becames and and larger when it became machine code so what the the abstractions that can be optimized important I would love to see that kind of visualization larger code bases yeah there might be blood a few can't show a larger code base in a one-hour talk and to have it fit on screen right so that C is if you love so my two languages would be machine code and C++ and then I think you can learn a lot from the functional languages so pig has pralaya male I don't care which I think actually you you'll you'll learn the same lessons of expressing especially mathematical notions really clearly and having the type system that's really strict and then you should probably have a language for sort of quickly churning out something you could pick JavaScript you could pick Python you could pick Ruby really make of JavaScript in general so you kind of you're talking in the Platonic sense of all languages about what they're good at what their philosophy design is but there's also a large user base behind each of these languages and they use it in the way maybe it wasn't really designed for that's right javascript is used way beyond I probably put hooks design for it let let me say it this way when you build a tool you do not know how it's going to be used you try to improve the tool by looking at how it's being used and when people cut their fingers off and try and stop that from happening but really you have no control over how something is used so I'm very happy and proud of some of the things he plus plaus being used at and some of the things I wish people wouldn't do Bitcoin mining being my favorite example uses as much energy as Switzerland and mostly serves criminals yeah but back to back to the languages I actually think that having JavaScript run in the browser what was was an enabling thing for a lot of things yes you could have done it better but people were trying to do it better they were using proof sort of more principles language designs but they just couldn't do it right and the non professional programmers that write or lots of that code just couldn't understand them so it did amazing job for what it was it's not the prettiest language and I don't think it ever will be the prettiest language but that's not be bigots here so what was the origin story of C++ you you basically gave a few perspectives of your inspiration of object-oriented programming that's you had a connection with C in performance efficiency was an important thing you were drawn to efficiency and reliability reliability you have to get both what what's reliability I I really want my telephone calls to get through and I want the quality of what I am talking coming out with the other end the other end might be in London or wherever so and you don't want the system to be crashing if you're doing a bank here is you must not crash it might be your your bank account that is in trouble there's different constraints like in games it doesn't matter too much if there's a crash nobody dies and nobody gets ruined but I am interested in the combination of performance partly because of sort of speed of things being done part of being able to do things that is necessary to do to have reliable energy of larger systems if you spend all your time interpreting a simple function call you are not going to have enough time to do proper signal processing to get the telephone calls to sound right I know that or you have to have 10 times as many computers and you can't afford your phone anymore it's a ridiculous idea in the modern world because we have solved all of those problems I mean they keep popping up in different ways as we tackle bigger and bigger problems efficiency remains always an important aspect but you have to think about efficiency not just as speed but as an enabler to things and women thinks it enables is this reliability is dependability you won when I press the pedal the brake pedal of a car it is not actually connect it directly to to anything but a computer that computer better work let's talk about reliability just a little bit so modern cars have ECU's millions of lines of code Mme so this is certainly especially true of autonomous vehicles where some of the aspects of the control or driver assistance systems that steer the car the key panel and so on so how do you think you know I talk to regulators people in government who are very nervous about testing the safety of these systems of software ultimately software that makes decisions that could lead to fatalities so how do you how do we test software systems like these first of all safety like performance and like security is a systems property people tend to look at one part of a system at a time and saying something like this is secure that's all right I don't need to do that yeah that piece of code is secure I'll buy your operator right if you want to have reliability if you want to have performance if you want to have security you have to look at the whole system I did not expect you to say that but that's very true yes I'm dealing with one part of the system and I want my part to be really good but I know it's not the whole system furthermore if making an individual part perfect may actually not be the best way of getting the highest degree of reliability and performance and such the spumone says super cross type say not type safe you can break it sure I can break anything that runs on a computer I may not go through your type system if I wanted to break into your computer I'll probably try SQL injection and it's very true if you think about safety or even reliability at its system level especially when a human being is involved it's starts becoming hopeless pretty quickly in terms of proving that something is safe to a certain level yeah there's so many variables it's so complex well let's get back to something we can talk about and it actually makes some progress on yes we look at C++ programs and we can try and make sure the crash less often the way you do that is largely by simplification it is not the first step is to simplify the code have less code have code that are less likely to go wrong it's not by runtime testing everything it is not by big test frameworks that you're using yes we do that also but the first step is actually to make sure that when you want to express something you can express it directly in code rather than going through endless loops and convolutions in your head before it gets down the code that if if the way you are thinking about a problem is not in the code there is a missing piece that's just in your head and the code you can see what it does but it cannot see what you thought about it unless you have expressed things directly when you express things directly you can maintain it it's these years to find errors is easier to make modifications it's actually easier to test it and lo and behold it runs faster and therefore you can use a smaller number of computers which means there's less hardware that could possibly break so I think the key here is simplification but it has to be to use the Einstein code as simple as possible and no simpler not simpler well there are other areas with under constraints where you can be simpler than you can be in C++ but in the domain I'm dealing with that's the simplification I'm after so how do you inspire or ensure that the Einstein level simplification is reached so okay can you do code review can you look at code is there if I gave you the code for the Ford f-150 and said here is this a mess or is this okay is it possible to tell is it possible to regulate an experienced developer can do it code and see if it smells you know I'm mixed metaphors deliberately yes the the point is that it is hard to generate something that is really obviously clean and can be appreciated but you can usually recognize when you haven't reached that point and so if I I've never looked at me if 150 code so I wouldn't know but but I know what I ought to be looking for there I'll be looking for some tricks that correlates with bugs and elsewhere and I have tried to formulate rules for what what good code looks like and the current version of that is called the C++ core guidelines one thing people should remember is there's what you can do in a language and what you should do in a language you have lots of things that is necessary in some context but not another's as things that exist just because there's 30 year old code out there and you can't get rid of it but you can't have rules it says when you create it try and follow these rules this does not create good programs by themselves but it limits the damage and off for mistakes it limits the possibilities of the mistakes and basically we are trying to say what is it that a good programmer does at the fairly simple level of where you use the language and how you use it now I can move all the rules for chiseling in my marble it doesn't mean that somebody who follows all of those rules can do a masterpiece by Machine Angelo that is there something else to write a good program just is there something else to create important work of art that is there's some kind of inspiration understanding gift but we can approach the sort of technical the the craftsmanship level of it the the the famous painters the famous cultures was among other things superb craftsmen they could express their ideas using their tools very well and so these days I think what I'm doing what a lot of people are doing we're still trying to figure out how it is to use our tools very well for a really good piece of code you need a spark of inspiration and you can't I think regulate that you you cannot say that I'll take a picture only I'll buy your picture only if you're at least then go there are things you can regulate but not the inspiration I think that's quite beautifully put it is true that there is there's an experienced programmer when you see code that's inspired that's like Michelangelo you know it when you see it and the opposite of that is code that is messy code that smells you know when you see it and I'm not sure you can describe it in words except vaguely through guidelines and so on yes it's easier to recognize ugly than to recognize beauty in code and for the reason is that sometimes beauty comes from something that's innovative and unusual and you have to sometimes think reasonably hard to appreciate that on the other hand the misses have things in common and you can you can have static checkers dynamic checkers that finds large number of the most common mistakes you can catch a lot of sloppiness mechanically I'm a great fan of static analysis in particular because you can check for not just the language rules but for the usage of language rules and I think we will see much more static analysis in the coming decade clear the drive word static analysis you represent a piece of code so that you can write a program that goes or that representation and look for things that are right and not right so for instance you can analyze a program to see if resources are leaked that's one of my favorite problems it's not actually all that hard and one C++ but you can do it if you were writing in the C level you have to have a Murloc and a free and they have to match if you have them in a single function you can usually do it very easily if there's a man log here there should be a free there on the other hand in between can be drawing complete code and then it becomes impossible yeah if you pass that pointer to the memory out of a function and then want to make sure that the free is done somewhere else now it gets really difficult and so for static analysis you can run through a program and you can try and figure out if there's any leaks and what you will properly find is that you will find some leaks and you'll find quite a few places where your analysis can't be complete it might depend on runtime it might depend on the cleverness of your analyzer and it might take a long time some of these programs run for a long time but if you combine such analysis with a set of rules it says how people could use it you can actually see why the rules are violated and that stops you from getting into the impossible complexities you don't want to solve the halting problem the static analysis is looking at the code without running the code yes and thereby it's almost not in production code but it's almost like an educational tool of how the language should be used it's guys you like it is best right it would guide you in how you write future code as well and you learn together yes so basically you need a set of rules for how you use the language then you need a static analysis that catches your mistakes when you violate the rules or when your code ends up doing things that it shouldn't despite the rules because there's the language rules you can go further and again it's back to my idea that I would much rather find errors before I start running the code if nothing else once the code runs if it catches an error at run times I have to have an error handler and one of the hardest things to write in code is their handling code because you know something went wrong do you know really exactly what went wrong usually not how can you recover when you don't know what the problem was you can't be a hundred percent sure what the problem was in many many cases and this is this is part of it so yes we need good languages or good type systems we need rules for how to use them we need static analysis and the ultimate for static analysis is of course program proof but that still doesn't scale so the kind of systems we deploy then we start needing testing and the rest of the stuff so C++ is an object-oriented programming language that creates especially with its newer versions as we'll talk about higher and higher levels of abstraction so how do you design let's even go back to the origin C++ how you design something with so much abstraction that's still efficient and is still something that you can manage do static analysis on you can have constraints on they can be reliable those things we've talked about so create the to me slightly there's a slight tension between high-level abstraction and efficiency that's a good question I could probably have a year's course just trying to answer it yes there's a tension between efficiency and abstraction but you also get the interesting situation that you get the best efficiency out of the best abstraction and my main tool for efficiency for performance actually is abstraction so let's go back to how C++ got there yeah you said it was up to Rory in the programming language I actually never said that it's always quoted but I never did I said C++ supports object-oriented programming but it's nine other techniques and that that's important because I think that the best solution to most complex interesting problems require ideas and techniques from things that has been called object-oriented data abstraction function or traditional C style code all of the above and so when I was designing C++ I soon realized I couldn't just add features if you just add what looks pretty or what people ask for or what you think is good one by one you're not going to get a coherent whole what you need is a set of guidelines that that that guides your decisions should this feature Vienna should this feature be out how should a feature be modified before it can go in and such and there's a in in the book I wrote about that that sign evolution of si+ process a whole bunch of rules like that most of them are not language technical they they they're they're things like don't violate static type system because I like static type system for the obvious reason that I like things to be reliable on reasonable amounts of hardware but one of these rules is the zero overhead principle the were kind of put a zero overhead principle it basically says that if you have an abstraction it should not cost anything compared to write the equivalent code at a lower level so if I have say a matrix multiplied it should be written in such a way that you could not drop to the C level of abstraction and use arrays and pointers and such and run faster and so people have written such matrix multiplications and we have actually gotten code that ran faster than Fortran because once you had the right abstraction you can eliminate you can eliminate temporaries and you can do loop fusion and other good stuff like that that's quite hard to do by hand and in a lower level language and there's some really nice examples of that and the key here is that that matrix multiplication the matrix abstraction allows you to write code that's simple and easy you can do that in any language but with C++ it has the features so that you can also have this thing run faster than if you hand coded it now people have given that lecture many times I and others and a very common on question after the talk where you have demonstrated that you can outperform Fortran for dense matrix multiplication people come up and says yeah but there are C++ if I rewrote your code and see how much faster would have run the answer is much slower this happened the first time actually back in the ages with a friend of mine called Doug McIlroy who demonstrated exactly this effect and so the principle is you should give programmers the tools so that the abstractions can follow the 0oi principle furthermore when you put in a language feature in C++ or a standard library feature you try to meet this it doesn't mean it's absolutely optimal but it means if you're hand coded with the usual the facilities in the language in C++ in C you should not be able to better it usually you can do better if you use embedded a simpler for machine code for some of the details to utilize part of a computer that the compiler doesn't know about but you should get to that point before you be to the abstraction so that's that's a beautiful ideal to reach for and we meet it quite often quite often so where's the magic of that coming from there's some of it is the compilation process so the implementation is C++ some of it is the design of the feature itself the guidelines so I've recently an often talk of Chris Ladner so clang what just out of curiosity is your relationship in general with the different implementations in C++ as you think about you and committee and other people C++ think about the design of new features or design of previous features the in in trying to reach the ideal of zero overhead who does the magic come from the design the guidelines or from the implementations and and not all you have you you are you you you you go for programming technique program language features and implementation techniques you need all three and how can you think about all three at the same time it takes some experience takes some practice and sometimes you get it wrong but after a while you sort of get it right I don't write compilers anymore but Brian Kearney and pointed out that one of the reason c++ succeeded was some of the craftsmanship I put into the early compilers and of course I did the languages sign of course I wrote a fair amount of code using this kind of stuff and I think most of the successes involves progress in all three areas together a small group of people can do that two three people can can work together to do something like that it's ideal if it's one person that has all the skills necessary but nobody has all the skills necessary in all the fields where C++ is used so if you want to approach my idea in say concurrent programming you need to know about algorithms of my current programming you need to know the the triggering of lock-free programming you need to know something about compiler techniques and then you have to know some of the program error the sorry the application areas what this is like some forms of graphics or some forms of what are called the web server and kind of stuff and that's very hard to get into a single head but small groups can do it too it says there differences in your view not saying which is better or so on but difference in the different implementations of C++ why are there several sort of many of you naive questions for me GCC clang so this is a very reasonable question when I designed C++ most languages have multiple implementations because if you wanna I p.m. if you run on a Sun if you wanna Motorola that those just many many companies and they each have their own compilation structure the old compilers it was just fairly common that those many of them and I wrote C front assuming that other people would write compilers for C++ if I was successful and furthermore I wanted to utilize all the backend infrastructure were available I soon realized that my users were using 25 different linkers I couldn't write my own linker yes I could but I couldn't write 25 linkers and also get any work done on the language and so it came from a world where there was many linkers many optimizers many compiler front ends not not to start but over at many operating systems the whole world was not an 86 and linux box or something whatever is the standard today in the old days they said a set of X so basically I assumed there'd be lots of compilers it was not a decision that there should be many compilers it was just a fact that's the way the world is and yes many compilers emerged and today there's at least four front ends playing GCC Microsoft and EDG it is Design Group they they supply a lot of the independence organizations and the embedded systems industry and there's lots and lots of backends we have to think about how many dozen begins there are because different machines have different things especially in the embedded world their machines are very different the architectures are very different and so having a single implementation was never an option now I also happen to dislike monocultures monocultures they are dangerous because whoever owns the monoculture can go stale and there's no competition and there's no incentive to innovate there's a lot of incentive to put barriers in the way of change because hey we own the world and it's a very comfortable world for us and who are you to to mess with that so I really am very happy that this for front-ends for C++ clanks great but GCC was great but then it got somewhat stale Tran came along and GCC's much better now competition my Microsoft is much better now so hello at least a low number our front end puts a lot of pressure on stand-ups compliance and also on performance and error messages and compile time speed all this good stuff that we want do you think crazy question there might come along you hope that might come along implementation of C++ written given all its history written from scratch so written today from scratch well playing and the LLVM this more less written by from scratch but there's been c++ 11 14 17 20 you know there's been a lot you know later somebody's going to try again there has been attempts to write new C++ compilers and some of them has been used and some of them has been absorbed into others and so yeah I don't happen so what are the key features of C++ and let's use that as a way to sort of talk about the evolution of C++ the new feature so at the highest level what are the features that were there in the beginning what features got added its first get a principal on aim in place C++ is for people who want to use hardware really well and then manage the complexity of doing that through abstraction and so the first facility you you have is a way of manipulating the machines at a fairly low level that looks very much like see it has loops it has variables it has pointers like machine addresses it can access memory directly it can allocate stuff in the absolute minimum of space needed on the machine there's a machine facing part of C++ which is roughly equivalent to C I said C++ could beat C and it can doesn't mean I dislike see if I disliked C wouldn't have built on it furthermore after Dennis Ritchie I'm probably the major contributor to modern C and well I had lunch with Dennis most days for 16 years and we never had a harsh word between us so these C versus C++ fights are for people who don't quite understand what's going on then the other part is the abstraction and there the key is the class which is a user defined type and my idea for the class is that you should be able to build a type that's just like the building types in in the way you use them in the way you declare them and the way you get the memory and you can do just as well so in C++ there's an int as in C you should be able to build an abstraction a class which we can call capital int that you could use exactly like an integer and run just as fast as an integer there's the idea right there and of course you probably don't want to use the int itself but it has happened people have wanted integers that were range checked so that you couldn't overflow one such especially for very safety critical applications like the fuel injection for a marine diesel engine for the largest ships this is a real example by the way this has been done they they built themselves an integer that was just like integer except that couldn't overflow if there's no or flow you went into the error handling and then you built more interesting types you can build a matrix which you need to do graphics or you could build a gnome for a for a video game and all these are classes and they appear just like the built-in types exciting terms of efficiency and so on so what else is there and flexibility so I don't know for people who are not familiar with object-oriented programming there's inheritance there's a hierarchy of classes you you can just like you said create a generic vehicle that can turn left so what people found was that you don't actually know how do I say this a lot of types are related that is the vehicles all the accounts are related bicycles cars fire engines tanks they have some things in common and some things that differ and you would like to have the common things common and having the differences specific and when you didn't want to know about the differences like just turn left uuuuu you don't have to worry about it that's how you get the traditional object-oriented programming coming out of simulate opted by small talk and C++ and all the other languages the other kind of obvious similarity between types comes when you have something like a vector fortune gave us the vector as called array of doubles but the minute you have a vector of doubles you want a vector or double precision doubles and for short doubles for graphics and why should you have not have a vector of integers while you're added or vector of vectors and vector of vectors of chess pieces now we have a board right so this is you express array the commonality as the idea of a vector and the variations come through parameterization and so here we get the two fundamental ways of abstracting or of having similarities of types in C++ there's the inheritance and there's a parameterization there's the object-oriented programming in this generic programming with the templates for the generic program yeah so you you've presented it very nicely but now you have to make all that happen and make it efficient so generic programming with templates there's all kinds of magic going on especially recently that you can help catch up on but it feels to me like you can do way more than what you just said with templates you can start doing this kind of meta programming this kind you can do meta programming also I I didn't go there and in that explanation we're trying to be very basics but go back on so the implementation implementation if you couldn't implement this efficiently if you couldn't use it so that it became efficient it has no place in C++ because it were violates the zero overhead principle so when I had to get up during programming inheritance I took the idea of virtual functions from Simula virtual functions is a similar term class is a similar term if you ever use those words say thanks to question you go and all you and I'll and I did the simplest implementation I knew off which was basically a jump table so you get the virtual function table or the function goes in do it does an indirection through a table and get the right function that's how you pick the right thing there and I thought that was trivial it's close to optimal it's endo is obvious it turned out the Simula had a more complicated way of doing it therefore slower and it turns out that most languages have something that's a little bit more complicated sometimes more flexible but you pay for it and one of the strengths of C++ was that you could actually do this object-oriented stuff and your overhead compared to ordinary functions there's no interactions it's not open five ten twenty five percent for just the core it sits down there it's not too and that means you can afford to use it furthermore in C++ you have the distinction between a virtual function and a non-virtual function if you don't want any overhead if you don't need the interaction that gives you the flexibility in object-oriented programming just don't ask for it so the idea is that you only use virtual functions if you actually need the flexibility so it's not zero overhead but zero overhead compared to any other way of achieving the flexibility now also parameterization basically the compiler looks at at the the template say the vector and it looks at the parameter and then combines the two and generates a piece of code that is exactly as if you're written a vector off that specific type yes so that's the that's the minimal overhead if you have many template parameters you can actually combine code that the compiler couldn't usually see at the same time and therefore get code that is faster then if you had handwritten stuff on this you are very very clever so the thing is Parature i's code the compiler fills stuff in during the compilation process not during runtime that's right and so in furthermore it gives all the information it's gotten which is the template the parameter and the context of use it combines the three and generates good code but it can generate now it's a little outside of what I'm even comfortable thinking about but it can generate a lot of code yes and how do you remember being both amazed at the power of that idea and how ugly the debugging look the debugging can be truly horrid come back to this because I have a solution anyway the debugging was ugly the code generated by C++ has always been ugly because there's these inherent optimizations a modern C++ compiler has runned in middle-end and beckoned optimizations even C front back in 83 had front end and back end optimizations I actually took the code generated an internal representation munch that implements a representation to generate good code so people says it's not a compiler I generate see if the reason it generated C was a one that you used to C's code generators that are really good at backend optimizations but I need a front end of two eyes Asians and therefore the C I generated was optimized C hmm the way really good up a handcrafted optimize a human who could could generate it and it was not meant for humans it was the output of a program and it's much worse today and with templates it gets much worse still so it's hard to do it's hard to combine simple debugging with simple with the optimal code because the idea is to drag in information from different parts of the code to generate good code machine code and that's not readable so what people often do for debugging is they turn the optimizer off and so you get code that when you when when something in your source code looks like a function call it is a function call when the optimizer is turned on it may disappear the function call it may inline and so one of the things you can do is you can actually get code that is smaller than the function call because you eliminate the function preamble and returned and that's just the operation there one of the key things when I did templates was I wanted to make sure that if you have say a sort algorithm and you give it a sorting criteria if that sorting criteria is simply comparing things with lesson the code generators should be the less than not a indirect function call to a compression object which is what it is in the source code but we really want down to the single instruction and but anyway turn off the optimizer and and you can you can debug the first level of debugging can be done and I always do without the optimization on because then I can see what's going on and then there's this idea of concepts that puts some now I've never even the I don't know if it was ever available in any form but it puts some constraints on the stuff you can parameterize essentially let me try and explain yes so yes it wasn't there ten years ago we have had versions of it that actually work for the last four or five years it was a design by Gabby does raise true certain and me we were professors and postdocs in Texas at the time and the implementation by Andrew Sutton has been available for at that time and it is part of C++ 20 and the standard library that uses it so this is becoming really very real it's available in clang and GCC GCC for a couple of years and I believe Microsoft zum-zum going to do it expect a wall of C++ 20 to be available so in all the major compilers in 20 but this kind of stuff is it's available now I'm just saying that because otherwise people might think I was talking about science fiction and so what I'm going to say Israel on Crete you can write it today and there's production users of it so the basic idea is that when you have a a generic component like a sort function the sort function will will require at least two parameters one a data structure with a given type and comparison criteria and these things are related but obviously you can't compare things if you don't know what the type of things you compare and so you want to be able to say I'm going to sort something and did this to be sortable what does it mean to be sortable you look it up in the standard it has to have it has to be a sequence with a beginning and an end there has to be random access to that sequence and there has to be the element types has to be comparable like you more like an operator can I do it yes what illogical already cannot basically what concepts are there compile-time predicates there predicates you can ask are you a sequence yes I have begin an end are you a random exit sequence yes I have subscripting and plus it's your element type something that has a less then yes I have a less than hits and so basically that's the system and so instead of saying I will take a parameter of any type it'll say I'll take something that's audible and it's well defined and so we say okay you can sorta less then I don't want less then I want greater then also something I invent so you have two parameters the sortable thing and the compassion criteria and the comparison criteria will say well I can you you can write it saying it should operate on the element type and it has the compassion operations so that's the simply the fundamental thing it's compile-time predicates do you have the properties I need so it specifies the requirements of the code on the parameters that gets yes there are lots of types actually but operating in the space of concepts concepts the word concept was used by Alec Stephan of who is sort of the father of generic programming in the context of C++ there's other places that use that word but the way we call Genetic Programming is Alex's and he called them concepts because he said there they are the sort of the fundamental concepts of an area so they should be called concepts and we've had concepts all the time if you look at the knr book about si si has arithmetic types and it has integral types it says so in the book and then it lists what they are and they have certain properties the difference today is that we can actually write a concept that will ask a type are you an integral type do you have the properties necessary to be an integral type do you have Proust - divide so what may be the story of concepts because I thought it might be part of C++ 11 C C C's o X or whatever it was at the time what was the why didn't it look like what we'll talk a little bit about this fascinating process of standards because I think it's really interesting for people it's interesting for me but why did it take so long what shapes the the idea of concepts take what were the challenges back in 87 of there abouts 97 well 1987 like they are about so when I was designing templates obviously I wanted to express the notion of what is required by a template of its arguments and so I looked at this and basically for for templates I wanted three properties I wanted to be very flexible it had to be able to express things I couldn't imagine because I know I can't imagine everything and I've been suffering from languages and try to constrain you to only do what you're the designer thought good didn't want to do that secondly it had to run faster as faster faster that hand written code so basically if I have a vector of T and I take a vector of cha it should run as fast as you built a vector of cha yourself without parameterization and second and thirdly I wanted to be able to express the constraints of of the arguments have proper type checking of the interfaces and neither I nor anybody else at the time knew how to get all three and I thought for C++ I must have the two first otherwise it's not C++ and it bothered me for an hour a couple of decades that I couldn't solve the third one I mean I was the one that put function argument type checking in to see I know the value of good interfaces I didn't invent that idea it's very common but I did it and I wanted to do the same for templates of course and I could so it bothered me then we try it again mm of to 2003 cavitus raised and I started analyzing the problem explained possible solutions there was not a complete design a group in University of Indiana an old friend of mine they started a project at Indiana and we thought we could get a good system of concepts in another two or three years that would have made C++ la 11 to C++ Oh 607 well it turns out that I think we got a lot of the fundamental ideas are wrong they were took on conventional they didn't quite fit C++ in my opinion didn't serve implicit conversions very well it didn't of mixed makes type arithmetic mix type computation computations very well a lot of stuff came out of the functional community and it that community didn't deal with multiple types in in the same way as C++ does had more constraints on on what you could express and didn't have the draconian performance requirements and basically we tried we tried very hard we had some successes but it just in the end wasn't didn't compile fast enough was too hard to use and didn't run fast enough unless you had optimizes that was beyond the state of the art they still are so we had to do something else basically it was the idea that a set of parameters has defines a set of operations and you go through an interaction table just like for virtual functions and then you try to optimize the interaction away to get performance and we just couldn't do all of that but get back to the standardization we are standardizing C++ on the ISO rules which a very open process people come in there's no requirements for education or experience they start develop C++ and there's a hope when was the first standard established what is that like the ISO standard is there committee that you're referring to she was a group of people what it was that like how often do you meet what's the disguise I'll try and explain that so sometime in early 1989 two people one from IBM one from HP turned up in my office and told me I would like to standardize it PLAs PLAs this was a new idea to me and I pointed out that it wasn't finished yet it wasn't ready for former standardization and such and they say no beyond even gotten it you you really want to do this our organizations depend on c++ we cannot depend on something that's owned by another corporation that might be a competitor of course we could rely on you but you might get run over by a bus right the old really needs to get this out new it has to be standardized under formal rules and we are going to standardize it under ISO rules and you really want to be part of it because basically otherwise we will do it ourselves and we know you can do it better so through a combination of arm-twisting and flattery Carolus started so in late in late 89 there was a meeting in DC at the x-ray no it was not ISO then it was an SI the American national standard were doing we met there we were lectured on the rules of how to do when ANSI standard there was about 25 of us there which apparently was a new record for that kind of meeting and some of the old see guys that it's been standardizing see was there so we got some expertise in so the way this works is that it's an open process anybody can consign up if they pay the minimal fee which is about a thousand dollars still less then just a little bit more now and I think it's twelve hundred and eighty dollars it's not it's not going to kill you and we have three meetings a year this is fairly standard we try to meetings a year for a couple years that didn't work too well so three weeks is three one-week meetings a year and you meet and you have taken meet technical discussions and then you bring proposals forward for votes the votes are done one person per one vote per organization so you can't have say IBM come in with 10 people and dominate things that's not allowed and these organizations that extends to the UC bus bus this yes this is all individuals or individuals I mean it's a it's a bunch of people in room deciding the design of a language based on which a lot of the world's systems run right well I think most people would agree it's better than if I decided it or better than if a single organization like agency decides it I don't know if everyone agrees to that by the way bureaucracies have their critics - yes they they're that look standardization is not pleasant it's it's it's horrifying like democracy what we exactly as Churchill says democracy is the worst way except for or the others right and it's about say the same reforms but anyway so we meet and we we have these votes and that determines what the standard is couple of years later we extended this so it became worldwide we have stand out of organizations that are active in currently 15 to 20 countries and another fifteen to twenty are sort of looking and and voting based on the rest of the work on it and we meet three times a year next week I'll be in Cologne Germany spending a week doing standardization and we'll vote out the committee draft or c plus plus 20 which goes to the national standards committees for comments and requests for changes and improvements then we do that and there's a second set of votes where hopefully everybody votes in favor this has happened several times the first time we finished we started in the first technical meeting was in 1990 the last was in 98 we voted it out that was suspended that people used till 11:00 or a little bit past 11:00 and was an international standard all the countries voted in favor it took longer with 11 I'll mention why what all the nations voted in favor and we work on the basis of consensus that is we do not want something that passes 6040 because then we're going to get dialects and opponents and people complain too much they don't complain so much but basically it no real effect the the standards has been obeyed they have been working to make it easier to use many compilers many computers and all of that kind of stuff and so the first the traditional with ISO standards to take ten years we did the first one and eight brilliant and we thought we were going to do the next one and six because now we're good at it right it took 13 yeah it was named Oh X he was named Oh X hoping that you would at least get it in within the single within the arts the single day I thought we would get yeah I thought would gets six seven or eight the confidence of youth yes right well the point is that this was sort of like a second system effect that is we now knew how to do it and so we're going to do it much better and we got more ambitious and bish han dicho penguia furthermore there is this tendency because it's a 10-year cycle or age doesn't matter just before you're out to ship somebody has a bright idea yeah and so we really really must get that in we did that successfully with the STL we got the the standard Liars all the STL stuff that that my base be I think it saved C++ it was beautiful yes and then people tried it with all our things and it didn't work so well they got things in but it wasn't as dramatic and it took longer and longer and longer so after C++ 11 which was a huge improvement and what basically what most people are using today we decided ever again and so how do you avoid those slips and the answer is that you shipped more often so that if you if you if you have a slip on the 10-year cycle by the time you know it's a slip there's 11 years till you get it yeah now with a three year cycle there is about three or four years till you get it like the delay between feature freeze and shipping so you always get one or two years more and so we were shipped fourteen on time we shipped seventeen on time and we ship we will ship 20 on time it's it'll happen and furthermore this allow this gives a predictability that allows the implementers the compiler implementers the library implementers so they have a target and they deliver on it 11 took two years before most compilers were good enough 14 most compilers were actually getting pretty good in 14 17 everybody shipped in 17 well we are going to have at least almost everybody's ship almost everything in 20 and I know this because they're shipping in nineteen predictably this is good delivery on time is good and so yeah that's great those how it works there's a lot of features that came in in C++ 11 there's a lot of features at the birth of C++ they were amazing and ideas with concepts in 2020 what to you is the most justjust to you personally beautiful or just you sit back and think wow that's just nice and clean feature of C++ I have written two papers for the history of programming languages conference which basically asked me such questions and I'm writing a third one which I will deliver at the history of programming languages conference in London next year so I've been thinking about that and there is one play answer constructors and destructors the way a constructor can establish the environment for the use of the Java type for object and the destructor that cleans up any messes at the end of it that is the key to C++ that's why we don't have to use garbage collection that's how we can get predictable performance that's how you can get the minimal overhead in many many cases and have really clean types it's the idea of constructor destructor pairs sometimes it comes out under the name our high AIII resource acquisition is initialization which is the idea that you grab resources and the constructor and release them and destructor it's also the best example of why I shouldn't be in advertising I get the best idea and I call it resource acquisition is initialization not the greatest naming I've ever heard so it's types abstraction of types you said I want to create my own types so types is an essential part of C++ and making them efficient as the if it is the key part and GU the this is almost getting philosophical but the construction and the destruction the creation of an instance of a type and the freeing of resources from that instance of a type is what defines the object is uh that's like birth and death is what defines human life yeah that's right by the way philosophy is important you can't do good language design without philosophy because what you are determining is what people can express this is very important by the way constructors destructors came into C++ in 79 in about the second week of my work with what was then Corsi of the classes it is a fundamental idea next comes the fact that you need to control copying because once you control as you says birth and death you have to control taking copies which is another way of creating an object and finally you have to be able to move things around so you get the move operations and that's the set of key operations you can define on a C++ type inserts you those things are just a beautiful part of C++ that is at the core of it all yes you mentioned that you hope there will be one unified set of guidelines in the future for how to construct the programming language so perhaps not one programming language but a unification of how we build programming languages if you remember the statement I I have some trouble remembering it but I know the origin of that idea so maybe you can talk about sort of C++ has been improving there's been a lot of programming language do you word is the arc of history taking us do you hope that there is a unification about the languages with which we communicate in the digital space well III think that languages should be designed not by clobbering language features together and doing slightly different versions or somebody else's ideas but through the creation of a set of principles rules of thumbs whatever you call them I I made them for C++ and we're trying to teach people in the Standards Committee about these rules because a lot of people come in and says I've got a great idea let's put it in language and then you have to ask why does it fit in the language why does it fit in this language it may fit in on our language and not here or may fit here not the other language so you have to work from a set of principles and you have to develop that set of principles and it's one example that I sometimes remember is I was sitting down with some of the designers of common lisp and we are talking about languages and language features and obviously we didn't agree about anything because well this was not C++ and vice versa too many parenthesis but suddenly we started making progress I said I had this problem and I developed it according to these ideas and they said what why we had that problem different problem and we develop it the same kind of principles and so we worked through large chunks of C++ and large chunks of Common Lisp and figure out we actually had similar sets of principles of how to do it but the constraints on our designs were very different and the aims for the usage was very different but there was commonality in the way you reason about language features and the fundamental principles you are trying to do so do you think that's possible to so they're just like there is perhaps a unified theory of physics of the fundamental forces of physics now I'm sure there is commonalities among the languages but there's also people involved you know that help drive these developing these languages do you have a hope or an optimism that there will be a unification if you think about physics and Einstein towards a simplified language do you think that it's possible let's remember sort of modern physics I think started with Galileo in the 1300s so they have had seven hundred years to get going modern computing started in about 49 we've got what's that 70 years they have 10 10 times yeah and furthermore they they are not as bothered with people using physics the way we are worried about programming it's done by humans so each have problems and constraints the others have but we are very immature compared to physics so I would look at sort of the philosophical level and and look for fundamental principles like you don't leak resources you shouldn't you don't take errors at runtime that you don't need to you don't violate some kind of type system there's many kinds of type systems but when you have one you don't break it etc etc there will be quite a few and it will not be be the same for all languages but I think if we step back at some kind of philosophical level we can we would be able to agree on sets of principles that applied to two sets of problem areas and within an area of use by in C++ this case what used to be called systems programming the area between the hardware and the the the fluffier parts of the system you you might very well see a convergence so these days you see rust having a adopted ra íí- and sometime accuses me for having borrowed it 20 years before they discovered it but it's we're seeing some kind of conversion convergence here instead of relying on garbage collection all the time the garbage collection languages are doing things like the dispose patterns and such that imitates some of the construction destruction stuff and they're trying not to use the garbage collection all the time things like that so there's there there's conversion but I think we have to step back to the philosophical level and agree on principles and then we'll see some conversions convergences and it will be application domain-specific so a crazy question but I work a lot with machine learning with deep learning I'm not sure if you touch that world that much but you could think of programming is the thing that takes some input programming is the task of creating a program and a program takes some input and produces some output so machine learning systems train on data in order to be able to take an input and produce output but they're messy fuzzy things much like we as children grow up you know we take some input make some output but we're noisy we mess up a lot we're definitely not reliable biological system or a giant mess so there's a sense in which machine learning is a kind of way of programming but just fuzzy it's very very very different than C++ because C++ is a like it's just like you said it's extremely reliable it's efficient it's you know you can you can measure you can test in a bunch of different ways with biological systems or machine learning systems you can't say much except sort of empirically saying that ninety-nine point eight percent of the time it seems to work what do you think about this fuzzy kind of programming indeed even see it as programming is it solely and totally another kind of world I I think it's a different kind of world and it is fuzzy and in my domain I don't like fuzziness that is people say things like they want everybody to be able to program but I don't want everybody to program my my aeroplane controls or the car controls I want that to be done by engineers I want that to be done with people that are specifically educated and trained for doing building things and it is not for everybody similarly a language like C++ is not for everybody it is generated via sharp and effective tool for professionals basically and definitely for people who who aim at some kind of precision you don't have people doing calculations without understanding math right counting on your fingers not going to cut it if you want to fly to the moon and so there are areas where and eighty-four percent accuracy rate 16 percent false positive rate it's perfectly acceptable and where people will probably get no more than 70 you said 98% I what I have seen is more like 84 and by by really a lot of blood sweat and tears you can get up to the 92 and a half right so this is fine if it is say pre-screening stuff before the human look at it it is not good enough for for life-threatening situations and so there's lots of areas where where the fuzziness is perfectly acceptable and good and better than humans cheaper than humans but it's not the kind of engineering stuff I'm mostly interested in I worry a bit about machine learning the context of cars you know much more about this than I do I worry too but I'm I'm sort of a an amateur here I've read some of the papers but I have not ever done it and the the idea that scares me the most is the one I have heard and I don't know how common it is that you have this AI system machine learning all of these trained neural nets and when they're something is too complicated they asked the human for help but human is reading a book or sleep and he has 30 seconds or three seconds to figure out what the problem was that the AI system couldn't handle and do the right thing this is scary I mean how do you do the cutter walk between the Machine and the human it's very very difficult and for the designer or one of the most reliable efficient and powerful programming languages C++ I can understand why that world is actually unappealing it is for most engineers to me it's extremely appealing because we don't know how to get that interaction right but I think it's possible but it's very very hard it is and I was stating a problem no yes that is the nostril I mean I would much rather never rely on a human if you're driving a nuclear reactor if you're or an autonomous vehicle it would it's much better to design systems written in C++ that never asked human for help let's just get one fact in yeah all of this AI star Suns help us constructs so so that's one reason I have to keep a weather eye out or what's going on in that field but I will never become an expert area but it's a good example of how you separate different areas of applications and you have to have different tools different principles and then they interact no major system today is written in one language and there are good reasons for that when you look back at your life work what is uh what is the moment what is a event creation that you're really proud of they say damn I did pretty good there is it as obvious as the creation of C++ and so obvious I've spent a lot of time with C++ and there's a combination of a few good ideas a lot of hard work and a bit of luck and I try to get away from it a few times but I get tracked in again partly because I'm most effective in this area and partly because what I do has much more impact if I do it in the context of C++ I I have four and a half million people that pick it up tomorrow if I get something right if I did it in another field I would have to start learning then I have to build it and then or see if anybody wants to use it one of the things that has kept me going for all of these years is one the good things that people do with it and the interesting things they do with it and also I get to see a lot of interesting stuff and talk to a lot of interesting people I mean if it has just been statements on paper on a screen I I don't think I could have kept going but I get to see the telescopes up on Mauna Kea and I actually went and see how Ford built cars and I got to JPL and see how they do the the Mars rovers there's so much cool stuff going on and most of the cool stuff is done by pretty nice people and sometimes in very nice places cambridge sophia antipolis silicon valley yeah it's there there's more to it than just code but code is central on top of the code are the people in very nice places well I think I speak for millions of people we aren't in saying thank you for creating this language that so many systems are built on top of them that make a better world so thank you and thank you for talking today yeah thanks and we'll make it even better good you