Latest / Oxide and Friends / Across the Chasm with Rust

Transcript

Across the Chasm with Rust · Oxide and Friends

• 0:00
  Speaker 1: Alright. With that, I think we're good to go. So, and maybe not even with the with our traditional complaint about Twitter spaces, although I it it doesn't feel right to not complain about it. So I don't know.
• 0:14
  Speaker 2: Work work pretty good last week. Let's, hope for the best. Or
• 0:16
  Speaker 1: Of course. Because I'm saying that. It's gonna really be a disastrous week. So, Adam, you're describing how we got here? Because you had a tweet over the weekend that I think got us here.
• 0:27
  Speaker 2: Yeah. So, let's see. So, you know, there's the every so often, Steve, you can tell me how often because I don't keep track, there's a new Rust release. And then on Twitter, because I've been following more and more of the right folks, folks get excited about little here and there details. And one of the things in the most recent Rust release is let chains.
• 0:49
  So in Rust, you can say, if let and then a pattern equals some variable and, it was sort of annoying in the past where if you wanted to do many of these things, you had to sort of nest them deep, which was annoying, or you had to put a match, which was kind of ugly. And now you knew Rust Chain. So, a let chain. So that was an example of just, like, some nice thing that came along without, you know, just I mean, from my perspective as a dumb user of Rust, it just kinda fell from space onto my lap and now I get to use it. And I feel like that happens a bunch, and it's one of the things I enjoy about Rust.
• 1:25
  Speaker 1: Yeah. Amen. And I think so well, we we talked about this specific feature. Because, Steve, this has been in the works for a long time.
• 1:32
  Speaker 3: Correct. Can you hear me? I don't know if my microphone is on my phone or if it's on my headphones. Yeah. We gotcha.
• 1:38
  Speaker 1: Okay. Cool. Where were you
• 1:40
  Speaker 3: yeah. Just like, yeah. This feature, I don't remember exactly how long, but it definitely was talked about for a while, and that was, like, for in the first place. My understanding is that Swift has had a similar feature for kind of a long time, so there was some amount of precedent. But, my recollection was there was a lot of talk about the exact syntax that should be used, and that kinda, like, held it down for a little while because this is not, like, a particularly complicated feature semantically, but, you know, making sure that you got all the your ducks in a row could take some time.
• 2:15
  So, yeah. Totally. It, like, took a little while, but it's here and that's cool.
• 2:19
  Speaker 2: And I would say one one of the, kind of one of the things that is a huge time waster for me, say like late Friday evenings or whatever, is getting deep into some of these Rust features that feel like I really want them, like let let chains or like, having traits, have async, within them. Yeah. There's stuff like that that, some of them just feel like, oh, like, this is a kind of simple feature where we're dealing with with some of the esoteric details. And then some of them are just huge deep rabbit holes, where people have literally been talking about them for 6 years and the level of complexity associated with them just boggles the mind.
• 3:01
  Speaker 3: Definitely.
• 3:03
  Speaker 1: Well, and and I feel that, I mean, if lat is one of those. Like, it is not simple to if the the let change is definitely not simple. There's a lot of edge conditions that and it was interesting to because, Adam, did you go back to the history of this thing at all? I mean, it's been around for 4 plus years.
• 3:17
  Speaker 2: No. You know, I I had been through the history of it. You know, one of the, like, 10000 times I needed it, but I I've not, like, refreshed my memory on that.
• 3:26
  Speaker 1: It was interesting in terms of, like, the Odyssey that that the a feature like this goes on. And I, for 1, actually I know that Odyssey is extraordinarily frustrating, probably for all involved. But, for us, those who actually are the, like, Rust users, it's I really appreciate the Odysee because they they really make sure that they're not breaking things. I mean, I think, Steve, correct me if I'm wrong, but the the it just seems that breakage of existing crates has taken really build the various. People do not wanna break existing crates.
• 3:56
  Speaker 3: Definitely. I mean, that's the whole point, like, we run this test suite of the entire of all of crates as part of the release process. Like, it's important.
• 4:05
  Speaker 1: Which is I I I have to tell you is great. I mean, they just like the the level because I I feel like this is not always the case with just software in general. I think the often there's not a great deal of empathy with the users, frankly. And it feels like if someone wants to do something and they're kind of, you know, loud enough, they can make it happen in a lot of communities. And that doesn't really seem to be true at Rust.
• 4:29
  It seems to be that there's, like, a lot of really thoughtful discourse on these things. And I said, I'm sure it is, like, frustrating for most people most of the time, but the the artifact, the result of that is really, really, really good, I feel.
• 4:41
  Speaker 3: Yeah. There's definitely a super huge balance. There's a number of people who have, like, burned out and quit over the years because of this being so onerous, and, like, it is definitely true. I think something that we see a lot more it's kinda happening a little bit lately in some cases, but what I see in other places I mean, like, literally, like, Guido stepped down from being the BDFL of Python because he added a feature that he really wanted and everybody hated him about it and he was just sick of taking shit from people. So, like, this is definitely a thing that happens, in programming language communities in general.
• 5:13
  And actually, ironically, the, like, stability thing, one one place that takes that, like, stronger than you may normally assume is, like, Ruby is, like, actually very weirdly stable in a lot of ways.
• 5:23
  Speaker 1: Oh, that is that is surprising. I don't mean to sound pejorative.
• 5:27
  Speaker 3: Yeah. Totally. Surprising. There is a there's a feature in Ruby called flip flops. I don't know if you've ever heard of this feature or not.
• 5:33
  It it you basically, like, you have a range and you use a triple dot, and what happens is is iteration happens, it goes from, like, returning false to then when it gets within the range, it starts returning true and then outside it starts returning false again. This is a pearlism that, like, got put in Ruby that, like, never got taken out. And so when it was time to talk about, like, Ruby 2.0, somebody filed a bug that was like, hey, we should finally remove flip flops. And there the people were like, well, does anyone know if this feature is being used by anyone? And, Yatsuke Endo, if I remember correctly, was like, I'm actually one of the users of flip flops.
• 6:08
  For example, this. And he posted a Quine, written in the movie that relied on flip flops.
• 6:14
  Speaker 1: This is a load bearing quine quine quine
• 6:16
  Speaker 4: quine quine.
• 6:16
  Speaker 3: Yes. And so Matt went, cool. Seems like people are using this. Never mind.
• 6:19
  Speaker 4: We're not gonna remove it and close
• 6:20
  Speaker 1: the button. Okay. So, like, Steve, you should explain what I mean, I I you should explain what Acquiant is.
• 6:26
  Speaker 5: I I bet
• 6:27
  Speaker 1: if folks don't know what Acquiant is
• 6:28
  Speaker 3: So Acquiant is a program that prints its own source code, basically. And you can also have variants like, this well, the reason I remember that it's, Yatsuke Endo is because he is, like, kinda semi notorious for making a lot of these coins. And, one of the ones that he did previously was a, like, I think it's called a 7 quine. It's how you determine, like, the number of iterations. So step 1 prints step 2 prints step 3, and then print 7, print step 1 again.
• 6:57
  So it's kinda like that kind of coin. He did one where, it looks like a globe that rotates through those 7 steps, so when it gets back to the start again, like, that's what it's like. Wait. Wait. Wait.
• 7:08
  Speaker 1: Wait. Is he the one who did the the the 100 Yes. Language query? Correct. Yes.
• 7:14
  So, Adam, do you know anything about this? The the 100 language query?
• 7:17
  Speaker 2: You know, you told me about this, like, maybe, like, 8 years ago, something like that.
• 7:22
  Speaker 1: Yes. Good memory because we used it to test, LX. So we done a Linux personality for smart OS, and it was delightful to discover this now a 128 language coin relay. So coin relay is and just as Steve is describing is a program that generates another program as output. That program generates another program and and so on and so forth.
• 7:47
  And then it the the 128th program generates the first program as output, which is extraordinary. And it actually causes to debug some really gnarly bugs in some very strange languages called I wanna say it's is it g Portugal, r Portugal? It's there's a language that's in Portuguese Portuguese, everything about it is in Portuguese, and it was we had a super esoteric linger issue again. But then, Steve, this thing was amazing. This coin relay was amazing.
• 8:24
  Speaker 3: Yeah. I'm gonna triple check those things. I'm, like, 99% sure that it was. Well,
• 8:28
  Speaker 1: I did. The person who did this was definitely.
• 8:31
  Speaker 3: It was. Yeah.
• 8:32
  Speaker 1: Okay. Yeah. Yeah. Because there are a bunch of like, because I'm like, how do you do this? And there is an issue where someone's like, hey.
• 8:41
  Look. Like, I'm a researcher and how you kind of, like, address like an open research question, and I'm I'm very curious how you did this. Can you describe your, like, your methodology here? And then he, like, closes the issue out with, like, the cherry blossoms are out in Tokyo. Closed.
• 8:57
  Yep. And he's like, okay. Is this is this potentially, like, an alien life form? Is this from this I mean, it's it's amazing. It's otherworldly.
• 9:06
  So the fact that this person needs an operator does not mean that everyone needs it. I think it's the moral of the story. I think that's true. Yeah. And the flip flop is, did you ever use it in actual code, Steve?
• 9:20
  I'm still trying to understand, like, when I would actually want that behavior.
• 9:24
  Speaker 3: Yeah. It's it's I forget why, like, it was originally put in Perl or whatever, but it's it's something about just, like, when you need to do certain kinds of range operations, then it's useful for I I don't know. I've never used it for anything important.
• 9:39
  Speaker 1: But the fact that it's got Pearl origin is definitely interesting. So I would contrast kind of Pearl something back in the day, where it just felt like it would add abstraction really quickly without necessarily thinking about the longer term consequences. And then it became a language that had so much abstraction that it became unreadable at level because someone goes to different abstraction to do the same thing.
• 10:00
  Speaker 6: I'm gonna use it as a girl.
• 10:04
  Speaker 1: This was
• 10:05
  Speaker 6: this was not super uncommon to use this in Pearl. And it it like, the the utilities, you can say things like, does this number match in within this range? Like, does this IP address match within this range of permitted IP addresses for something?
• 10:20
  Speaker 4: That that
• 10:20
  Speaker 6: was a really, like, Perl esque use for
• 10:23
  Speaker 1: this. Interesting. So the but that that's, interesting that they so in terms of the way, I guess so, Steve, the moral of the story was not the coin relay. It was Yeah.
• 10:36
  Speaker 6: That
• 10:37
  Speaker 1: the just the way that Ruby dealt with a feature being used versus the way that Rust thinks about it. I mean, were you contrasting that to the Rust community?
• 10:46
  Speaker 3: No. I was saying that I think that it's like different languages have different attitudes towards stability and Rusts tend to be extremely on that way. And I think some languages, even if they have the perception for being the other way, at times will be conservative. Like, you can't always, like, you can't always say that a language, like, is super stable or is not in all circumstances because, like, it just really kinda, like, depends. And so Right.
• 11:10
  You know, like, Rust tends to take stable features really seriously, but unstable features change all the time. And, like, yeah, unstable features aren't in the language proper yet, but, like, the point is there's a mechanism for language developers to, like, care and not care and they it's clearly divided in Rust by the tooling, but other languages also do this kind of thing, they just don't necessarily have that distinction and so it can feel like they break a lot of things when sometimes maybe they, like, don't break something you don't notice as opposed to they do break something you do notice or whatever.
• 11:38
  Speaker 1: Yeah. That's interesting. In terms of, like, the because Rust definitely does have first class support for experimental features.
• 11:52
  Speaker 3: This statically and also, like, cleanly to know what things you're using and not using.
• 11:57
  Speaker 2: Yeah. It's it's such a lovely mechanism to to both have that extremely strict, like well thought out process for evolving the language, but then also have the the, like, nightly YOLO, do whatever you want. Like, I'm sure there's more strictures than that. But to have those opportunities, I I I think, like, you can't have one without the other. Like, to to have that strict process almost, you know, in order to to build that language and and and do it accretively, like, requires that avenue for exploration.
• 12:29
  Speaker 1: Yeah. When then you also allow you can get some real experience using some of these features, and that experience can also be I mean, I were do you remember the our our misadventures with the exclusive range operator in in match patterns, Adam? No. So there is a still, I believe, experimental feature for, so Rust has the exclusive versus inclusive range pattern, but the matched and tax forces you to use the inclusive range pattern if you're gonna use a range pattern in the in a match arm. Steve, please correct me if I get any of this stuff wrong.
• 13:05
  Speaker 3: I believe that's true. This is like, I actually don't use exclusive ranges very often or, or inclusive ranges very often, so I'm not as familiar with the specific details of some of this deck. But, yeah, you're totally right. There's something there. Yeah.
• 13:18
  Speaker 1: Right. And so you actually but in a match pattern, you need it well, in a I I feel like in a match pattern, I don't very often use ranges, just full stop. But the in a match pattern, you have to have inclusive ranges. There is no support for exclusive ranges. And we had I don't know if you remember this, Adam, but we had a bug in talk super early on in oxide that was due it is because the problem is if you support both inclusive and exclusive range patterns in a match arm, it's really easy to screw that up.
