Scale By The Bay 2018: Bryan Cantrill, Rust and Other Interesting Things

good morning everybody um it's great to be here I this is definitely the first time maybe the only time in my life that I'm in the functional programming track that is definitely a first so it's exciting because often on honestly functional languages have not really functional programming has not really been on the menu for me as a system software programmer it kind of actually entered the menu ironically enough with JavaScript I mean I'm embarrassed to say this but I I really I mean I yes my degrees in computer science so there's no real excuse for this but I didn't really appreciate or learn functional programming until implanting in JavaScript in 2006 so I hopefully I'm in kind of a safe space where I can confess that to you but um and actually it was funny for those of you who weren't around at that time to tell it was kind of a weird time because we had this thing called Ajax asynchronous JavaScript and XML worst acronym ever like you can't have one of the letters be a conjunction another be an abbreviation of a terrible terrible an idea or a good idea but of a terrible abbreviation terrible acronym and a bunch of us kind of simultaneously were waiting in the JavaScript in late 2005 2006 because we're trying to actually build these like interesting programs on the browser and discovering like oh my god that's a real language here in terms of JavaScript it's not just for blank tags like I'm actually doing interesting things and I actually like oh my god I actually I I'm learning what a closure is I'm actually I am appreciating a lambda I'm actually appreciating this stuff so that was great um but in JavaScript has been great but and we've used to Detroit for a bunch of different reasons but the truth is that in the deeper parts of system software we have not really had that kind of power that that programmatic power we've proven kind of stuck and I think we're about to get unstuck and I want to kind of explain what what I'm seeing there I want to talk first about about platform values and software values because the older I get the more I believe that that values are really core to the decisions that we make so what do I mean by by values so values are positive traits that you are choosing amongst so we all that there are lots of kind of positive things but our own individual values will dictate when if we when we have to choose between two things how we actually make that choice and different platforms make that choice differently and too often I think that we look at the different choices that a different platform has made and we we will criticize those choices or we will embrace those choices but we're actually doing is we are commenting on our own values relative to the values perhaps of a different system so our own values are really important and the values that we have shift based on what we're doing where when we don't have necessarily one set of values for all of the software we write we got different software what we write we will have different values and we want our software to reflect those values and I think that actually in the in the kind of the post open source world when we are selecting a programming language we're looking at a programming language we're looking at a software platform we should be looking as much at values as we are at anything else do the values here reflect the values that I want for this thing especially when community is so important I mean in an open source world you're selecting community as much as you're selecting anything else and I've learned this the hard way where you've got because if you like I love the technology and the community is I've got come comes vicious with but I really love the technology if the community doesn't reflect your values you will find that the software will come to not reflect your values as well so you really need to need to define the right community for the values the right values then for it for the job the right software for the value so what's gonna make this a little more specific here so this is just kind of a scattering of random values these are this is not a very well organized list I guess it's alphabetical I guess I could make it alphabetical other than that it's not really sorted it's not meant to be exhaustive there are lots more values than this and each of these values kind of mean different things to different people so there's a lot of nuance here but we can kind of generally agree what it means to have performances of value what it means to have robustness as a value or debug ability as a value or composability as a value or expressiveness as of you and you can't have it all you can't choose all of these things we can all agree that each of these things is important I don't think any of us would say that that value is just garbage and you should never want it right I mean for I don't know maybe there are some things up here but I think that in general we would say you know all of these things are important they're good they have their place but the real question is when you have to make a choice between two of them what do you choose and those what that choice that you make you being a software platform a language a community that choice reflects the core values of that that platform or language and you can't have every value be a core value so what are the core values of some of these things because these things are in tension and I think that they do when you have these core values they're going to attract like-minded folks and as a result they become self reinforcing because those who are attracted to those values are attracted to the software and then they want to defend those values in the software they want those values to remain consistent so that they there's a self-fulfilling prophecy here so let's look at these values so kind of grayed out the values that they don't have and say you know the history of C is pretty interesting we we tend to think of C and UNIX as being identical twins born at the same moment kind of in the birth canal at the same time that's not actually the case UNIX was actually developed before C if slightly units was developed originally all in assembly and there was an opera there was a language called B that was kind of floating around but they didn't really use B for very much B was slow so B was used for some ancillary parts of the operating system and they they saw the need to develop a higher-level language a structured language although the higher level came first that would allow them to not have to employ in the operating system in assembly that is that the birthplace of C is we want effectively a better assembly we want a non machine specific assembly and that's what C is see is effectively portably assemble portable assembly the a number one goal of C is is performance and I add interoperability that are as well because it is just models the Machine C is designed to interoperate with anything that can execute on the machine effectively so C interoperates with assembly it can interoperate with effectively anything that is going to actually operate on the machine so interoperability is very important portability these are important and then simplicity one of the things that's interesting about C is C only grew those things that were needed to implement UNIX so they didn't add structures to UNIX or just C until they realize they needed them named one UNIX so C it really didn't have structures seems like what do you what does he have if it doesn't have structures seems like it has precious precious little but assembly doesn't have structures so why would you and then that you know what structures would make this a lot easier so they added structures okay but they kind of stopped there and C has retained that minimalist aesthetic which i think is very core to two C's value so this is what I would say these values are and it's not that C doesn't care about these other things it's just that it deliberately if it has to make a choice between these or when it had to make a choice between these these are the ones that that it chose and admittedly C is also in a time when a lot of these things are much more profound tension performance and expressiveness for example we're very much in tension and that they chose performance just throw that as long as doing one letter languages in terms of B and C might as well throw K in there it's got nothing to do with system software enough people know K K and Q it's follow-on were developed by again Arthur Whitney who is definitely unlike a different astral plane so Arthur believes that the Arthur's aesthetic is all around minimalism and expressiveness Arthur Arthur learned APL from Ken Iverson at age four I'm not making this up he's like Ken Iverson's neighbor and further Arthur has the belief which I admire and I love and I I mean I I don't want to like III don't want to talk him out of this belief that he can teach any four-year-old API now when he told me this I had a four year old that I knew for a fact could not be taught APL I mean I'm Betty and and he's like you should bring your four year old and I will teach them aap I'm like this is gonna end poorly for everybody because I you are not gonna be able to teach him APL and he's gonna be very upset having to learn aap I think this is not gonna do well we're not I'm not gonna call this Bluff but I I I admire the beauty of a brain that believes that APL can be taught to a four-year-old that's that's amazing to me on but Kay's only values are in that expressiveness Arthur wants to write a program and I guess it's not funny I shouldn't say without laughing in as few characters as possible I mean that is what beauty is - Arthur fewest number of characters I don't know if he feels he's gonna be vividly punished for the number of characters uses I don't quite understand what drives that but that's what drives that and and he will make code denser and denser and denser and denser is it readable it is emphatically not readable and it looks like you know and from if you're of my vintage it looks like your mom picked up the phone when you were on the modem and you get like a bunch of line noise like that's like compilable K I think um but it's beautiful alright so that's in but these are the only values like don't care do we dead we don't get maintainability readability no don't care we care about its expressiveness in performance that's it performs very very well and used often for market facing kind of operations I just gotta throw this in there for another one that's quick that's kind of clarifying you know OpenBSD the operating system security end of core values the there is no other core value in open BSD in that and that that's not I'm not being perative it's actually incredibly clarifying when you have a system that is so upfront and transparent about this is what we care about and we don't care if we're gonna make the system much slower to make it secure that's what we're gonna do if we need to turn off hyper-threading because we believe that hyper threading is unsafe at any speed that's what we're gonna go do and you're gonna lose half your virtual cores but too bad they were never secure they were always vulnerable to side channel attacks but it's all true actually that's all that that's a totally reasonable if position an admirable position this is what OpenBSD cares about and and more power to them um I just I love auch gotta lock in there just give you kind of some different examples auch is really about like writing programs quickly I write I mean I don't know about you but I you know I write awk on a daily basis I write three or four Ockham's day like I just and these are one-liners right these are super quick programs but awk is really beautiful in that then I can write something super quickly it's very simple it's pretty expressive as these things go you can do a lot with a little anak it's very approachable you can get anyone to be if you've read the awk programming language so awk named because of aho Weinberger and Kernighan the three people that invented it the ark programming language I think is an absolute model of programming language documentation so you you get the awk program language it's like 130 pages the book it's beautifully written beautifully typeset you'll read it in like two hours and then you're done like that's it you know all about there's there's nothing more to know about Ock like you actually learned it all the end and it's there's something that is great and beautiful by that it's simple its approachable and so on I think you might be able to teach a four-year-old awk maybe you know that's crazy you can't do that I died but maybe a seven-year-old I'm okay now I have never written a line of Scala so and if you like if you like rush the stage because this is wrong um I'm sorry that's I put a question mark there to try to reason with the mob as they were throwing chairs at me so and I I'm not necessary asserting this but it is just kind of like try this one I think it's a useful exercise to think about like what are the core values for the things that I implement in the things that are important to me because that's probably why they're important to you that's probably why you gravitated them at some level um in what I see in Scala is certainly expressiveness writing is very important I think you've got to put interoperability way way way up there I mean the whole point of Scala is to be able to interact with the Java ecosystem at large that's a very core principle to me that's a core value I mean I remember actually seeing what I think must have been one of Martin's very first talks on Scala um back and I think 2004 and the this was a big deal the ability to reuse java classes in a language that provided integrity and robustness and expressiveness and composability and I'm not saying that Scala doesn't care about the things that that aren't bolded here but just if it has to choose this is what scholars gonna choose I thought was very interesting because you saw the panel last night where Martin was being asked what is your kind of vision for Scala going forward and it wants to make it easier to write robust programs it's really about writing robust software and I thought it was interesting too that eliminating some of the things like the XML in URLs I did not know that XML literals but eliminating some of things that we no longer need because they're not gonna serve these values I'm not sure where xml literals fall on the values and the moon Ranelagh okay so the there the challenge for that we have in system software that is not necessarily a challenge that you might have in software your writing but in the in in the software in the system software that is beneath you or beneath us that is that that is that is say it comprises the the foundation upon which we build the values are dictated by those who will use the software it's dictated by the expectations like the the an operating system that for example does not hold of the values around say robustness or safety or or security that operating system is one that is not long for this universe because you're not gonna want to use it no one wants to have an operating system that panics on them no one wants have an operating system and our expectations for the operon system and for system software are very very very high and rightfully so they should be high on and so in an in particular if there are certain values that if your system software doesn't have it your software can't have it and we are learning this the hard way because these values go even deeper into security right I mean 2018 has been my Anna's horrible us because of and it was it was on you know January 2nd of 2018 when I'm looking at this hacker news story that someone trying to kind of reverse engineer some patches that are being floated against the Linux kernel thinking there may be a really serious security vulnerability here with Intel and the US and that was the beginning of the end for my 2018 because 2018 has taught us that that security what was ultimately subservient to performance in the design of the microprocessor and we were all complicit in that by the way like what's not it's easy to kind of like blame Intel for that but the reality was we were all complicit in that we that's what we demanded the problem is we discovered that that that very lowest substrate because it chose performance over security at some very key and implicit junctures we ended up with a substrate that self above it in the operating system the system software that now lost security as a value it doesn't matter how much how dear you hold security if you have hyper-threading enabled doesn't matter because because the hyper threading itself is not secure or it doesn't matter in if you don't have kernel page table isolation doesn't matter how dear you hold it because now you are vulnerable to an attack but from a substrate that ultimately chose something else over over security and this is very painful for us it's very painful when you're when the the infrastructure the layer that you depend on because we all depend on layers beneath us when the layer that kind of a jack-in-the-box hey surprise I don't hold the values you thought I held it's like okay well I guess I will cancel what I was gonna do for 2018 and spend the time getting the system back to where I thought it was on on December 31st 2017 which is what we have effectively done it's been it's been very frustrating in that regard but that's a four system software we have to hold these values it is essential so these are the values that we demand of system software um it's got to be compatible right you you're not gonna an upgrade to a microprocessor to an operating system to a database when that breaks your software that's not okay it's got to be developed we have to understand what's going on why things are failing you've got to have integrity as a core value you can't have data corruption um you need performance I really wish we get just like can we just get rid of performance then it'll be fine and we don't need performance you know a the the late great Roger Faulkner I worked with at Sun Microsystems for a long time which said that performance is the root of all evil and and he's right performance is the root of all evil if we are are happy with our systems not performing well things get a lot easier but if that's not we don't want to do that right performance is important performance drives right to the economics of what we're doing it's not okay to be wasting cycles that we don't need to waste we actually have to have performance as a constraint and this can be brutal by the way especially when the numbers are small it's like man this thing is like 2% faster than you guys just like that 2% is brutal to get out of but it's important it should be important it's important that we hold that value for our system software it's got to be resilient it's got to be robust it's got to be safe it's got to be secure we that that's paramount that it's secure it's be stable it's gonna be thorough in that our system software our microprocessors our operating systems even our databases we need them to support a wide range of things they these are not purpose-built things we can't afford for them to be purpose-built things they have to be generic that generic ism requires a thoroughness that is actually really challenging we got to be transparent we got any kind of the day of proprietary glop well it was but it behind us and then that's actually this is coming back actually with the whole cloud thing so I'm we work for a cloud cloud provider although our software's all open-source but right now us compute is being reprioritized by the by the cloud providers so transparency may be fading as a value I hope that we'd go and demand that it back again okay so I just wanna remind you with the platform that the core values of C are so we're just gonna kinda do this all right so that's what we demand that's C what we demand C it's like right eye left eye right eye left eye right eye left eye all right there's only one value these things have in common performance that's it everything else and this is actually and you know what Roger accepted Roger passed away a couple years ago Roger you are haunting us from the grave because you are actually all right Ron performance actually is the root of all evil here because if it performance ultimately in terms of the values we demand for system software we do demand performance over all else that is the reality we might not like that but we cannot accept a system that is better in all of these other attributes but suffers in terms of performance and for evidence of that just look at history's graveyard of systems that did deliver and you will find people that that talk about you know capability based systems or micro no based systems or other other systems that ultimately fell down on this most important criteria and I say how you sort fork UNIX so I love my kernel so I'm not I'm not trying to pick I pick at wounds but performance ultimately is is the most important thing so that's C C is clearly I mean we kind of got in there with C but it's been really painful well what about C++ all right well this might be for C++ so so C++ okay so we're definitely gonna get rid of simplicity I don't have a way of saying there should be a way of like I need a strikeout to be like I hate simplicity like that's like I am actually anti simplicity cross that one out so see West boss is like anti simplicity um and then I also decided that again in my kind of as long as I am issuing fatwas against programming languages I I decided that expressiveness is important interoperability is actually less important to C++ C++ has actually made choices yes C++ is a better C and yes I think it can still compile C although that becomes less and less important over time but the C++ struggles with interoperability at a deeper level where you have components that are written in non C++ trying to cooperate with components that are written in C++ it is possible but very very painful and C++ does not make it easy across the board I mean it starts with name mangling and gets much much worse it's really really painful to make software uh you have to design your C++ to explicitly interoperate with C which is very frustrating because you have these software out there that it's actually only in C++ is gonna be very hard to actually get a dinner operate with C so this gives us the this this tremendous divide this tremendous disconnect between the values that that the system software programming languages have had in a way performance and then nothing else um and the values that we need for the software we have have all these other values now we've gotten there um it's been a long painful arduous path the reality is our system software does work it is actually it does have all these other values it does it is stable it is sick it is I mean it is relatively stable it is relatively secure or I thought it was secured on on December 31st 2017 anyway it is relatively safe relatively robust does perform well but we've gotten there the painful way it has taken us a very long time we've written a lot of bespoke tooling now we've also gotten very good at it I'm good at writing my C does not it is not going to dereference memory it does not have that is not a failure mode that I have in the C that I write because I've been doing this for a long time and I know how to malloc and free and I know how to create dynamic data structures and do that do so completely safely and I can very quickly that's good it was very painful and the truth is it is very much dependent on me the programmer and my reviewers and my testing and so on there's no net that is provided by the language at all the language is allowing me to do whatever I want it's you know it's like a Montessori Preschool as long as we all worship at the old or at the altar of performance um so the you know the question is like it can we do better because we've succeeded despite the language not because of it is there an opportunity to better and I was actually at the point where I was beginning to despair a little bit where I had and yes there are the language to come out you may be familiar with giant because of nodejs I had this like great belief that no js' was going to be what would save us all um yeah and if you would be like no that's just JavaScript I'm like I know I know it's just Josh but I wanted so much better I wanted so much better for JavaScript it wasn't gonna be JavaScript it was gonna be a dynamic language in which we could write robust server-side software and it's just JavaScript it's just JavaScript dude I it is just JavaScript and and what I mean by that is the values that JavaScript has aren't bad values but they are not the values that we have for system software that defies JavaScript as is really around velocity and especially approachability we want as many people as possible to be able to write JavaScript and that is not that's I think that's a great ambition and there's nothing wrong with that value it is antithetical to system software because that does become in tension and suck if we want to choose an abstraction that allows ten thousand more people to write software but that soft word will be rife with edge conditions that they will probably never encounter should we do it if your first value is robustus you say no of course not if your first value is approachability and and growth then yes of course you should and that is the fundamental tension for us um so I want us to do better um I I was I was beginning to despair because I didn't see a language that was that was really offering fundamentally different values and then along came rust and now along came rust rust has been around for a long time started actually a long long long time ago started in like 2006 or just a little bit later but rust has kind of has grown over time and I like I think many people have been increasingly rust curious over the years right and my my rust curiosity has has grown over the years because rust has this incredibly interesting system of ownership where whereby you are the programmer are going to work with the compiler to figure out who owns what when who owns what piece of memory the compiler is gonna restrict what you do and you're not going to burst into tears when it does it that's like that that's the bargain that you're gonna have with the compiler as a result the compiler knows when things need to be allocated and when things need to be de-allocated when they're that are still reference to this and when there is no longer reference to and you're gonna work with it and as a result you get the denied then the dynamicism that you get in a garbage collected language but the performance of explicit memory management and this is amazing and importantly unlike see rust is highly composable so the big problem with see I mean this is always the problem right it's not it's not you it's the other person like I know how to write memory say I know how to actually deal with memory safely but calling you to a library that jerk no I don't know how to do a memory safely or but it's even worse than that right because what where things get dropped is in the boundary is in the the library is allocating something on your behalf that you are explicitly or implicitly expected to free or deallocate you lose track of that you've got a memory leak memory corruption are worse it is very hard even if you're very good at seeing a between here career it's very hard to compose it so what we end up doing is having these very minimal kind of structures where we embed these things in larger structures and we're able to do so totally safely but ultimately sub-optimally rust actually allows us to have higher performing primitives and so as a result and I'll come back to the rust values but in in my experience and this is my experience I'm not trying to draw a large conclusions this is a bit of software that is what I was alluding to us on in the panel that I'd written in C and I'd kind of written in you know hand optimized C I went to rewrite it and rust because I was increasingly rust curious and wanted to finally say that rust curiosity by writing some real rust after a lot of back and forth of the compiler some tears that I wiped away um do it like let the wookie win is my advice when you're dealing with rust that what you want to rust wants you to do things certain ways and you're much better off doing things the way rust wants you to do it so I did it in a way that was obviously suboptimal but fine I can get it to compile I just gotta like I don't even care about performance anymore just let me get this thing working and then and I know it's gonna perform terribly and then I ran it and it outperformed my C it's like what how did that happen how and I took it apart and how did I outperform I see well this particular software spends all of its time rebalancing a binary tree and in rust the primitive that I was using was an AVL tree which is the thing we've used for ever and I've got a very robust AVL tree implementation that I've used in rust you don't have to AVL tree actually the betray B tree you may remember from databases right but the rust observation is actually with the memory hierarchy being what it is a beech tree actually makes sense just in software that's not talking to disk you can view DRAM as the disk that you're talking to and a beech tree actually makes a lot more sense beech trees a pain in the butt to implement but with rust you can just use it you don't have to actually know any of the implementation details of it and as a result it outperformed my safe in large part because the data structure but also because there are optimizations that Russ can make that C could not make and then of course it was like wow that's a GCC issue how about clang I'm like clang is not gonna fundamentally change the physics of my C which it doesn't like clang makes it a little bit better this is the lower is better here um so this was really interesting to me and it shows the the kind of the core values of Russ um so yes performance it has to be performance it kind of the epicenter of the universe but you get that composability the expressiveness that you in the scala world have had for a long time we now get this to have this at a much lower level we get safety we get security we get rigor we get robustness we get integrity and very importantly we get interoperability and this is actually the difference between rust and other languages that look somewhat similar is rusts emphasis on interoperability rust does not aspire to rewrite everything in rust rust is trying to cooperate with those systems that already exist so it's not just ownership um the I know that you know and you would be right to be annoyed when a bunch of systems people discover algebraic types like it's a brand new invention it's like hey I just found out like I'm getting clean water out of the tap I don't have to boy you're just like yes you knucklehead like yes you clean water it's valuable like your babies are no longer dying it's amazing um but algebraic types okay and I knew about algebraic types in the abstract but to actually be able to see how algebraic types can be used for really concise error handling you can make much more robust stuff and again you know this I'm actually I'm literally preaching to the choir so what next um but algebraic types are amazing and they are amazing for reasons beyond what I appreciated um hygienic macros true story I did not know how to spell hygienic before rust hygienic is kind of a pain in the butt you got that second eye in there like what's that doing there but the the eye I have been so far from hygienic macros that I literally didn't know how to spell it now macros are a key for us and C we use the C preprocessor all the time I could not have written the code that I've written in my career without C preprocessor macros are very important the macros and rust are amazing the foreign function interface is what allows it to interact with C based systems it's outstanding and then there's this unsafe keyword which is this kind of get-out-of-jail kind of like a furlough program you get to go away a conjugal visit with your memory you don't actually um sometimes these metaphors occur to me on the fly and I realize like as it's going out of my mouth the other part of my brain is like no let's kind of let's pull that one back please pull them out here that one's gone all right fine never mind it's been it's been tweeted forget it um but the the unsafe keyword allows you to relax certain restrictions that Russ puts in place that allows you to then in very isolated parts actually leverage what you know of memory and to build even higher performing things better things but you've really can find that unsafety so I think actually unsafe keyword is terrific terrific community thriving ecosystem I mean there's a lot to love about it um so that's the promise of rust there there is uh it and I made made references last night but the beauty of rust is that it shifts the cognitive load back from software when it's running in production to the developer and development which is great news if you're me I think great is if you're us but it means if you're the developer and development you're like where did all this cognitive load come from like I I'm much more used to being able to just kind of like push it into production but I know there's a lot more cognitive load a lot more things you need to think about and Russ complains about things that seem very very very pedantic and it can take a while to realize that oh rest is right actually rust is right there's an actual real issue here I mean there are a couple instances where people are convinced they're having a fruitless argument with a compiler because the compiler is wrong and they realize the compiler is actually right so um it's a really interesting that regarding it restricts what we can do it can be very very frustrating this is a quote from from the programming rossbach which I love that they you have a period of intense arguing with a compiler at the end of which the code looks rather nice as if it'd been a breeze to write and runs beautifully but there's no way that code is like you don't get the screams of pain that the developer had in getting that that kind of beautiful code that beautiful artifact so the the the peril of rust um is that it's got less of an advantage I think when we are reimplemented extant systems so when the software already works it's less clear to me especially you've got multiple own data structures like an OS kernel um I think that's gonna be brutal for rust but there are a lot of opportunities for us and start to kind of speed through here at the end but there are a lot of opportunities for rust because of its interoperability as a core value god bless that interoperability and performance is a core value because it allows us to do with rust what we did with C which is take an iterative approach start rewriting things in rust we don't have to rewrite the entire world in rust we can start rewriting parts of Ross and I think this is something that the scholar community really gets from its interoperability with Java but I think we're really learning it in system software um and so I think it's it's a new dawn of development in that regard the system is obviously much they're much broader than just the operating system there are a lot of use global components that are a natural fit for rust if I were writing system D today I mean I didn't write system B but if one were right actually mentioned system B if one were writing a user level facility to manage software as a service I would write that in rust absolutely and in particular just to close with the other body of software that I really want to see rewritten is the software that you can't see and I can't see and none of us can see the software that works beneath us is firmware I've been fond of saying but I believe it fervently that we are engaged in a war with firmware it is humanity versus firmware and everyone needs to pick a side so I hope that you pick the side of humanity and I think there's a lot of opportunity to rewrite that Louis all the software which I honestly is still in assembly or C I think there's a lot of opportunity to rewrite that in Rus so I think the you know one of the things that the Rus community says over and over again is we can have nice things and I think that that is very much borne out by Rus values the values themselves are a great fit for system software it doesn't mean it's a fit for everything and you shouldn't let anyone try to convince you that it's a fit for everything it's not but for certain bodies of software and in particular the software that I like to write it's a great fit and really liberating and I think we're gonna see a lot of system software written in rust with that thank you very much yeah I don't like negative five minutes for questions okay yeah I'm happy to take a question or two yes yeah so that's a great question and I mean clearly like if when you're talking to si si you can clearly be zero your address space I mean so it's Russ is going Russ is going to help you out with the safety of your code but when you need it I mean so for example if you want to call em map the which is allows you to actually M map a an object into your own address space that's an unsafe operation so you will need to wrap that in on safety I think what it's doing is confining that on safety such that you're aware of it so it does help you out in that it limits it as opposed to like letting that poison an entire application that make sense yeah cool any other other questions yes so what do you think of the idea of what systems for every but there's other spaces where it's very important to just in yes we're worse they did what was intended right you see a role for us not just as a system software but for example like cooperating what they did game or as some kind of date libraries and where you can combine the two system absolutely and I'd say any place where these values are important Russ is gonna have a place and in particular where these are the choices you want to make and in particular particular where performance is the is your top choice if if performance is your overarching value I think rust is absolutely gonna have a place all right I think I'm out of time thank you very much everybody [Applause] you

Channel: FunctionalTV

Views: 30,337

Rating: 4.9498434 out of 5

Keywords:

Id: 2wZ1pCpJUIM

Length: 37min 6sec (2226 seconds)

Published: Sun Dec 09 2018

Reddit Comments

[u/oconnor663]

One of my favorite bits at 33m08s:

There are a lot of options for Rust, because of its interoperability as a core value. God bless that interoperability and performance as a core value, because it allows us to do with Rust what we did with C, which is to take an iterative approach. Start rewriting things in Rust. We don't have to rewrite the entire world in Rust. We can start rewriting parts in Rust.

[u/gnuvince]

"Let the Wookie win" is my advice when dealing with Rust.

I cannot agree with this more. From what I've observed, the people who struggle the most with Rust are those who have an idea of how to write something and refuse to adapt when the Rust compiler refuses to type check their code.

[u/Plasticcaz]

I was introduced to Bryan Cantrill earlier this year (probably by his first rust talk), and he has fast become one of my favourite speakers. I am looking forward to watching this.

[u/Atheriel]

My favourite engineering speaker has discovered my favourite language!