• 13:48
  And Talk had screwed this up in one place and then cut and pasted it everywhere. And it's, like, kind of hard to read and re it's hard to to, like you have to be just very, I think, not just rust literate, but you have to know that, like, the double dots is always the exclusive range pattern, and this should be double dots equals to match the intent of the programmer. Does that make sense?
• 14:11
  Speaker 2: Yeah. Yeah. Yeah. Now now I do remember this. Yeah.
• 14:13
  And and and they had enabled some nightly feature.
• 14:16
  Speaker 1: They had enabled and I'm like, I don't understand how this this code is broken. And then I'm like, oh, they've enabled this nightly feature. They've misused it everywhere. And it's it's interesting because, like, this is the old this is one of the very few, like, language issues that I've kind of been involved in, but only as, like, hey. I wanna give this, this kind of report from the field that a project turned it on and misused it everywhere.
• 14:42
  And people should probably think carefully before enabling it. And that comment was, like, hugely down voted.
• 14:49
  Speaker 4: People were just like, burn him. Burn him. He's a witch.
• 14:53
  Speaker 1: He's a witch. And the and but what's interesting is that the I'm like, look. I just think you wanna be very careful because there's no way that Lindt is not gonna find us because these are 2 separate program where it's at. And I'm just like, I think it's but what's interesting is, like, the then to watch that discussion kinda happen over the years. And because the the other thing that I love is that Rust, the the Rust compiler will vector you to an open issue on something that is like Germane.
• 15:24
  And the Rust compiler, if you try to use an exclusive range pattern, the Rust compiler would be like, oh, no. You can't use an exclusive range pattern in a match arm, and here's the issue that's open for it. And over the years and I this this just happened, like, this afternoon, but every, like, once in a while, someone weighs in on that issue being, like, the fact that this is not like a power just saved my butt because I was about to, like, have a bug, basically. Yeah. And I think that that is I mean, obviously, I I got feelings about this particular issue, but I think, like, the meta issue of being allowing people to experiment with nightly features for better and for ill, and then offer feedback on that and have the compiler kind of aware that, oh, by the way, there's this what you're using is actually there's an experimental feature for this.
• 16:13
  And I think it I did actually great, in terms of the way that engenders discussion and and and feedback.
• 16:20
  Speaker 3: It it is also important, though. I think the the point that was made a minute ago that that also this is, like, tied to not being in stable until it is allowed to be in stable is actually really critical, though. And because we have actually have an existence proof of the downsides of this, I'm gonna pick on Haskell for like just a minute here. Haskell has, language pragmas, you can basically turn on features, in the language. And this was, like, kind of their my understanding, I'm not a super expert on the Haskell development process, but my understanding was this was part of the, like, we're not sure if we're ready for the speech or to truly exist in a language yet or not, so they're turning it on as, like, an extension.
• 17:03
  There's also some weirdness between, like, Haskell, the language definition, and Haskell is actually implemented by compilers, but, like, it's a whole separate sort of thing. But, anyway, the point is is that you can turn on those features in a stable compiler and, like, use them, and this leads to a dial an explosion of dialects where some people turn on some sets of features in all their projects and other ones don't. And this can also be kind of a problem because it there's no guarantee that they'll work well with each other, and so sometimes, like, somebody will, you know, land their favorite feature they've been working on for their PhD thesis or whatever and then kinda, like, abandon it and a bit rots a little teeny bit, like, doesn't work in some combination with this other feature because nobody did. You know, how do you how do you test the combinatorial explosion of which sets of these features are turned on versus not? You know, it's just like a hard engineering problem.
• 17:52
  And so that, like but that, like, happens because people in the CMS table can end up using those things and it leads to a lot of, like, fragmentation in in my understanding. That's what I've heard and observed people talking about. So, yeah. So I do think that both parts are really important. The the being able to have a way to try this stuff out and get it in people's hands, while also being like, most You have to explicitly opt into it.
• 18:16
  I think it's, like, really significant.
• 18:17
  Speaker 1: Yeah. That's a really important point because sorry, Adam. Go ahead.
• 18:20
  Speaker 2: Oh, Steve, I I was wondering. I I, you know, from my perspective, you know, some of these issues I I I dive deep on. Like, for example, when, like, ASM was was gonna be in in stable. You know, I was definitely sitting there refreshing the GitHub issue. Like, I know this is, like, ridiculous.
• 18:38
  But but, like, I I I was, like, okay. Another checkbox got checked. Like, we're we're 4 out of 5. Like, we're gonna get there. Very excited.
• 18:46
  Speaker 1: It's like you're watching, like, Apollo 13 return to
• 18:49
  Speaker 3: simulator. Yeah. Like, a
• 18:50
  Speaker 2: lot of people were watching, like, SpaceX or whatever, but this this
• 18:53
  Speaker 4: this was You're watching As of Land
• 18:55
  Speaker 1: and I Alcadable. Yeah. Exactly.
• 18:57
  Speaker 2: So but but I I gotta say, look, I don't have a lot of visibility into, like, what the process like, when when you know, how does how does something go from, you know, a, a goofball experimental feature or, or something that is in flight to something people are using to then folks getting, you know, the the cabal, the the council of elders saying, okay, we now let's make a push. Let's get this across the line. You know? And again, with without maybe the the gritty details of how how a bill becomes law. But just what's the general like, how does something get enough momentum to get across the line?
• 19:42
  Speaker 3: I want to think about what I want to see.
• 19:45
  Speaker 2: Totally fair. Totally fair.
• 19:47
  Speaker 3: I realized
• 19:47
  Speaker 4: I realized that he charged me.
• 19:48
  Speaker 1: He used that as if, like, Adam's trying to bribe you.
• 19:51
  Speaker 4: Like, I don't
• 19:52
  Speaker 3: even know.
• 19:53
  Speaker 1: Listen. I'm being a king of favorite charity.
• 19:55
  Speaker 2: I'm not a cop or anything.
• 19:56
  Speaker 3: I'll do it this way. The fact that you don't know that is a problem in the process that there has not been a lot of appetite for solving lately. And so I myself don't really fully know how that works anymore because things have changed. And so I have not been able to keep up with the way in which they have changed.
• 20:23
  Speaker 2: Wow. It is amazing that you constrict that whole sentence without using the letter e. That was that was remarkable. No. I I get it.
• 20:32
  My apologies, Steve, for for kinda putting on the spot there, but I but I do think,
• 20:35
  Speaker 3: part of it the the way I can say it a little bit more is, like, in the old days, what we used to do is have all our comments development process. But the language team enjoys sequestering themselves away from everyone else, so that's just the way that it is. Yeah.
• 20:54
  Speaker 4: That's how
• 20:54
  Speaker 2: I actually feel about it.
• 20:55
  Speaker 3: And I
• 20:55
  Speaker 2: guess I do I guess I do have some some sympathy for that because it may be that, like, being fully in the open may be distracting in there and especially as you get some some threshold of popularity, like having people jabber at you about some particular feature, disagree with you about some particular feature being ready or not ready, again, may be distracting. So,
• 21:16
  Speaker 3: maybe that's what we're
• 21:17
  Speaker 2: gonna do.
• 21:17
  Speaker 3: That is definitely one good reason to do it that way, for sure. Okay.
• 21:21
  Speaker 1: I mean, you're reading that that discussion is very that is loop thread is like that with the cartoon about React. I mean, did you just tell me to go fuck myself? It's like, I definitely did, Bob. It it it feels like yeah. That's not gonna be very but I can I I I can understand why that's both frustrating, but I can also understand I mean, that's that's not totally nonsensical too?
• 21:40
  I can understand why.
• 21:41
  Speaker 3: So the the the being public, like what Adam said a minute ago, the threat everything being really public is a problem for a lot of people and does lead to burnout. So I'm not necessarily saying that it is universally better. But there's some sort of back and forth balance here, and over time, it has swung in different directions. And, you know, I'm a little less charitable than I used to be. So that's just like the way that it goes.
• 22:07
  But it is actually it is actually a real problem, and I'm not gonna say that I think that GitHub issue threads are the be all end all, like, way to design a thing. It's just like I don't know. I just always think back to, like, the the the advice for remote first work is, like, don't make decisions in chat, make them in writing. And, like, I wonder how many of those threads will disappear someday. Like, the RFC's repo is, like, this rich history of programming language development.
• 22:32
  I've cited the remove the runtime RFC to, like, so many people over the years, and so, you know, I want that stuff to, like, survive, and, it is not clear to me how that happens in a world where all the relevant discussion is on Zulip.
• 22:48
  Speaker 1: Yeah. I mean,
• 22:49
  Speaker 2: that repo is so valuable and
• 22:51
  Speaker 1: so valuable. Yeah.
• 22:52
  Speaker 2: And, and also just, like, has nerve sniped me in so many ways and kind of broken my heart in some ways. Brian, I don't know if you've had this happen where, like, you have fallen in love with some RFC kind of, like, gone gone, you know, 15, 20 threads deep in it only to find find it sort of petered out in, like, you know, 9, 2019, and, like, the people who championed it sort of moved on, or that it's just some, like, ludicrously fucking complex thing, like, like, like, generic associated types or something like that, where you realize, okay, this is actually a ways off.
• 23:30
  Speaker 1: Yeah. The features have broken my heart. That's kind of interesting because I feel that and maybe this is where I'm just, like, a very meat and potatoes rush programmer that the stuff that I get most excited about seems to be the stuff that lands.
• 23:42
  Speaker 2: But you're but you're on nightly and hubris too. So you like But
• 23:44
  Speaker 3: we're we're on nightly only out of necessity. And in fact, I actually have an open PR to literally white list the or allow list the features, specifically, so that we don't add more of them, because we actually don't want to be accumulate we're trying to get unstable as soon as we can. We just can't because there's required stuff for OS development that's not stable yet.
• 24:02
  Speaker 2: Right.
• 24:02
  Speaker 1: So, it it actually seems like this is something I want to say too that that you're because you I think you made a very good point about, it is good that you can't be unstable and use an experimental feature because it it also puts pressure on those people that are using experimental features like us. I mean, Adam, that's part of the reason you're clicking reload and watching the moon landing of of the ASM hit because, like, speaking for Hubris, like, we definitely needed stable as of like we absolutely needed. There's a bunch of stuff that we needed, and that was a big one. I don't know, Steve. What else are we using in in Hubris?
• 24:36
  Speaker 3: The big the big thing that's the big thing that's not immediately being stabilized is naked functions.
• 24:42
  Speaker 1: Right. Makes
• 24:42
  Speaker 3: sense. So there's that.
• 24:43
  Speaker 6: There's there's some PR for that out, actually.
• 24:46
  Speaker 1: It just Oh, sweet.
• 24:48
  Speaker 6: Yeah. But it seems to have stalled, the PR, unfortunately.
• 24:51
  Speaker 1: It's Well, there's my heartbreaker, Adam. You're asking about the heartbreaker. That might be it. Totally.
• 24:56
  Speaker 3: But asm and naked functions were the big ones. We did somebody briefly snuck in, what's the destructuring assignments, but that's been stabilized since. And so, you know, we're technically not, As of my other PR, we won't be having that as an unstable feature soon once I update the tool chain, but that that got snuck in there briefly. There is a, like, CMOS something, whatever feature that's required as part of the LPC55 shenanigans, that, like, has to happen. I remember it was part of Laura's work on the Root of Trust stuff, like, needs a nightly feature that's specific to something that's like deep platform support.
• 25:38
  But that's really it. Naked Functions and Inline ASM were the 2, like, big features that were really necessary. And we're technically still, we're using the 2 of the sub features of inline assembly, asmconst and asm sim. Sim is being stabilized or is being called for stabilization right now. I don't know where const is at, though.
• 26:00
  Yeah.
• 26:01
  Speaker 1: Called for stabilization in a zoo thread that we're not in. But, hopefully, we're on that distant planet, I hope that the, the of elders, if these rules in our favor,
• 26:12
  Speaker 3: I think it'll be good.
• 26:14
  Speaker 1: Adam, would that
• 26:15
  Speaker 3: Oh, sorry. My interrupt.
• 26:18
  Speaker 7: Hi. I I as an interested observer rather than someone with anything enlightened to say, it feels like also there are multiple councils of elders, and I, like, never know quite what to read. And I just wanna emphasize or, like, reinforce that point. Like, I don't want to fish through Zulip chats. Like, I really don't.
• 26:41
  It's not something that I enjoy doing. I don't know what to search for, and, I I'm yeah. I'm totally on board with the idea that actually having this repository of well structured and well thought out
• 27:03
  Speaker 2: No. I'm just kidding.
• 27:04
  Speaker 3: Yeah. No. I think I think another example of how to solve this kind of problem actually is, like, LWN. Like, you can have a reporter. Right?
• 27:13
  Like, I'm not at down at city hall, you know, listening to every single meeting that happens down there, but I do, like, read the news and I find out when there's a new law that's been passed in my city. Right? And so you could also have, like, dedicated, you know, reporters, sort of, kind of. And that's, I think because, you know, the it's not like the Linux kernel mailing list is also hyper accessible to many people either, even though it's a little more public than maybe a chat thread would be. But, like, you know, there's there's other ways, like, essentially, curation to solve these kinds of problems.
• 27:43
  And so, you know, we'll we'll see what happens in the future to, like, kinda change that side of things.
• 27:47
  Speaker 4: You know,
• 27:48
  Speaker 1: so l w totally agree on l w n. L w n is, I mean, is more or less Jonathan Corbett. Yep. Maybe we should just convince Jonathan Corbett, like, you're kinda you hate like, this whole Linux thing is kinda played out. Once you come over to Rust and and because I agree with you.
• 28:02
  Well, so he His reportage is so good on on
• 28:05
  Speaker 3: He is currently hiring someone, and someone with a Rust beat is, like, on the job application, thing. Because because of Rust being in the kernel, he's like, is probably gonna be relevant to us in the future. So it it might also just literally be LWN. But, we'll we'll see how that goes. I I pay for LWN even though I haven't used Linux in years because it's just so good, and you're totally right.
• 28:26
  It's, like, basically, Justin, as far as I know, are, like, a very small team, but it's, like, super, super important.
• 28:33
  Speaker 1: It is really important. It's actually right. Because it's very it's a very good example. It's very good reportage in that he he's excellent at saying, you know, this this person says this thing and then this other person had a different point of view. He he it doesn't seem to inject his own point of view too much in there, which is pretty remarkable because he's often wading into things that are highly contentious.
• 28:54
  Speaker 3: The Linux kernel development community is not known for people not expressing their opinions on this. And so it is a it is a rarity in that crowd. Yes. So totally.
• 29:03
  Speaker 1: But good report is because because, Tim, I obviously agree with you. I mean, Steve might not agree with you about the importance of the RFCs. I did the, but it it is really, really important to and I found as actually a when I first came to Rust in 2018, I was going into the r those RFCs a lot to understand the origin of stuff. And I think, also, in 2018, I would just know if this is still true today. You know, what, at 4 plus years later but it's certainly in 2018, I felt like you were often ending up in the RFCs to understand why things were the way they were or or weren't the way that you you would expect them to be.
• 29:40
  But I don't know. Steve, do you have a sense of how true that is today?
• 29:45
  Speaker 3: I mean, I definitely I definitely think that that's a thing that happens over time because as more of stable Rust is a thing, like, you need less of that context because, like, how you do it is the way it's always been done in stable or whatever. Right? Like like, as a feature is about to land, you really care about the RFC, but 10 years after a feature lands, you're probably not gonna go look at the RFC because it's just, like, a normal thing you use. And so I would expect that, like, as the number of things lands and becomes stable and as time goes on, that it it will be in generally less and less, valuable to people. In terms of what I mean, not to people.
• 30:24
  I mean, like, a working Rust programmer will need to know even less than they used to.
• 30:30
  Speaker 1: Alright. So, Steve, I'm also curious about your perspective on this because I think I mean, we're obviously always victims of our own experience. And I I this is why I feel, like, kinda crotchety about my own Rust experience. I kinda feel like trying to learn Rust pre non lexical lifetimes versus post non lexical lifetimes feels to me like a real watershed feature that completely changed the approachability of the language. But it's hard for me.
• 30:58
  I mean, but it also happened kind of as I was just getting comfortable with the language. So is is that a fair read, or is that is that not accurate, do you think?
• 31:06
  Speaker 3: So this is gonna sound negative, but I promise it's not, actually. I agree with you only because that's, like, what literally everybody else says. I honestly did not need non lexical lifetimes very often, and it's a thing that's puzzled me for a very long time is, like, what is the way that I wrote code different than everybody else where they were running into it constantly? And I was, like, basically, not really. So I do think it's important.
• 31:31
  I do think it's really a big change. I think it mattered to a lot of people, but I didn't have that experience personally very much. You sound like you're an sociopath at a funeral.
• 31:40
  Speaker 1: Like, I understand why everyone else is crying, but it's, like, I I understand that you are feeling sadness, but this is not an emotion that I maybe it's more like Data from Star Trek.
• 31:49
  Speaker 3: Yeah. I get it. This is like well, this is just like there's a couple things like that that have been in Rust where it's like, okay. This definitely is really important to people, but, like, it's just not to me and, like, that's that's fine. That's great.
• 31:57
  I you know? As you said, just because one person needs or doesn't need a feature, doesn't mean it should be added or removed. Right? We're talking about the broader population. I think what's interesting about non lexical lifetimes is to me and I think it's I think it's actually I think it's actually more significant than Rust, actually.
• 32:14
  I think that not unless the lifetimes is actually a significant step forward in understanding how programmers think about their craft. I'm actually willing to galaxy brain it that that far. And the reason the reason is this. The non Lifetime was originally implemented lexically, partially, I think, because it's, like, easier, but partially because it was believed that programmers truly, like, understand the concept of scope. That's like a very core thing to what we do.
• 32:46
  And, like, that the idea of scope in programmers' minds would be lexical scope. And so it was, like, considered really, really important that, like, people be able to grok lifetimes, and therefore, we wanted to match the way that we thought programmers, like, mental models kind of, like, worked. And so that was, like, it's very simple. Like, you introduce a variable here, and then at the end of the curly brace, it's out. And so, like, what could be harder than that?
• 33:08
  Whereas, like, if you're trying to explain non lexical lifetimes in, like, a more formal kind of way, it's like, well, there's a control And so the feature the thing that's, like, technically non lexical lifetimes are far more complicated than lexical lifetimes, But for people, it's actually an easier way to think about it because it matches their mental model of scope more appropriately, which is the last time I stopped using this. It should just be done with or whatever. And so I think that that's like a an insight in the programmer's psychology that's, like, relatively rare that you get those kinds of developments. But, but, yeah, I think it, like, is very interesting for that reason alone.
• 33:52
  Speaker 1: Yeah. Okay. That is interesting. I I mean, it felt honestly when and I I think it's interesting that you did not get inflicted by this as much. And it may have been that I was coming from C, and was making a lot of the mistakes that I think c programmers make where you're just used to having, like,
• 34:07
  Speaker 4: oh, I
• 34:07
  Speaker 1: need to have, like, a back pointer here. It's like rush is like, no. No. Please don't. And so it may have been that.
• 34:14
  It was really, really frustrating when you had Rust is very upset with you. And because the you you can't do this because the the this variable was still, it this thing. And it felt less like it felt like I was having to to generate spurious scopes that shouldn't be required in order to force lexical lifetimes. Totally. And but yeah.
• 34:45
  But maybe that that's that's interesting. That maybe
• 34:47
  Speaker 3: I mean, I also write a very, like, nuts and bolts, nothing fancy style of Rust in many circumstances, largely because, you know, a lot of my history is not only writing my own programs. But when I'm trying to teach beginners, you know, I've iterated on the basic syntax like a zillion times. And so I probably just also, you know, you were like immediately getting into stuff that's like relatively, you know, not complicated in the sense of, like, the most complicated thing ever. But, like, I'm often teaching beginners, and therefore, I'm not using fancy stuff or, like, my examples are a little more contrived. And so I probably just ran up into it a lot less because you were, like, getting useful, active work done in, like, relatively complex scenarios right away.
• 35:28
  So I think that probably has something to do with it too.
• 35:31
  Speaker 1: Yeah. I mean and and I think that, like, that I'm trying to think about other features that were are there other Rust features that were like that that were where the a either a the state of Rust kinda gave us insight into program or psychology and or the way people want to think about the problem.
• 35:49
  Speaker 7: I thought I oh, sorry. Go ahead. So just to kind of pick up Steve's galaxy brain kind of thought, the, one thing that I really liked about non lexical lifetimes was that the Rust the community decided that actually programmers were the important thing here. And actually, we can bend the language to adjust to how people's mental model actually is, which demonstrates, I think, a lot of humility because there's an engineering challenge to kind of refactor something so core, like lifetimes, to Rust. I guess another aspect of that would be kind of a real emphasis on high quality error messages would be sort of similar.
• 36:33
  Like, compare if you compare the error messages from, say, 2018 to now, I think most people bumping into things are gonna have a better time today than they did a few years ago.
• 36:43
  Speaker 1: Absolutely. I agree with that.
• 36:45
  Speaker 3: Yeah. That's actually a similar I was actually that butts right into what I was gonna say as another example of a feature. It's like this sort of kinda is the debate over the syntax for async await was largely talked about and in ways of, like, how are people going to understand this? And one of the things that sort of helped get it over the line was, like, no. We're gonna parse the JavaScript syntax for async await and recommend our new weird syntax for async await, and that will help solve that problem for when people's mental model of how it should be is, like, the bet the other one from a different language.
• 37:18
  And so you solve that problem via a good error message and caring about error messages because you're trying to focus on the programmer and the way to think about stuff.
• 37:25
  Speaker 2: Yeah. I think that's a great example, Steve, because I think that the amount of work that I'm sure went into turning that into a coherent error message was was non trivial. And then beyond, like, the some of the technical implementation, the thing that I mean, we haven't really talked about the Rust community, but that's that's the other thing I love about Rust so much. And, so I wrote a blog post about my first use of Rust, you know, like, like 6 years ago or something. And I didn't even look back until, you know, when when Steve started Steve, you you joined DocuSign about, like, 2 years ago now?
• 37:59
  Speaker 3: Little little over 2. Yeah.
• 38:01
  Speaker 2: Jeez. It's nuts.
• 38:02
  Speaker 3: No. Right.
• 38:02
  Speaker 4: And I
• 38:03
  Speaker 2: think it's, like, shortly after Steve started, I for whatever reason, I went back to this Hacker News thread. And Steve's, like, comment was number 1 being like, hey. I'm, like, sorry this was tricky. Like, what what would have been more helpful? Of course, I didn't see it until it was much too late to be useful in that regard.
• 38:18
  But, like, I thought that was an amazing example of just, like, how much Steve in particular, but the Rust community cared about making this thing, like, good and useful and intuitive and and overcoming obstacles to understanding.
• 38:32
  Speaker 1: Yeah. And so and this is in 2015, Adam, that you did your first and and actually, Steve, it was funny because I Adam was the first person I knew who really went into Rust who was like, I would use, like, you know, one of my peers and someone who's gonna have a a pragmatic approach. And I remember reading that blog and she'd be like, man, thank god Adam did this. So now I'd never have to touch this language ever in my life because this is so clearly a horrific experience. And then Adam's blog entry is like, and in conclusion, I look forward to using Rust again.
• 39:02
  I'm like, Adam, what are you getting? Read your own blog entry. It's like, what
• 39:07
  Speaker 4: you're in a bad relationship with
• 39:08
  Speaker 3: us, buddy.
• 39:09
  Speaker 2: Such a weird experience, but, because I you know, at the time, I, so I was writing, at the time I was asking a screening question. I've, I've, as people who, I've worked with or have interviewed with me know, I basically have like 2 questions I've been asking for like the last 15 years. And one of them is a screening question that just to cut that we would ask at a couple of different companies. Just like write a anagrammer and do whatever do it in whatever language you wanted. And we had some interns who, like, like, well, I I'm gonna write it Rust.
• 39:40
  I was like, okay, don't don't show me, but I'm gonna go try this. And I went and tried it, and it was it was kind of brutal. And it was brutal. And I think in the ways that, like, dummies go to learn Rust, which is just to be like, okay, I know how to program. Like, don't tell me, like, I don't need to wait for the translation.
• 39:56
  I'll just, like, write this code. Like, what's the syntax? Like, it's probably like something else I know. And
• 40:03
  Speaker 1: it's Can I just get something out of my head right now that it's just driving me crazy? Earlier today, you replied to a tweet of someone who's like, when do you see something that automatically you take out the Simpsons? And that is now in my brain, and it's like so, like, literally, as you're speaking this, like, the image that comes to mind is I would Bob's stepping on rings.
• 40:25
  Speaker 4: No. That's that's exactly
• 40:26
  Speaker 2: what it was. That was exactly what it was. But I think as I had time to sort of think about what I had done, you know, and and sort of, like, done the thing that I should have done when I started writing the program, which was to appreciate the differences of the language. I I realized that the unique concepts of ownership and of lifetimes and and these kinds of things that I had never seen in a language. And if I had paused before writing to try to understand, you know, like, if you read Steve's book, like, he takes pains to, like, explain to you, if you just skim past those things.
• 41:00
  That that's what caught my eye, that it was like, this was a new thing. This wasn't like a language I had used before.
• 41:06
  Speaker 1: Yeah. And I think that actually the you know, I love you got a couple of great lines in there, where I you have you you describe, moving from anger into bargaining.
• 41:16
  Speaker 4: I mean, any I don't
• 41:18
  Speaker 2: know if people still maybe I mean, I know
• 41:20
  Speaker 1: the trust has
• 41:21
  Speaker 2: gotten so much better.
• 41:22
  Speaker 1: It's gotten so much better, but
• 41:23
  Speaker 6: oh god.
• 41:24
  Speaker 2: Brian, have you written any asynchrust?
• 41:27
  Speaker 1: Yes and yes. Okay. Yes. And I know exactly where you're going. Get the that's like I'm just screaming down the the street.
• 41:32
  Speaker 2: So so there there is definitely, like, stages of grief. But there's also, like, do you ever have the compiler is like, hey, this will all work if you use the static lifeline.
• 41:43
  Speaker 4: Totally. Oh, totally.
• 41:44
  Speaker 2: Like, what have I done that, like, this will only work if you can promise me that nothing will change for eternity. It's like, okay. Well, I can't promise that. Okay. Fine.
• 41:53
  Like, I've I've messed up more fundamentally.
• 41:56
  Speaker 4: Just commit. Why why
• 41:58
  Speaker 3: can't you just commit?
• 41:59
  Speaker 4: Why can't I just marry all
• 42:00
  Speaker 2: my data structures if I love them so much?
• 42:03
  Speaker 4: Yes. Adam, what I thought you
• 42:06
  Speaker 1: were gonna say is, like, when the compiler is like, actually, this will work, but you need to change that to be mutable. You're like, okay. In case that's mutable, the compiler is, like, what
• 42:14
  Speaker 4: the hell are you doing, you dumbass? Now nothing works. And he's, like, okay. I was, like, I'm sorry. I'm sorry.
• 42:21
  You do you do have the
• 42:23
  Speaker 2: I mean, still at these moments. And I remember, even at the time, like, the Rust compiler being, like, try this. And it's like, who told you to do that?
• 42:30
  Speaker 4: Yeah. Like, what? Why did you think that was gonna be worked stupid? It's like No. That's Like, why are you hitting yourself?
• 42:38
  Speaker 1: Right.
• 42:39
  Speaker 4: And it's actually it's like and
• 42:41
  Speaker 1: then it's, like, so earnest and helpful about the way it's telling you that you, like, lost your mind that you're just, like, in in some ways, it's even, like in some ways, it actually be, like, a little bit easier if it were just, like, look. You're being a dumbass. Like, you just do not I look. I'm sorry. This is the 4th time you tried to do this.
• 42:55
  I don't think you understand how this program works at all. Like, I'm just gonna,
• 42:58
  Speaker 2: like, I'm letting you know. But but there's nothing like async to help me, like, expose my ignorance and also to, like, vomit out some, like, error message that I need to, like, full screen my terminal in order to even, like, have a hope of understanding what's going on.
• 43:15
  Speaker 1: What was Dave's mess error message early? Do you remember the one that he had that was that was, like, 1300 lines long? It just but did he get an error message that was just, like, it'd be yeah. The it is absolutely monstrous, the kinds of things. And that has all gotten better, but it is still I think it highlights that I mean, you do and actually, I I I really appreciated the, the, the programming Rust book is and, Steve, I know you're emphatic about this too, in the Rust programming language.
• 43:44
  But just like the need for early programmers to change your mental model, Do not if you walk in a rust with your existing mental model, it's gonna hurt. Like, and if you just try to get a doubly linked list working, it's not gonna end well. You're gonna be in some in the wrong parts of the language, basically. In the in the super
• 44:02
  Speaker 4: go ahead. No. No. You go ahead.
• 44:05
  Speaker 3: In in the super old days, it was really common for c or c plus plus people to join IRC and be like, hey, I'm trying to write this program that's, like, clearly fine, but the compiler won't let it work. What do I have to do to get the compiler to shut up? You have to be like, well, what would happen if that got moved to another thread? And they'd be like, oh. Like, yeah.
• 44:25
  That's what the compiler is telling you is that you were actually, like, about to do something that does not actually work. Just because you thought it worked doesn't mean it actually works. And there was a really big predictive power, like, basically, the the way you know, it's like, it's like very sort of like stoicism kinda thing. Right? Like you can either try to change the world or you can change the way that you think about what's coming in.
• 44:47
  And so like, we'd see people be successful if their reaction to that was, oh, neat, versus like, well, I know better. There's no thread there. There's never gonna be a thread there. Can I doubt I'd get the compiler to shut up? And it's like, okay, like, you're talking to have a good time actually.
• 45:02
  Speaker 2: Totally. When when Rusty is, like, asking you questions about your program, it's not bad questions. Right? These are the questions that nobody was asking me about my programs before, and it sort of either worked by accident or it didn't. Yeah.
• 45:14
  Speaker 3: You know And and the trick is to make sure it's right often enough that you trust it. Because if it's not right often enough, then, you know, like like the thing with the the lifetimes that Brian was talking about earlier, then you become frustrated because you do know better than the compiler. And, like, the more that you can get, the the better the compiler is at actually being correct in those situations, the more you're able to trust it and therefore, the more you're able to, like, offload your mental capacity to it. But if it doesn't work, then, like, you know, that then you're it's a problem.
• 45:41
  Speaker 6: Look. That learning curve can be near vertical, though, and and it can be serious gut punch to the ego to have to absorb what the Rust compiler is telling you. And I've seen this multiple places now. In my last project at Google, when I convinced, you know, folks early on to switch from c plus plus to Rust, you know, we found ourselves writing, trying to write c and Rust and then being very frustrated for 2 or 3 or however many weeks. Until we kinda remember, like, okay, we need, like, a of this and that's just, like, I can no longer wrap my identity around being a c programmer, and, like, that's gotta be okay.
• 46:15
  And once we kinda did that, then we were alright. But, yeah, we had the we had the issue where people were like, this code is perfectly defined. How dare the compiler argue with me? And the
• 46:24
  Speaker 3: flip side of that is
• 46:25
  Speaker 6: that I've seen extremely experienced UNIX people turn around and say, I don't understand why this language exists. It doesn't do anything that c doesn't do, and it forces you to sprinkle unsafe and mud all over the place. And it's like, well, that's you're you're you're thinking about
• 46:39
  Speaker 1: it wrong.
• 46:40
  Speaker 6: It it actually is very frustrating.
• 46:43
  Speaker 1: Yeah. Well, there's actually a pretty good hacker news thread that I think that Adam, you'd seen over the weekend. Right? The the, on learning Rust. I think the and I think as and I see that it's been interesting to you for you to kinda watch, like, the broader programming community change its disposition really towards Rust?
• 47:01
  Because it feels like now there is a much more I think people are are are much more embracing of the mental model shift than they were 2, 3, 4, 5 years ago. Is that a is that a fair read?
• 47:11
  Speaker 3: I think that's true. I think it it also, like, People You know, you kind of go through Like, crossing the chasm is always, like, at the forefront of my mind. That whole thing is, like, really essential to the way I view a lot of things. And so I think that it's it's not even so much that people are more amenable, it's just that, like, now that the value has been demonstrated and now that, like, you can get a job and now that there's, like, projects that you care about, that you wanna contribute to, or Rust exists, more people are willing to put in the effort to learn something new because they know what they're gonna get in return. You know, like, in the old days, you basically were getting, like, hope.
• 47:49
  You know, maybe someday I'll I'll be able to a job in this language, and therefore, I'm gonna learn it because I like it. For other abstract reasons, I have some sort of other motivation. And I think now we're getting to the point where there's a much more, like, meat and potatoes reasons to, like, learn the language that's not, you know, I'm a programming language theory nerd and this affine type system is cool or whatever. And so I think that's also part of it too. It's like not even necessarily sentiment changing, it's just that, like, there's it is it is more clear that the cost benefit is maybe worth it, and therefore, people are more willing to even entertain it in the first place.
• 48:23
  And could you elaborate on what you mean by crossing the chasm? There's a there's a book. There's a business book called Crossing the Chasm, and it's about how, like, how disruptive technologies achieve like succeed in the market or whatever, something vaguely along those lines. And there's this diagram that's basically like a bell curve except for at the first quartile, there's like a there's like a gap. And so it's basically like, and each of those cohorts uses the technology for different reasons, and they start using the technology at a different place in its life.
• 48:58
  So the leftmost are, like, the extreme innovators or something. I don't remember. This is a business book, so it's full of silly jargon. But, like, those are the people that, like, use a thing just for the sake of using it because they enjoy using it, and they'll, like, always try new things because the fact that it's new is a good enough justification on its own. And the far other side is like the late the late majority or the laggards, I think is the term they actually use.
• 49:21
  And those are folks who like, you know, that Java thing is probably used enough that I'll start using it now. Like the, you know, like, a a COBOL programmer that's still writing COBOL today that's like getting around to trying those newfangled things that have been successful for 10 or 20 years because they just, you know, are much more conservative with their technology choices. And the trick is that a lot of things die before they can like cross the chasm, they can jump over that gap between the, like, people who are interested in a thing early because they see the potential and the people who, like, just wanna get their job done for the day and don't really care. And it's like, how do you how do you get your thing, or the trick is to get your thing from that early audience to that, like, bigger, more normal audience. And once you've done that, you're successful and you're gonna exist forever.
• 50:09
  But, like, lots of technologies sort of die trying to get to that kind of, like, you know, larger group of people. It's much more if you look at the diagram, it's, like, very visual, so it's, like, kinda easier to see how this works out. But I hope that verbal No. That's that's
• 50:24
  Speaker 1: a great description. Of course, it it natural follow-up question. When did Rust cross the chasm?
• 50:30
  Speaker 3: Yeah. Well, see, that's, like, kind of an interesting thing because you you don't one of the tricks is, like, you don't really necessarily know until like a lot later. And so I think a lot of people would, like, cite like, Russ
• 50:47
  Speaker 1: like I've got my answer to the answer to this question. So I'm I'm breaking history of your answer.
• 50:51
  Speaker 3: My answer to this question is actually the MVP of async await dropping.
• 50:56
  Speaker 1: Okay.
• 50:57
  Speaker 3: And that is because while everybody not I shouldn't say everybody. While there are a lot of criticisms of async and, like, there's still a lot of work to do there and, like, all this other stuff, If you look at the actual numbers of people reporting on the survey, like, what they use Rust for and what they use Rust for at work, it is network services. And it doesn't matter how many people on Hacker News say that you shouldn't write network services in an unmanaged language because it's the wrong tool for the job. A lot of people actually do think it's the right tool for the job, and asyncawaitlanding was a significant step forward in getting people to be able to write those things, and it honestly is still one of the biggest user groups of Rust just purely by the numbers, and I don't think it feels that way or it's reflected in the social side of things as much. But that's, like, the the actual situation is that that's what Rust is being used for in many, many, many cases.
• 51:45
  So I think that was the the real point at which it became more useful to a lot of those folks, is because everything touches the network now, basically. He says when his day job is writing firmware, the device is not
• 51:56
  Speaker 4: gonna exist. Well,
• 51:59
  Speaker 5: for what it's worth, that was actually the point for me as well. And and, you know, I'm trying to not turn this into an advertisement for what we do, but, we use Tokyo and Axum and Tokyo console and postgres stack data persistence, and we could not have built what we were building without Rust. And without the compile times, without the lifetimes, without the compile time reliability. It actually was a thing where a lot of us were formerly go programmers and Rubyist, and we kind of said we could not have built this without this. And and, like, I am trying to, like, put a positive spin because I do agree with you, Steve.
• 52:36
  There's definitely, like, some work to do, and the ergonomics aren't that great. Like, for instance, right now, we bumped everything out to factory, which is kinda like sidekick for those of you who've used it. And, we're we're sort of spawning off jobs when the threads get too big. Otherwise, debug mode, some of our async threads will kind of explode. And and, like, and, like,
• 52:57
  Speaker 6: we've seen it in Tokyo console.
• 52:58
  Speaker 5: We'd like, you know, sort of watch them kinda, like, balloon a little. But But at the same time, it's those kind of moments we're like, oh, well, maybe that's been a go routine, but all the other benefits and everything else that come along with it has certainly been like a, we could not have done XYZ thing without that. So the MVP was definitely there because, you know, a lot of us were kinda, like, silently in the back waiting. We're like, okay. We see the embedded use cases.
• 53:27
  We see the c and c plus plus replacement scenarios, but we're kinda sorta like, you know, when can I use this, like, my everyday, like, back end or full stack job? And and and I would have said that that, at least from my channels, was certainly where I saw heightened chatter.
• 53:42
  Speaker 1: It's like, Steve, are you playing a 19 forties radio sound effects reel? No. I,
• 53:48
  Speaker 4: I That's why I'm, like, waiting for the door to open and close, the footsteps, the tree.
• 53:54
  Speaker 3: I I have I, I make I make tea in mason jars and put it in my fridge. And so I had I'd set that up right before this happened, and so I was just putting the can the lids on and putting it in my refrigerator, and I didn't realize you could hear that. So my bad. But
• 54:08
  Speaker 4: No. No. No. No. No.
• 54:09
  Speaker 1: It was like but it was like crystal queer sound effects.
• 54:11
  Speaker 4: It was actually
• 54:12
  Speaker 5: so sorry, miss. I do it.
• 54:13
  Speaker 4: I I No. No.
• 54:14
  Speaker 5: No. You're fine. I I I mean, I make chemexes in the morning, and everyone's always like, why is Nick's video off? And then I'll have to, like, put in chat. Like, I'm, like, making a pour over, and it's gonna taste terrible, but I'm gonna go like it anyway.
• 54:24
  So I I
• 54:25
  Speaker 2: it's probably been there. Yep.
• 54:27
  Speaker 1: So that's interesting. But, Nick, you've got the same feeling as Steve. And, Adam, I think you I wonder if you have that same thought because, I mean, coming into Oxide, you're definitely like, look. I can see Rust for these kinda lower like, low down the stack. That makes tons of sense.
• 54:41
  Higher the stack, I think it might make less sense, but that's since since it's kind of.
• 54:46
  Speaker 2: No. Totally. So so when I joined so I I I, you know, I wrote my first Rust in 2015. I had dates right wrong, but then I I didn't really do anything with it again. Like, when I when I started my last company in in, in whatever it was, like, 20 2016.
• 55:04
  I know it's it's
• 55:05
  Speaker 4: 13 Dickany too?
• 55:06
  Speaker 6: Yeah. Exactly. It's moving quicker than
• 55:07
  Speaker 2: I thought. The the choices were sort of like Go and Java. And then, I'll say without embarrassment, we we chose Java, but it, like, those felt like the right answers for the kinds of problems that we were solving. And
• 55:20
  Speaker 1: Is now when we can talk about your love affair with Antler?
• 55:24
  Speaker 2: Oh, I I do love Antler. Antler is wonder I'm happy that we could have we could have a whole week long of shows on Antler. I'd be happy to do that. No. I think Antler is really cool.
• 55:32
  Speaker 1: Antler is really it seems really cool.
• 55:34
  Speaker 2: So, but but, you know, I I like rust. I like I like rust the first time I tried it, and I was fired up coming into Oxide. I was, you know, reading books on and stuff like that. But I did come in, and in week 1, I I was like, well, you know, why are we, like, for, say, the web layer or whatever, maybe it makes sense to to use something like Java or maybe it makes sense to use another language. But I would say that it it didn't take that long to feel like the the perceived obstacles associated with rust were far outweighed by all the obvious benefits.
• 56:08
  And that just, you know, you can trick yourself into saying, like, well, you know, I'm I'm using these these tinker toys with with Java and I can't get myself into these kinds of problems, but you clearly can. And you're bringing on a whole host of other problems with with a garbage collected. So, you know, I, I think that I'm, I'm no longer claimed to be unbiased. I'm hugely biased in favor of Rust. Like I, I, and maybe this is a good time as any, but like, I didn't, you know, people talked about loving programming languages.
• 56:41
  Like, I I worked with someone who loved Java, and I didn't think I was capable of loving a language. Like, I didn't think that was a thing that I had
• 56:49
  Speaker 4: in me. Me. And and now I am like This heart grew
• 56:52
  Speaker 3: 3 sizes larger that day. That's right. That's right.
• 56:56
  Speaker 4: But, like, you know, I just thought
• 56:57
  Speaker 2: it was, like, no. No. You just pick the right tool for the right job and, like, love has like, I don't know. Like like, sometimes Python is the right answer, I guess, or Java or or even Bash. Although, I hope our colleague, Dave Pacheco doesn't hear me say this because he has told me that bash is never the right answer for anything unless you're trying to signal to people that you don't take a problem seriously.
• 57:16
  Speaker 1: That is correct.
• 57:16
  Speaker 2: Yes. Okay. Well, fair enough. But, you know, I still use Bash because sometimes
• 57:19
  Speaker 1: I used Bash this morning. Yeah. I got a gnarly Bash, got the nail right now.
• 57:23
  Speaker 2: I I gotta say, like, a a lot of things are are looking like a rust shaped nail for me now. Like, I I think that I I'd use it in a lot of different contexts, that that a couple of years ago or two and a half years ago didn't necessarily seem appropriate. But in terms of, like, the the crossing the chasm, I think it I don't this is not gonna be as as pinned down in terms of a timeline. And Brian, I've I've been curious to your answer, but I felt like, you know, in that sort of early 2020 timeframe, I went from thinking, you know, a couple people are using this or or it's even used here and there for sort of the inner loop of whatever to to looking up and seeing that anyone who is doing serious systems programming was kicking the tires on rust or or using it in a very serious fashion. And that dam sort of broke.
• 58:14
  It feels like right around that time. Now I know that I'm biased and I've sort of like, now getting into Rust, but it feels more and more, like, around that time frame was when the the folks doing these kinds of systems problems really kinda jumped
• 58:26
  Speaker 1: in. Well, and that and that would dovetail with Steve's async await timing, honestly. So that would be, that's that's interesting. And so
• 58:32
  Speaker 3: it it doesn't have to be a feature. Right? Like, we're talking about basically, like, timelines of different populations of groups. And so, like, I I'm just saying that I think that's, like, around when it was, but I definitely think 2018 was, like, a bike shed year or a watershed year. Some sort of shed.
• 58:46
  Speaker 4: Quite. Was it was it bike shedding when you talk about which kind of shed it is? Is that
• 58:52
  Speaker 3: the That's right.
• 58:53
  Speaker 1: That's right. But, like,
• 58:54
  Speaker 2: yeah our bike shed moment. No. Yeah.
• 58:56
  Speaker 3: I feel like around 2018 Yeah. For whatever reason was, like, when stuff, like, really cemented itself and started taking off even more than it was previously.
• 59:06
  Speaker 1: You you know, I got on the Internet moments before the internal September of 1993. I got on the Internet in the fall of 1992. So the fact that I got in the rush in 2018, right before crossing the chasm, I think that that's, I'll take that.
• 59:17
  Speaker 3: Yeah. I I also the last thing I would say about crossing the chasm, I think it's really important that programmers understand where they fall on that on that line, and that can change for different things too because, like, you know, I was a super, super early adopter of Rust, but, like, there's like, I don't think I've like ever written a Dockerfile, for example. It's like, I'm like an extreme laggard on Docker, but I'm like super early in Rust and I felt much better about, like, various technologies when I understood how I felt about how early of an adopter I wanted to be and recognizing that other people are in a different stage in that area. And, like, a lot of a lot of arguments happen between people who, like, have an early adopter mindset versus, like, majority mindset, and then they talk past each other because they don't realize they're both getting out of or not getting out of the situation what they wanted just because they're coming from a different place in the first place. So I think it's also helped me deal with a lot of, like, arguing online about stuff, by, like, knowing that that thinking about the mental framework and figuring out where I fit into it for whatever technology we're talking about.
• 1:00:24
  Speaker 1: Yeah. That's interesting. And I also think that I mean, you're making an important point too that it that where you are in that curve may be more of a function of the problem you're solving and less a function of you as a technologist. That as a technologist, you may be an early adopter in one regard and then actually a late adopter in another regard, and that doesn't make you a dullard or a waggard or or, you know, what have you. But that that it it the and being kinda self aware of that is is is important.
• 1:00:50
  Luke, I wanna get you in here because you've been in the Rust community for a really long time. And I like, did you have a sense of when the when the chasm was crossed? To the degree that I think I think we have crossed the chasm, I would assume.
• 1:01:05
  Speaker 8: Sure. I mean, I feel like a lot of my time has been spent lurking. Like early on I did like do a lot more like when I interned there and other stuff. But then after that kind of went away, you know, doing work stuff, life stuff, but kind of just keeping an eye on it in the background, like, just playing around with it myself. But I yeah.
• 1:01:28
  I do think around 2018, right when async the MP MVP was starting to land was like, I think this could actually be a thing that I could convince someone at work that I could use. I actually remember writing, like, right before that release was cut, like, some little project with, like, Async, Tokyo, and all that stuff and then showing my address at the time. It's like, look at this. It was like, you know, I did this in, like, you know, a week and it does so much better than what we are already have kind of thing.
• 1:02:00
  Speaker 1: Okay. That's interesting, Ludwig. So that that is an interesting kind of acid test when you can go to a new technology and kind of catch up to where the exit technology is in a remarkably quick period of time. I do think that's a kind of a hallmark to when something is becoming really real. Yeah.
• 1:02:19
  And so for me because I actually like, the thing that really drew my attention to Russ after I made it was like so Adam's terrific experience, like, never touching that. And but then the when honestly, Steve, and I don't know if it would would have been like maybe 2016, 2017. When was the green threads removed? 2014. 2014.
• 1:02:38
  So it's before? Out of interest.
• 1:02:40
  Speaker 3: It was before 1.0. Yeah. Because that to
• 1:02:43
  Speaker 1: me, I thought that's a super interesting decision. I did because it felt very pragmatic and, I mean, very much aligned with my own experience and wisdom. But it felt and I'm sure that that was controversial at the time. Was that controversial at the time?
• 1:02:59
  Speaker 3: Yes and no. It it it definitely,
• 1:03:05
  Speaker 1: I think it depended on
• 1:03:06
  Speaker 8: who you were talking to. Some
• 1:03:07
  Speaker 1: people are all for it.
• 1:03:10
  Speaker 3: It it was also largely spearheaded by someone who was often the source of controversy. And so I think, also, some people were colored by nontechnical factors when talking about that at the time, if I remember correctly. Sorry, Luke, when you were saying something and I said something.
• 1:03:29
  Speaker 8: Oh, no. Yeah. I just I just remember thinking depending on who you asked, like, maybe some of the more people familiar with node kind of stuff were like, yeah, I know. Segmented stacks, green threads, that's great. Versus like people who wanted to, you know, run it on the PS 3 or what have you.
• 1:03:46
  Or just like, we want libnative basically. And then the difficulty is like, well, how do you deal with like segmented stacks when you have like, you know, inline assembly and other other parts of the language that make it really difficult?
• 1:04:00
  Speaker 3: Yeah. Every language that's used segmented stacks is eventually removed them at some point. It's Amen. My understanding, basically. Yes.
• 1:04:07
  Let alone you know, obviously, a lot of people still do green stuff green thread stuff, but I think segment and stacks is definitely, an idea whose time has gone, for sure. It it it's just it's the details.
• 1:04:21
  Speaker 1: So the reason that it kinda turned my head, I was like, I guess I found out about I've I've I've got the chronology wrong here. But the reason that it turned my head is because it does reflect people really trying to use the system. And I think that things will kinda happily use green threads when they are actually not really getting into the mechanics of getting something that is gonna run for a long period of time and run robustly. But when you are like, there are so many edge conditions. It feels like it's such a good idea, and it's such a long tail of disasters that are really, really hard to mitigate, that it it it that to me was like, okay.
• 1:04:55
  Wow. This is actually, getting real and is is gonna be these are real systems. I came into Rust, for whatever it's worth, in the in I I've been meaning to look into it for maybe 6 months, 12 months by the time I got into it. The although one of my coworkers, Adam, Levinthal's me gloriously by maintaining that I I I that I was deriding Russ to him in 2013 or 2014. That's my way wherever you are.
• 1:05:21
  Exactly. I so he I I he had cackled uproariously when I fell in love Russ because he felt that it was a grand comeuppance, and maybe he was. But the I felt like I was looking into Russ out of somewhat out of desperation, honestly, because I felt like the I just couldn't find a home for myself. And I'm like, if it's not gonna be if this is, like, my last best hope. You're talking about, like like, coming to Rust at a hope, Steve.
• 1:05:47
  Yeah. And, actually, I think since then, the the the the the environment has actually improved. I think that there are other languages. I actually think this is in part due to success of Rust, is that Rust has shown that there's a space there, and other languages like Zig are starting to be in that space, and I think that that's actually really healthy. I think that that's a good thing.
• 1:06:07
  I'm not sure your your take on that, but I I liked having having more languages experiment with different ideas. I think
• 1:06:15
  Speaker 6: it's good.
• 1:06:15
  Speaker 2: One thing I very good.
• 1:06:17
  Speaker 1: I one thing I I also wanted to get to, in addition to kind of pulling people across the chasm, I wanted to just because I know I'm gonna learn something. I wanted to hear people's, like, small features that have been added over the last couple of years that are really meaningful to their quality of life. And I've got a handful of these, but I'm I imagine other people have got got ones that I have not heard of or I have missed. The I I I mean, we we talked about inline ASM. Do you use const generics, Adam?
• 1:06:51
  Is that something that
• 1:06:52
  Speaker 2: Yes. I do. In in a way that, like, is totally different than you guys. Like, I I remember in in Hubris, you guys being very fired up for that. And I got fired up for it in like a really dumb way for a, like an open API, SDK generator that I've built.
• 1:07:14
  And this, like, this is such a weird use of Rust or like such a, I don't know. When people think about Rust, it's not for, like, calling, like, dumbass REST APIs or whatever, but, like, JSON schema. Okay. I'm losing everyone, like, by the second, lets you say define an integer that is like a multiple of 7 or fucking whatever. So I I use the comp generic to define that.
• 1:07:40
  Speaker 4: Oh, nice. I didn't realize that.
• 1:07:42
  Speaker 1: I didn't realize that story was gonna end so quickly.
• 1:07:44
  Speaker 2: Yeah. I thought you were like, you're like, oh, geez. This sub story is gonna go on and on. No. It's just like, unless you define a type that's like, here's a number that has some weird properties.
• 1:07:53
  Like it needs to be between 12 and a 1000 and a multiple of 7 and cost generics are a way that like, I don't have to kind of do a bespoke type for each one, or it can be structural in the type rather than, you know, just like an input parameter or something like that.
• 1:08:09
  Speaker 1: Oh, that's very cool. And that's in for generator?
• 1:08:11
  Speaker 2: That's right.
• 1:08:12
  Speaker 1: Oh, that's what I need. Oh, cool. Okay. Yeah. So you'd alright.
• 1:08:14
  Well, that answer that question.
• 1:08:15
  Speaker 4: You
• 1:08:15
  Speaker 1: definitely do. What what what are some other little ones that you are there other
• 1:08:19
  Speaker 2: I have another one that, like, only I give a shit about, which was, like, I write I I I'm not sure how to write Rust, is the first way I'm gonna say this, which is I think different people write Rust differently. Like, I you know, I've looked in and it's oxide is such a great case, and most of our repos are open, but you can find a bunch of Rust code that looks like C code. And, certainly, like, if you're in my neck of the woods, not that I'd recommend it, you can have Rust code that feels more like Go or Java or something like that. And you can have lots of folks who want to use a for loop for everything, and you can folks who wanna use a, like, for each on an iterator for everything. Is this an intervention?
• 1:09:05
  I which one are you? You know which
• 1:09:07
  Speaker 4: one I okay. I've been
• 1:09:08
  Speaker 1: trying to get better. I've been trying to be more, like I'm trying to get more mappy, foldy, but I, you know,
• 1:09:14
  Speaker 2: I No. No. I'm what I'm saying is I'm way too mappy foldy to the point where
• 1:09:19
  Speaker 1: This is an intervention. This is an intervention. Look. I'll I'll change. I can get better.
• 1:09:22
  I will use more I I will stop using for loops.
• 1:09:24
  Speaker 2: So No. So no. No. So, like, I I'm to the point where seriously, if I have to name a variable, I think I fucked up. Or if I have to have something be mutable, I feel embarrassed.
• 1:09:35
  Although, like
• 1:09:35
  Speaker 3: used into iterator on option?
• 1:09:38
  Speaker 2: Yes. So that's exactly what I'm so that's what I'm go so not only if I use
• 1:09:41
  Speaker 1: iterator on
• 1:09:42
  Speaker 2: option, Steve, but I am using the bull has a, then.
• 1:09:48
  Speaker 3: Then? Yeah.
• 1:09:49
  Speaker 1: Yeah. Uh-huh.
• 1:09:50
  Speaker 2: I've been I've been using a bunch of bull then so that I can launch myself from the pedestrian world of of of, like, integral types into the lofty world of things I can I can, try with a capital t or iterate over or or or reduce? I'm saying this is a cry for help, not an intervention, Brian.
• 1:10:12
  Speaker 1: No. I feel like because I I I'm just not I feel that I myself, I try I'm trying to be more Mavi folding. And the and Clippy is trying to help me for whatever it's worth. Clippy is Clippy is like, you moron. This should not be a form of like
• 1:10:25
  Speaker 2: Do you ever Klippy recommend something? And you're like, okay. Fine, Klippy. Let's do it your way. And then the compiler's like, this
• 1:10:32
  Speaker 3: is terrible. Like, this
• 1:10:34
  Speaker 2: this is garbage. Come on.
• 1:10:36
  Speaker 4: Mom and dad are fighting. Exactly. Don't tell me that Clippy told you to do this. I mean, if Clippy told
• 1:10:42
  Speaker 1: you to jump off a bridge, would you do it? Of course not.
• 1:10:44
  Speaker 3: Yes. I would.
• 1:10:45
  Speaker 1: Actually, I probably would. Actually, I would go to Steve, and I would say, hey, Clippy is starting to jump off a bridge. That doesn't sound right. Could someone, please? No.
• 1:10:51
  You really should be jumping off a bridge.
• 1:10:52
  Speaker 3: Okay. Fine. Jump off a bridge.
• 1:10:55
  Speaker 1: I think I think
• 1:10:55
  Speaker 9: it actually touches on something interesting that has been sort of a a detraction I've had for Rust. I just wanna start off off the bat. I'm a huge fan of Rust. I wish you nothing but success. But I think when Adam said that there's a lot of different ways to write Rust, I think that's totally true in terms of what you end up with.
• 1:11:15
  But as a practice, I think one of the reasons that it's hard for Rust or was hard for Rust to jump over that chasm is because it kind of shifts the line about what a programming language is because I don't know anybody who understands how to write Rust without Rust analyzer in Clippy. There's a sort of Esperantoism of Rust where it's not really the language that anybody writes sort of unassisted or it's not their their sort of, like, first language. It's not the thing that they really think in. They have sort of a conversation with their tools in order to construct the program. I don't think that's necessarily negative, but it's very interesting.
• 1:11:55
  Speaker 2: It's a great point. And I think that one that sort of leans on modern, like what we can do do in a way that then becomes structural, but also important. I'll, I'll, I mean, I'll go one further, which is when I'm looking at code reviews in GitHub, I sometimes find the Rust unintelligible. Because it's like, you know, let variable name equals whatever. And I, and I am desperate for Rust analyzer to tell me the types of everything.
• 1:12:20
  Like I'll sit there and assign, assign things to types, just so that Rust analyzer can help me figure out what, you know, what's coming out the other end. But but you're right that the these types have become extremely I mean, these these tools have become extremely load bearing for how, I guess, how everyone like rice rust.
• 1:12:39
  Speaker 3: Better ID support was, like, one of the number one things on the survey every year for a very long time. Yeah. For exactly that reason.
• 1:12:46
  Speaker 1: I I like syntax highlighting, which I also don't don't use. I have learned, like, not to bring this up in mixed company that I don't use Rust analyzer. I I I not pejoratively. I just don't end up, I'd and part of the reason that I'm not, like, mappy foldy, always because I it is easier. Although, again, I'm trying to get better about that and trying to, like, rewire my brain around it.
• 1:13:09
  And it has it does, I think, yield better code. But but, sure, I think to your point, I actually do think Rust is becoming the way I think about a problem. Rust has become the way I think about it, I should say. I I it is my first language at this point. And, actually, I went back to write I at least I hope it's my first language because when I went back to write c recently, it was, otherworldly.
• 1:13:29
  Speaker 2: It was a very strange experience. Very, like, jeez. Okay. How do I pattern match again? Like, how what's the syntax for that?
• 1:13:36
  Speaker 1: I just feel like with c, I feel like I'm going, like, cave diving where I'm just like, okay. I've gotta go, like, triple check all the equipment. I've got, like this is a 100% on me, and a lot of people die down here. So I need to be, you know well, I'm not in the Rust swimming pool here where the like, nothing is gonna help me out. I need to be very, the compiler is not gonna help me out.
• 1:13:57
  I've become very accustomed to the compiler helping
• 1:13:59
  Speaker 3: me out.
• 1:14:00
  Speaker 6: Does anybody feel that learning Rust has made them a better c programmer?
• 1:14:03
  Speaker 1: For sure. No question. It has made me a bet you because and that is, Dan, why I'm so I've got such trepidation. And I mean, I've I said this early on with Rust that the one of the things that we don't talk about enough with Rust is the integer safety. And the, with the one of the the most serious vulnerabilities in DTrace was an integer safety issue.
• 1:14:23
  That Lint did not catch, the compiler did not no one, like, helped me. I felt like abandoned by everybody because and I had done something that is extremely common in c where you're saying, if bounds plus size is less than my limit, then it's good to go. And it's like, nope. Not necessarily. And no one is actually gonna actually check on that.
• 1:14:45
  And if if if you have, integer unsafety, so I do feel it's made me a better C programmer, although also a more cautious one as a result. Dan, do you feel it's made you a better C programmer?
• 1:14:57
  Speaker 6: Oh, definitely. Definitely. And so I I went to our exercise a few years ago, rewriting MIT's x v six operating system in Rust. And, you know, having and and and that was really it was a very interesting exercise because having the c code next to the Rust code was fascinating because I saw bugs in the c code that only that I would've never seen had I not actively been writing in Rust and thinking about those things.
• 1:15:25
  Speaker 1: So did do do you have some little features that have been added over the years that you particularly like?
• 1:15:33
  Speaker 6: Well, so it's weird. I've spent the bulk of my time writing Rust code, writing bare metal code for large scale systems. So I never like, it it's weird. Async, was mentioned earlier, and and it just mystifies me. It's totally foreign to my experience.
• 1:15:50
  When I got to Akhmed, I found myself writing a very different type of Rust than I have in writing. But definitely, ASM, oh my goodness. The new ASM well, it it's not new anymore. It's, like, 4 or 5 years old now. But the the the sort of stabilized ASM syntax changed my life.
• 1:16:06
  All those weird, like, mix that you had to put in with the GCC style LLVM and line asm stuff. And it's like, okay. You put an m here, and I think that means a memory operand. But nobody really knows because this is all just kind of strange. And put a star there, and maybe it'll do something different, and maybe it'll do what you want.
• 1:16:23
  Like, when when the new add them syntax came in, I was I was ecstatic. That just blew my mind.
• 1:16:28
  Speaker 4: Yeah.
• 1:16:28
  Speaker 3: I saw a tweet I saw a tweet recently that somebody said, like, if you show me some assembly written in gas syntax, I'm gonna assume that you're a serial in your spare time.
• 1:16:38
  Speaker 4: So, anyway, it makes sense.
• 1:16:41
  Speaker 1: Another one that I that happened, I guess, not too recently, maybe earlier in the year, but, capture identifiers and format strings. Do you use this, Adam?
• 1:16:50
  Speaker 2: This is where you can do, like, open curly name and variable close curly. Yeah. I I I, you know, a
• 1:16:55
  Speaker 4: colleague of ours, John, John Gallagher, was was using that. I was like, cool. I didn't know
• 1:17:06
  Speaker 1: It's really cool. And I like your cons generics where you've I I've got some residual shame over why I like captured identifiers so much format strings. Because I'm, like, I am strung out addicted to build RS, and, like, I'm a hardened I mean, this is actually where you do a you know, Drew, you've been making it or or your point that it's like, Rust blur some of the boundaries. One of the boundaries that it blurs in a great way is the boundary between the build system and the artifact. And build RS lives in in the this this kind of interstitial layer, And the ability to generate code programmatically has been, to me, has just been huge for programming of hardware software layer.
• 1:17:49
  And that's actually ends up being, like, a lot of format strengths, and that ends up being a lot of variables and format strings. So it's, like, it's I have a guilty use case, but it's been liberating.
• 1:17:59
  Speaker 3: I like this feature for a obscure reason, which is it's very similar to the way that you do it in Ruby, which you have a pound first and then the curlies to put a variable to interpolate a variable there. But back when I used to teach Ruby, I used to explain to people to help them remember the syntax that the curlies are like little crab pinchers that hold the variable in place in that part of a string. And so for that then to end up in rust and the whole crabs thing, like, years later is, like, very satisfying to me.
• 1:18:24
  Speaker 2: That's awesome.
• 1:18:25
  Speaker 1: So Homecoming. I just Steve, what what what are some of your little the or actually, listen. I can see you. I'm getting there. Wait.
• 1:18:31
  Do you have a do you
• 1:18:31
  Speaker 4: have a favorite one that does?
• 1:18:32
  Speaker 8: Yeah. I have a small one that was recent. New Cyclic.
• 1:18:37
  Speaker 1: Oh. Oh, okay. Tell me about that one.
• 1:18:40
  Speaker 8: It's just like you lets you create an arc. And at creation time, you give a disclosure that where you get the weak reference to it so you can store it or whatever. So you can create these like soft referential things much more easily without having to resort to a bunch of unsafe like we were doing in Purple's for a while.
• 1:18:59
  Speaker 2: So what what are you using this for?
• 1:19:03
  Speaker 8: Sometimes you just want to hold a weak reference to something
• 1:19:14
  Speaker 1: Okay? So just, like,
• 1:19:15
  Speaker 4: you know, just get off. Yeah. Friends.
• 1:19:17
  Speaker 3: Sometimes you just need to do
• 1:19:18
  Speaker 4: it. Right?
• 1:19:20
  Speaker 1: That's very cool. Yeah. I had not I that's a good example. So I mean, I that I knew it. I was gonna have a favorite thing.
• 1:19:25
  Speaker 8: Like, 1 dot 6 o.
• 1:19:28
  Speaker 4: Okay.
• 1:19:29
  Speaker 1: A couple months ago. Yeah.
• 1:19:30
  Speaker 2: Yeah. What's so cool is, like, in the run stocks, it tells you that. Like, 1.6 o, it puts it right next to it. I mean, there there's so many nice things like that. Where if you went to it and said, why is this not working for me?
• 1:19:41
  It has it right there in the documentation. Like, why it's not working for you? And how you get to the version that does work? I I love this thing.
• 1:19:47
  Speaker 8: Right. And a little older one is not needing to put externcrateblah everywhere.
• 1:19:54
  Speaker 1: Oh, yes. Superbure. When did that stage because that that's one of those things that I think I didn't even notice had happened. I think I just forgotten extern crate, and I was just no longer being yelled at by anybody. And I
• 1:20:06
  Speaker 6: That was 2018, and that was magical. Magical. Like, actually, real deterministic syntax for figuring out what is coming where with with respect to a crate. That was a game changing feature for
• 1:20:19
  Speaker 3: sure. There is a little extra crate in Hubris still, Brian, so you'll have to remember at some point briefly.
• 1:20:23
  Speaker 6: You have to do it for Alec. Like, if you're implementing Alec yourself, then you're kinda you you have to do external create Alec, but that's kind of the only one I did.
• 1:20:31
  Speaker 8: You have to do it for macros for a while?
• 1:20:33
  Speaker 4: Yeah. Right.
• 1:20:34
  Speaker 1: That's right.
• 1:20:34
  Speaker 4: I mean, I remember doing it for macros.
• 1:20:37
  Speaker 2: Yeah. I still bumped into it with some older crates that are still doing it for macros.
• 1:20:41
  Speaker 1: But Steve, did you just step on a dog toy? That is
• 1:20:43
  Speaker 3: fantastic. I did, actually. I did step on a dog toy. Yep.
• 1:20:47
  Speaker 1: I was like, this is doing nothing for my view of you having a 1940 sound effects reel. They it are you waiting for, like, a cloud horn?
• 1:20:53
  Speaker 3: But those
• 1:20:54
  Speaker 4: of you
• 1:20:54
  Speaker 3: who don't work at Oxide, I have this, like, program I run on my camera where it filters out everything behind me so it only shows me. And so there's, like, a joke the other day where I had the dog. I, like, took that down or whatever, but it's like, oh, you can finally see what's in my apartment. So this is kinda like the opposite. Now everyone's, like, hearing what's in my apartment, like, mapping it out.
• 1:21:13
  The CIA
• 1:21:14
  Speaker 4: I am.
• 1:21:14
  Speaker 3: Out my apartment by the noise or whatever. Yeah.
• 1:21:16
  Speaker 4: I thought
• 1:21:17
  Speaker 6: it was just how excited you were about not having to write external credit anymore.
• 1:21:21
  Speaker 3: I definitely was psyched about it for sure. I have my list is a little strange because it's a it's a tooling feature and a not actually stabilized yet, but should be soonish kind of feature that I will enjoy a lot. And then also a ridiculous analogy, back to the earlier bit about programming languages, growing what a programming language means in Rust analyzer stuff. The thing that I the the biggest, like, small thing that's a big thing for me is RustUp can now get link dot exe on its own from Microsoft instead of you needing to go download the Visual Studio tools and install all that
• 1:21:55
  Speaker 2: crap yourself.
• 1:21:57
  Speaker 3: That is, like, super, super clutch for people getting started on Windows because it's, like, the number one step that, like, you get wrong and it's, like, a big giant pain. And I don't even know how they did it because Microsoft doesn't distribute that stuff independently for whatever weird reason they do, but however they did it, I don't even care. They just it works now. So in the latest Rust up, if you install it on Windows, you don't need that
• 1:22:27
  Speaker 1: the ability to to write programs for Windows would be so low bearing for myself. But at Oxide, because of the double e's in particular, have a lot of tooling that is only on Windows, it has been I mean, singularly valuable to be able to generate software that runs on Windows. So that's actually that's really important. That's great to hear.
• 1:22:44
  Speaker 3: Yeah. The, the one that I think is, like, super maybe life changing is a little wrong, but I think is really awesome, is not quite stabilized yet is the x86 interrupt ABI. So Dan referenced xv6 before, but like, classically, you know, xv6 has a Perl script that generates the assembly, that's the prologues, and and, afterward for all of your interrupt handlers. And, like, the way that's always been done since the basically, the beginning of time is to always push and, you know, pop the state that you the state for every register that could be possibly mangled by your interrupt handler because, you know, you don't necessarily wanna think about exactly how that's gonna be cogent and all that stuff. But when you had the x86 interrupt ABI, now you can just write a normal Rust function and it will, like, cogen for you and it knows which registers it's using and not using, So it'll only push and pop the stuff that you actually use based on the actual cogen of the stuff that you wrote.
• 1:23:40
  So it actually be, like, more efficient and it's easier because you don't need to deal with, like, developing all that stuff stuff yourself. You can just be like, This is an interrupt handler. Please make it callable appropriately for me, please. I think it's a really cool, like a thing that you maybe assumed couldn't be done by a compiler, but, like, actually can, and it's both easier and better, which is, like, extra wild and awesome.
• 1:24:01
  Speaker 6: I'm gonna agree. Push back on that. I I I and the reason why is that very often in interrupt handler, you want to manipulate the state that you're gonna return to. So you actually need, like, a mutable reference to a data structure or something that has all the contents of the registers on it. So usually what you end up doing is creating some data structure in assembly language that you sort of push onto the top of the stack, and then you pass a pointer to that as an argument to the actual handler function.
• 1:24:28
  And, like, I mean, I hear what you're saying, Steve, and I'm I'm I'm I actually kind of apologize. I'm not trying to be a
• 1:24:33
  Speaker 4: a jerk about
• 1:24:34
  Speaker 6: it. But I just I I remember seeing that, and I was like, oh, that's kinda nifty. And then I I kinda thought about it, and I was like, actually, it doesn't work for my use cases. So I've never, unfortunately, used it.
• 1:24:45
  Speaker 3: Totally. Yeah. I mean, this is the thing about this with the super low level stuff is that, like, you know, it'll be useful for some people and not for others. Like, most of my most of my usage of that feature is, like, messing around with toy OSes, so I can, you know, not do those techniques. So it's more meaningful for those kind of things, I think, than it is necessarily for everybody for sure.
• 1:25:03
  Speaker 1: And the RFC is in the interrupt calling conventions RFC. Is that right? Am I
• 1:25:07
  Speaker 3: right? Yeah.
• 1:25:07
  Speaker 1: I think yeah. So that's from Philip from who Yeah. Wrote the the blog OS. Yep. So that's that's interesting.
• 1:25:14
  That's that's coming from.
• 1:25:16
  Speaker 4: Cool. That's yeah. That's that those
• 1:25:18
  Speaker 1: are at opposite ends, I I feel, of the stack, Steve, in terms of your Yes. The the honor downloading.
• 1:25:24
  Speaker 3: Definitely. The the the silly analogy thing is is I think so it's just, like, a little more than a programming language, and there's also, to some degree, about the, like, does it make you a better c programmer? I think that there is a deep affinity between Rust's viewpoint on the world and the way that the Dutch build roads, which basically is like it's it's so okay. The way do you know how we set speed limits in the US? What we do is we, like, we, like, send an n turn out on a sunny day, and we watch all the cars drive past, and we knock off the top 15%, and then that's the speed limit.
• 1:26:01
  So we, like, build a road, and then we observe how people act, and then we set the rules based on how they act, which is, like, a problem for safety because you get spaces that are designed purely for cars and car speeds and, like, all that kind of stuff and the Dutchman and everything else. The way the Dutch view building roads is they actually have a now they have this classification system, and there's 4 different kinds of roads. I won't get into that thing. But the point is is they look they go, okay. This is a residential road and a residential street.
• 1:26:25
  Therefore, for safety reasons, we want cars to only go 25 miles an hour. Therefore, how do we design the road so that a driver will feel that 25 miles an hour is an appropriate speed to drive, and they don't even necessarily need to, like, look at the speed limit sign or, like, feel limited by the speed limit. It should just be the natural way that you drive. And so there's techniques and tools that you use to, like, make that happen when you're designing a road.
• 1:26:47
  Speaker 1: We're just gonna make this road, like, shit scary at 30 miles an hour.
• 1:26:50
  Speaker 3: Yeah. When you, like, put up a lot of trees along the side, you make the things narrower. Like, one of honestly, one of the biggest differences we believe in the US that you make roads safer by making them wider. Turns out that means people feel more comfortable driving faster, and it actually makes roads more dangerous. So they'll actually make very narrow roads with like, speed bumps and stuff, sort of things like that.
• 1:27:09
  I could go on with this a long time, but it's not the Dutch road building meeting space or whatever. But Russ, Russ' attitude is, like, is, like, different in that, like, more similar to that in that, like, we're gonna construct an environment where you don't have to think super hard all the time because humans are fallible and make mistakes and they get tired and they maybe drink a little bit and, like, you know, all these other things that happen. And if we can construct an environment where you can do stuff and a compiler will be like, no, no, no, actually, like, you know, I'm gonna nudge you towards right thing, it means you don't need to put as much cognitive load on these things that don't matter, and you could think about your problem a little bit more, as opposed to, like, necessarily needing to remember. Like, because when I go back to Ruby, for example, like, now, I'm, like, terrified because there's no thing that checks to tell me if what I'm doing is ridiculous. Like, when I write Rust, I'm, like, not thinking that much because I know that the compiler has my back.
• 1:28:02
  And so I rely on it, like, to to handle all these things that I don't get in other languages because we've created this environment in this way that guides you towards an appropriate, you know, part of the space. And so I think for me, that's like it's not even so much that I, like, become a better programmer in other places. It's just that I realize how much other languages are, like, let's widen the roads to make it safer, when that's, like, not actually the right way that you make things easier for programmers. Like, giving people ultimate amounts of choice really ends up meaning they drown in thinking about all the details too much whenever what we really need is to, like, create a thing that will get you to do the right thing without needing to think about everything all the
• 1:28:40
  Speaker 6: time. Okay. I have to I have to jump in here because this really brings home something for me that that I think is a is a big deal. Especially in the systems programming community, there is just too much gatekeepering, and I think so much of that is based on kind of the corollary to what Steve just said. It's this idea that people can keep all that complexity in their head with languages like c and c plus plus, and therefore, they are somehow better qualified than the people who are mere mortals like myself who just can't.
• 1:29:11
  Speaker 1: Yeah. It's
• 1:29:13
  Speaker 6: Yeah. And so therefore, they look at a language like Rust and it lacks I'm I'm you know, the machismo or whatever you wanna call it of a language like c where they're like, look, you know, I I can I understand undefined behavior, and I've read every word of, you know, the c eleven spec, and I can apply it this, you know, forwards, backwards, and sideways? Therefore, I am better at doing this than you are. And I feel like that is a huge, huge barrier to entry to, say, doing carnel development. And I'm actually really glad that Russ takes the opposite approach.
• 1:29:46
  They kinda like, no. Let's make the roads narrower, and let's, you know, decrease the surface area with which you can cut yourself because it turns out that's actually really important.
• 1:29:55
  Speaker 5: And I think that that's gonna
• 1:29:56
  Speaker 6: democratize things and make it easier for people to get involved.
• 1:29:59
  Speaker 1: Totally. And then the compiler can actually help you a lot. That's, to me, is, like, the big I I did not think you and, Adam, just you said you didn't feel you could love again. Maybe those weren't your exact words.
• 1:30:09
  Speaker 3: No. That's how
• 1:30:09
  Speaker 1: it was.
• 1:30:10
  Speaker 2: Yeah. Or even love for the first time.
• 1:30:11
  Speaker 1: But yeah. The but I felt that, like, the compiler was just always was a burden. It was not something was something to be dealt with, not something that could actually help me write better software. And, Dan, just to your point of, like, that's what Rust does. And, Steve, you might not have seen it.
• 1:30:31
  Dan had a had a tweet during our conversation. I think it's pretty interesting about when he felt the chasm was crossed. And I didn't I think it was a very good point. The hard copy publication of both the Rust programming language and programming Rust, which Yeah. That was really and I remember buying both of those at the same time and reading both of them, and I totally agree that that's a good point about the the the chasm being crossed then.
• 1:30:52
  Speaker 6: When when we were advocating for switching Hyperion to be written on Rust from c plus plus at Google, we had to write a document to justify that. I mean, that was an extraordinarily controversial decision. And so myself and the, you know, and the tech leads sat down when we wrote this doc, and that was one of the big data points. And I was like, look, people have committed to putting these words onto dead trees. That means that language no.
• 1:31:14
  I'm I'm totally serious. I mean, that means that this language has reached a point of maturity where people are basically betting that it's not gonna change that much in the future. And that means that it's gonna be relatively stable for us to program against. And that was huge.
• 1:31:28
  Speaker 3: Interesting. It also is huge for the book market because after people saw how well both of those books did, that was also why you see this, like, a year or 2 later, a giant explosion in the amount of books that were written on Rust because everybody went out and bought both books. And, like, people looked at that and were like, oh, holy crap. Okay. This is a real thing, and therefore, publishers started soliciting more authors and, like, all that kind of stuff.
• 1:31:51
  So it definitely was, yeah. Totally. That's cool. Big moment.
• 1:31:54
  Speaker 5: I'm also thinking of John's book that
• 1:31:57
  Speaker 6: came out in the past year. Yes.
• 1:31:58
  Speaker 3: Oh, yeah.
• 1:31:59
  Speaker 1: That's so good. That
• 1:32:00
  Speaker 3: Rust for Rustations.
• 1:32:00
  Speaker 5: Rustations. Yeah. That one is, absolutely phenomenal.
• 1:32:05
  Speaker 1: Okay. I didn't you know, I have not read that yet, and I'm gonna I'm buying that now.
• 1:32:09
  Speaker 3: Oh. That You definitely should.
• 1:32:11
  Speaker 5: Like Yeah. Like, sitting like, the I I'm trying to remember, like, 2018 because that's when I started writing. And or or 2019, early 2019. And I think it was actually John who's Twitch streams I found. I was, like, in the programming section because I was, like, watching just random things on Twitch, and I was like, oh, you can, like, watch people program.
• 1:32:42
  I think that's pretty cool. And and then it's kind of cool to see that come full circle. I know if anyone else here, feel free to chime in if any of you have seen his streams, but they're pretty sweet.
• 1:32:55
  Speaker 3: I've heard many people express that opinion. I personally haven't watched them, but I really like the way that John teaches stuff, and I'm sure they're great.
• 1:33:03
  Speaker 1: Yeah. Yeah. I'm I'm sorry. I can't talk ordering book. I've no.
• 1:33:08
  Speaker 4: I I I
• 1:33:09
  Speaker 1: I'm I'm literally ordering the book right now. And unlike, you know, normally, I'm I am I'm I'm being a skinflint and, you know, spending a dollar 98 for a used book. This one's I'm buying new, baby. This one.
• 1:33:20
  Speaker 2: You you and me both, and I'm expensing it.
• 1:33:23
  Speaker 1: I'm expensing it too. That's why I'm buying it new. I feel
• 1:33:26
  Speaker 4: I, yeah,
• 1:33:26
  Speaker 1: I I I feel like I can't make Pierre de la Man pay for, like, the 15th history of tandem that I'm buying. But, you know, actually, the the the frustrations I feel we can put on the company is nickel.
• 1:33:37
  Speaker 8: But, you know, like, speaking of those videos, the one that I always go back to is the atomic and memory ordering one because it is It's so hot. Explain. I mean, it's just that. It's like I feel like it's really hard to get those subtle details right. So every so often, I'll just, like, rewatch, like, the relevant part, and it's, like, so well explained and definitely elevated my understanding of them.
• 1:34:03
  Speaker 1: And this is And this is 8
• 1:34:05
  Speaker 3: stream? Well, I think you watch it
• 1:34:07
  Speaker 8: on YouTube. Like, it was definitely live stream, but you can watch, like, you know, the VOD of it.
• 1:34:12
  Speaker 5: Yeah. John John, he he he switched to doing, like, crust of rusts, and I think they're, like, a little shorter format, and they get reuploaded to YouTube. So I'm gonna call it, like,
• 1:34:22
  Speaker 4: a little
• 1:34:23
  Speaker 1: short. It's,
• 1:34:23
  Speaker 8: like, 2 and a half hours.
• 1:34:27
  Speaker 3: Yeah.
• 1:34:27
  Speaker 4: But it
• 1:34:27
  Speaker 3: has to show off.
• 1:34:31
  Speaker 1: That's awesome. That's definitely something to check out. Ben, I you I I know you were looking to get in here a little while ago.
• 1:34:39
  Speaker 10: Yeah. Among the the recent features that
• 1:34:42
  Speaker 6: that hit home, I I
• 1:34:43
  Speaker 10: I feel like I have a a a niche one and a more common It
• 1:34:51
  Speaker 2: When you're when you're muted muted, we're getting we're getting some echo from you.
• 1:34:58
  Speaker 10: So the in in searching for, UB in various published creates, I found, Rayon and protobuf were doing, invalid out of bounds get unchecked in order to access the uninitialized region of a back between the length and capacity. And that seemed interesting. Yeah. Especially because the the valid way to do this in Rust used to be a little bit complicated, at least especially for for what Rayon was doing. Right?
• 1:35:33
  When I when I raised this with the the Rayon authors, they said, oh, you know, we actually wanna have a slice to that region. We wanna make sure that the lifetime is correct. And so they they didn't just wanna use pointer arithmetic directly from the from the pointer in the back. And so there was an unstable API to do this. Right?
• 1:35:48
  Spare capacity mud. And so I just commented on the tracking issue, and I was apparently the only one who'd really noticed that there was a lot of need for this. And it just got stabilized pretty quickly after that, which was which was really interesting.
• 1:36:05
  Speaker 3: That's awesome.
• 1:36:06
  Speaker 1: That was really satisfying too. It wouldn't be like, hey. I was able to kinda connect these get connect this kinda effort over here with the need over there and help make it happen.
• 1:36:16
  Speaker 10: Yeah. Yeah. It was it was one of those experiences where I'm I'm not sure if people knew that they needed this, and now I'm now I'm wondering how much we'll be able to get people to actually, use it, but I'm I'm hoping that people find it in the docs when they're actually looking.
• 1:36:29
  Speaker 1: And this is you said it's and I I'm also gonna reveal that I think maybe I I mean, it's a common theme that I mispronounce things, but I say mute when I read it aloud in my I do too. You do too. Mhmm.
• 1:36:43
  Speaker 10: I I go back and forth, honestly.
• 1:36:47
  Speaker 2: Good. Is Wait wait. Wait. I'll only be wrong half the time.
• 1:36:52
  Speaker 1: Is this, like, rust cube cut over this cube CTO is whether Okay.
• 1:36:57
  Speaker 10: Oh, no. Okay. We gotta talk about this. You got me started on Cuddle, and nobody else that I have talked to says that.
• 1:37:04
  Speaker 1: Says Cuddl.
• 1:37:05
  Speaker 6: Sorry. This is I I I told the MX card here. This dates back like, 19 yeah.
• 1:37:11
  Speaker 1: Are we talking when you say, like, I personally got you started on that because I Yeah. Oh, boy. Yeah. I I I realized that, the I had the I was in a the changelog podcast a week and a half ago, and someone said, you know what? I realized after listening to this podcast that I've been mispronouncing the word n a d I r.
• 1:37:32
  And I'm like, no. No. No. Wait. Actually, stop.
• 1:37:34
  Before I think I may be mispronouncing it. How do you pronounce that word, Steve? Nadir? Do you? Is it because of me or did you make it no.
• 1:37:44
  Speaker 3: I just that's what it looks like. It should be that's a little how it looks to me. I don't think I've ever heard you say it.
• 1:37:49
  Speaker 1: Okay. Good. Oh, god. Thank god. God bless you.
• 1:37:51
  I if this is just part of the the the larger intervention around fold and map and fold, that's fine. Yeah, I do say Nadir, but, Adam, you say Nader.
• 1:38:01
  Speaker 6: That's right. Sorry. Brian's in Brian's in the clear here. It is Nadir.
• 1:38:07
  Speaker 4: Brian's in the clear.
• 1:38:08
  Speaker 1: Dan is waiting. Alright. Oh, benevolent Dan. Weigh please weigh the hearts of the those before you. Are maybe you could pronounce it either way.
• 1:38:18
  So I don't know. Kuddl, I think you gotta put that in the maybe in the other either bucket. But I do say mute when I am reading Rust aloud to myself. Adam, do you say mutt or mute?
• 1:38:31
  Speaker 2: I try to avoid it entirely by not having anything be mutable.
• 1:38:35
  Speaker 1: Oh, are you a safe
• 1:38:38
  Speaker 4: Well, from the high ivory tower of mappy foldy
• 1:38:41
  Speaker 3: Don't don't even declare a variable as mutable if you don't declare any variables
• 1:38:45
  Speaker 2: in the first place. So
• 1:38:47
  Speaker 1: Aren't you a saint? Shouldn't we all live like Adam and never use the keyword? Adam's like, is that even a keyword?
• 1:38:54
  Speaker 4: I don't even know. I don't
• 1:38:55
  Speaker 2: I don't know what you're talking about. It's a new language feature I've never seen. Is this what we're talking about? Can I just add this?
• 1:39:03
  Speaker 5: There is definitely this, like, addicting element to, like, like, start using closures and pattern matching. And it's like, I wonder how few statements I can write. I'm not sure if anyone else has ever gotten that sort of power trip before, but
• 1:39:16
  Speaker 2: it's gonna
• 1:39:16
  Speaker 5: happen a few times and totally unnecessary too. I'm just like, I just wonder how far we can go to have this road.
• 1:39:23
  Speaker 6: I I feel like I feel like like Rust programmers go through these stages when they first start out. It's like you start out fighting the borrowing checker, which, you know, is something of a controversial statement, I believe, but everybody kinda goes through that. And then it's like, oh, wow. Traits are so cool. Let's use them everywhere.
• 1:39:39
  Yes. Traits gone wild. He's
• 1:39:41
  Speaker 1: a Yeah.
• 1:39:42
  Speaker 6: Yeah. And then it's like, what are the other neat features of the language that I can use? And then after, I don't know, I wanna say, like, 6 months to a year, people start writing pretty reasonable code that starts to seem idiomatic. But it's like, it definitely takes a while to come up to speed and and become, like, a proficient idiomatic rep for car.
• 1:40:00
  Speaker 1: Yeah. And I I feel like also, at least early on, I feel I needed a cliff to bless some of the things that I was doing as there's not a better way to do this. I feel like with Rust, it it Rust is constantly driving you to think, is there a better way of doing this? And it can be helpful from an experienced frustration to be like, actually, that's basically that's pretty good.
• 1:40:18
  Speaker 3: There's a blog post I can't remember that's, like, about stages of somebody writing a programming, like, like and they they show them writing, like I think it's a lisp. Like, they're like, write like, and then they just learn Haskell's. They write that function this way, and then they learn Ruby, and they write it that way. And it's, like, showing different styles of programming, but I cannot remember what the name of it is whatsoever.
• 1:40:42
  Speaker 6: There's one where, like, the Haskell programmer discovers point point arithmetic and things of this nature. And And then, like, at the and then and it's like writing hello world or something. And then, like, at the end, they get back to the original program written. Like, oh, wow. That really simple program is actually pretty much the way that you do it.
• 1:41:00
  Speaker 1: Totally. Hey. Hey. I wanna get to a small feature that, Adam, I discovered in looking at what small features I might have missed just in preparation for today. Nice.
• 1:41:08
  Cargo ad. Have you seen this?
• 1:41:10
  Speaker 2: Yeah. I did see that recently. And it and it because it adds it to the Cargo TOML. Yes. It gets the resources.
• 1:41:17
  Speaker 4: It is the best.
• 1:41:18
  Speaker 2: And you don't have to sell it yourself with, like, opening an editor.
• 1:41:29
  Speaker 3: I've wanted it for so long. I'm so glad that Epage was able to put in so much work to make that happen because it was great.
• 1:41:34
  Speaker 1: Yeah. It's that that I mean, and that's one of the things that I'm sure was, like, a bit early to actually do, honestly, because it's kinda rewriting you know, it's rewriting one of the files that you got. And, but that is the that one, I have not used yet because I only discovered it, like, you know, 15 minutes before we started, but I'm definitely putting that on the list. Another one that for me, I love, Steve, that I I don't know what your take is on. Links in Rust doc, I actually find really valuable.
• 1:41:59
  That's a
• 1:42:00
  Speaker 4: good one. It's not that That's
• 1:42:01
  Speaker 5: really important to note.
• 1:42:02
  Speaker 3: To a lot of discussion. So good.
• 1:42:04
  Speaker 5: For forgive me for interrupting. My bad.
• 1:42:07
  Speaker 3: No. I was just saying, unfortunately, I need to go because it's getting a little late here.
• 1:42:11
  Speaker 1: So I I which is a great segue. We we are I we're we we definitely wanna wrap. I know we've gone on a a bit long. The, absence party, You wanna
• 1:42:23
  Speaker 11: Yeah. That's me. Zeeshan. I would say I think, 2 things to say really quick. I I think you mean Kyle Kingsbury's typing technical interview?
• 1:42:30
  Speaker 3: That's definitely related. It's not the one I'm thinking of, but it's definitely a similar one. It's very good, and anyway, everybody should go read that for sure. Absolutely.
• 1:42:37
  Speaker 11: Yeah. Yeah. I Anyway, I was just gonna say, obviously, the the Rust links as well is, to me really huge, because also the documentation in Rust is a big thing to make people understand, like, why this language? I think it's just another reason why it showcases, like, oh, like, we're doing this. You can actually read about what's happening.
• 1:42:54
  There's really good docs. A lot of languages kinda suffer from really great documentation. So
• 1:42:59
  Speaker 1: It definitely do. I know I'm I'm sorry to take the wind out of your sales, but
• 1:43:02
  Speaker 5: I got I'm I'm glad that you're gonna say
• 1:43:04
  Speaker 1: the same thing. I actually I love Rustoc. I know, Adam, you've used it a ton, and made great use of it in in and elsewhere. So it it, it's a terrific attribute of the language. Well, this has been, Steve, thank you so much for joining us, Steve Lukman.
• 1:43:19
  Yeah.
• 1:43:20
  Speaker 3: Thanks for having me.
• 1:43:20
  Speaker 1: It's great. I mean, you YouTube obviously been in this community a lot longer than than than we have, and I've got a lot of longevity here and and great perspective. But, honestly, it's been so great that Rust I think unlike so many things I use where updates are something to kinda dread because they're gonna break things, I it's like wrapped presents under the tree on Christmas morning and waking up at, like, 5 in the morning to go unwrap them. It's really exciting to move to the
• 1:43:48
  Speaker 6: latest. So
• 1:43:49
  Speaker 3: It's gonna be 10 years for me in December. So I'm finally gonna be able to answer all those job ads that need 10 years of Rust experience. Exactly.
• 1:43:58
  Speaker 1: Nice. Awesome. Well, hey, Adam. Thanks for the tweet too. They they got us kick started on
• 1:44:02
  Speaker 4: this one.
• 1:44:03
  Speaker 1: And and and in the end of the movie, did your heart grow 3 times as large? Would you like
• 1:44:08
  Speaker 2: At at least. At least.
• 1:44:10
  Speaker 1: Awesome. Alright. Thanks, everyone. We're gone next week, but we'll be back in 2 weeks. I'm
• 1:44:16
  Speaker 5: looking forward. We got a a guest lined up for
• 1:44:18
  Speaker 1: 2 weeks. I'm looking forward to that. Alright. Thanks, everyone.
• 1:44:21
  Speaker 4: Talk to
• 1:44:22
  Speaker 1: you later.
• 1:44:23
  Speaker 7: Peace.