Two's Complement - A Bit Rusty

Episode Date: November 16, 2022

Matt and Ben discuss the Rust programming language, recall some hobby projects they've used it for, and speculate about where else it might be used, such as embedded rust. Ben tries to remember how Ethereum works, and fails. Matt makes a ray tracer and a Weird Al reference.

I'm Matt Godbolt. And I'm Ben Rady. And this is Two's Compliment, a programming podcast. Hey, Ben. Hi, Matt. How's it going? Good. So it's that time of the week again, and you and I are staying with each other through

webcams and blurry backdrops and all of that. How much processing time do you think is being wasted by GPUs blurring backgrounds or substituting in other people's backgrounds right now? I mean, there's got to be a substantial amount of heat death of the universe is caused by Gmail, not Gmail, Google Me and Zoom and all these things like doing this really intense AI operation to determine what is foreground, what is background, and then doing something with the background. Yeah. Well, you know, now that crypto's crashed, we got to do something with all those GPUs. Very good point. Very good point very good point so we're staring at each other yes we're staring we're staring at each other it's that time

and this week i figured um we've been talking on and off about various different languages and our experiences with them obviously python javascript c++ um html such as that's a language it's got it ends in an l so it's a l the l does stand for language it's like sql right sql structured query language you know it's not really that structured you can do more than query with it and so questionably a language um yeah visual source safe again none of those words are true none of the above anyway i feel like again we're off target already but talking in general about languages and the one we haven't really spoken about is rust mainly because you and i haven't got as much experience with it as perhaps we ought to in

order to have like really strong opinions but we have used it i've used it on a couple of projects i've got a toy project that i uh created which is like my standard way of learning a new language which is to write a ray tracer or a path tracer in it and that was a lot of fun and it's pretty performant i was very impressed with it that was a while ago and then i've written some command line tools in it since and you've done some work on it too right yes yeah i uh made some changes to the um ethereum uh node software that was written in rust oh to do a little bit of research into how the ethereum network worked and this was like gosh three years ago and i have basically forgotten everything about that project. I probably remember a few interesting things to know and tell,

but my intent, what I was trying to do there and what I think reasonably accomplished there is to sort of draw out a map of what the Ethereum network looked like, not necessarily from a geographic level, but more like a, you know, what nodes are actually producing the blocks that wind up in the blockchain and how do those blocks propagate across the blockchain?

Because at the time I was really interested in prediction markets. Roger was one in particular that was, had a lot of attention and people were talking about on Ethereum. And I was like, well, I mean, knowing what I know about traditional financial markets,

if someone's going to place an order and it's going to take some amount of time to get to the exchange where it's going to take some amount of time to get to the exchange where it's going to actually be recorded uh being able to know that that order is coming has a lot of value and that is actually what this is talking about like in a distributed exchange like you would see on an ethereum magical something something got it i see yes yes so i i was like trying to figure out if this was a problem basically like is this a flaw in the theory behind distributed i mean would really be any distributed type of

exchange but specifically i was interested in prediction markets and and auger in particular what is a what is a prediction market i feel like we're going we're getting derailed immediately here yeah you should tell me what a prediction market is because that sounds... We're going to put a lot of things on the conversation stack and then we're going to pop them back off again and figure out where we're going to start. Blurry backgrounds. Blurry backgrounds. So, yeah. A prediction market is a particular type of financial exchange.

It's similar to a futures market. It's similar to, if you know what a binary option is, it has some similarity to that. But basically, the idea behind a prediction market is that you use the quote-unquote wisdom of the crowds to predict the probability of future events by letting people bet on whether those future events will occur. Okay.

There have been a few of these sort of normal centralized ones. I think there was one called sort of an iInsight. I want to say Insight. I don't know if that's correct. It rings a vague bell that that some university was involved with one of them at some stage in order to... Well, there's one called Predict It, which actually recently, I think,

got shut down. They had gotten a letter, a no-action letter from some government agency, the CFTC. The SEC or the FTC or... Yeah, something like that. CRC or... And that agency recently rescinded their no action letter because of some things that Predictit was doing.

And all of, by the way, when that happened, I'm sure all of the Augur and sort of Ethereum-based distributed network prediction market folks went, See? See? I told you so. See? See? Right. Yeah. went cc i told you so cc um right yeah so this prediction market is somewhere where i can bet on a future thing happening or not so like what like a a presidential election or something like that and i say i think uh the conservatives are going to get in to the next uk uh general um election and so i i bet but who's taking the other side of the bet and how do you how does someone work out the probability of that happening or something because like presumably i like bet 100 quid or whatever and then someone will yeah

how does that bit work yeah so i mean the the way that different markets do it in different ways um my memory of augur is that the way that they did it is that you basically uh wound up creating two tokens every time you you sort of placed an order there was there was one that it would happen and one that it wouldn't and if the the transaction through, or basically if the order was filled, if you matched with somebody else that took an opposing position at a matching probability and price, like that's sort of the magic of prediction markets is that the price and the probability are the same. They're linked together in some way, right?

Exactly. So like, you know, in the case of predicted, it was like all of the prices have to be between one penny and 99 cents right um and that was the basically the probability that you were saying you know if you're buying something for 56 cents you were saying there was a 56 chance it was gonna and something like you buy it for 56 cents and it's either worth nothing or it's worth a dollar when the market actually when you decide and therefore the price approaches uh the certainty of the event as as exactly yeah got it okay now that makes sense to me as some sort of very hand-waving level yeah yeah yeah but like so any exchange from a traditional finance point of view i like you say any exchange knowledge is power and if you can see somebody is strongly buying up something on one side of your network and you can see that the

price is therefore therefore going to go up you can take advantage of that and that's what you were trying to do with this was to say is that a problem yes can this actually be gamed in some way or is it just fundamentally flawed and in order to to do that, we're going to slowly back up the stack, although I can easily go back down again. We're going to get to Rust here any minute. Any second, any second. Yeah, right. You wrote a program in Rust that parsed some kind of exhaust from the Ethereum network itself to see how information traveled across the network. Yeah, I mean, I wouldn't even give myself the credit to say that I wrote a program in Rust.

What I did was I made some modifications to the Rust Ethereum, the Ethereum node that was written in Rust, to capture some information as it was flowing through the node and to sort of change its behavior a little bit. Basically, what I would do is when an Ethereum node connects to the network, it finds some number of peers that it can pull information from, basically pull the blockchain information from. And I've made some modifications to that to actually actively seek out peers in the network. So instead of just taking whatever peers I discovered, I would try to backtrack and figure out, okay, well, you got this from this node, so I'm going to go back to that node and connect it directly and figure

out, oh, you got this from that node, and sort of try to work my way back and be like, where are these blocks coming from? What nodes are generally originating the blocks on the blockchain? Because that is probably the first reliable place that you would see this information. Additionally, the other thing that you can do when you connect to these nodes is look at the transaction pool.

So these are the pending transactions that may or may not show up in future blocks. I see. And you can get... To be mined in the kind of bitcoiny sense of it there are things that are yet to be checked to make sure that they are actually okay in terms of the rules of the network but they will be put into the next available block once the once whoever wins the lottery wins the lottery and publishes a new one got it exactly exactly and you can see you know the gas costs that they're willing to pay and you know the way ethereum works is the higher you pay the more you pay for for

your your transaction costs your gas costs the more likely it is that you'll wind up in a block so you can look at like it's almost like being able to look at the queue of incoming orders into an exchange like these orders haven't hit the book yet, but they will at some point. Assuming they aren't ill-formed or they haven't got a double spend kind of thing. So the whole thing that the miners are supposed to be doing is doing all these checks. Right, right. Then that will stand. That order will stand once all of the checks have been done. So you can look at it and kind of go, well, this is an intention to send an order, even if it isn't an actual order.

And you can use that as a, oh, that's really interesting. Right. And you can even do some things to validate for yourself that those things will, in fact, clear through. Because you could be mining yourself at this point. Yes. Your node is capable of doing the mining. It's just that you need to solve some drastically complicated math problem in order to mine the block. And that's just not what you're interested in doing.

But you could run the same checks that you would do. Yeah. Yeah. You don't even need to solve the drastically complicated math problem. Right. Because you don't care about that part of it. You don't have to sign it effectively, which is. Yeah.

Yeah. Yeah. Okay. And that happened to be written in Rust already. So you modified an existing piece of code. Yes. So what were your experiences like then? Obviously, you've done a whole bunch of procedural style, sort of C-derived-ish languages before.

Yeah. What were your thoughts about Rust then? Yeah, probably the closest analog to Rust that I had worked with at the time, and this is probably still true, is Scala. I wrote a little bit of Scala. Interesting. Probably about 10 years ago, something like that, that had, you know, that sort of like, you know, heavy use of algebraic types and pattern matching and all those sorts of things. Got it, yeah. And, you know, like, it was a little hard for me to separate the challenges of working in that style of language versus the challenges of just working in a completely unfamiliar code base, right? Because this was a fairly mature piece of software. And, you know, I, and I kind of knew the domain, but not, you know, nearly as well as I sort of had to eventually learn to sort of figure all this stuff out. So there was a lot of additional layers of challenge

heaped up on top of this to sort of get me to where I wanted to go. But the language itself I thought was really nice. The tooling I thought was really nice. The compiler was a little slow, but it was also

doing a lot of work for me, so it was sort of like, okay, I get why this is going to be slow. The interesting thing for me, obviously being so test-driven and everything, was I tried to write some tests for the code that I was changing, and I managed to write a few, but

the code in this Ethereum wallet I don't think was particularly designed to be tested. And even if they made an attempt to do that... Right, of course. Only sending transactions worth hundreds of millions of dollars.

So yeah, I mean, the challenge I think was finding a new level, a new sort of baseline for me in the balance between sort of types and tests, right? Because, like, depending on the language that I'm working in, I might write more or less tests. I definitely don't want to write tests for things that are guaranteed by the type system. That's silly. And so working in Rust for me was sort of

I was discovering multiple things at the same time. A, how this Ethereum node worked. B, like the general structure of this code base. C, how Rust worked. And then D, how to write tests for existing code in Rust that didn't just

check what the compiler was checking for me. So all of those things together made for a pretty interesting but challenging experience. So what was the, I mean, just ignoring the Rust aspect of this for a second, what was the upshot? Did you find anything interesting in your analysis? Yeah, I'd have to go back and look at the data that I captured to remind myself exactly what it was.

But what I saw was that there are very at the time it's probably different now there were very specific nodes on the ethereum network where it's like if you wanted to see the transactions first you just go there and you get them and these are like nodes where um the whole thing's peer-to-peer right so if i want to put a new thing on the network i connect to my to just some random peers but clearly the folks who are placing orders more had either geographically located in a place where their client had connected them to some set of peers that were able to take the load or or some other aspect but and you were able to say well this is these are where you should go if you want to see

those kinds of orders and yeah whatever reason for whatever reason i didn't come to any conclusions about the reason and at the end of the day it's not really that important like is this happening because of internet network topology is it happening because of geography is it happening because of default settings in the right is it just literally the nodes it's like connection dot i and i file in there right right right right um but it doesn't actually matter if the transactions show up somewhere first that's can get them there first, right? So that actually discouraged me from pursuing any more stuff with distributed prediction markets on Ethereum. Because I was like, well, I think this game is... The game you're playing here is not, how do I operate effectively in this market?

The game you're playing here is, how do I get the transactions first? And literally front run. I mean, people use the term front running for lots of things. Which is a legally defined term, I would just like to say, because people use it in a lot of ways

that are not correct, especially given our industry. We're a little sensitive to that. Exactly. In this case case literal front running because you could observe the pending orders that were yet to be um placed on the blockchain and you could make a decision based on them and then you could try and get your order in before them by sending it to faster nodes or different nodes or more or some just pay more gas you could send it

to the exact same note you say okay they're, they're paying two ETH of gas. I'm going to pay three ETH, and I'll get there first. Yeah, that makes sense. So, yeah, gosh. So that really dissuaded me from doing anything in those markets because I'm like, this is very gameable. And that was basically my conclusion. And then after that, I just stopped working on all the rest.

I kind of like, it's almost like you have the revelation, and you're like, oh. And you just sort of like back away slowly. And that was it. Yeah. Well, so a lot of rust there, but there was a lot of other things going on for you. So my toy project was, at least the first one I wrote, was this path tracer or ray tracer. I mean, they're similar.

Path tracing is what it's doing technically, but ray tracing, if people know what ray tracing is it's basically that uh and i do that i've done that in pretty much every language um i've i've learned of recent times it's just like my kind of icebreaker i know the domain fairly well the math is pretty interesting there's some modeling things it's kind of an ooe type project but you don't have to do it in o in fact i have a talk where i write that program three different ways in just in c++ using object-oriented or functional or data-oriented design kind of techniques just to show that they're how multi-paradigm c++ is but anyway i was writing this in rust i'm very familiar with it also it's almost like the opposite of your problem. I wasn't exploring anything other than the language.

And my experiences were very positive. I also, and this was a little while ago, I also hit the compiler is slow issue. But then I know that it has improved a lot since when I was writing this particular bit of code with. And I was able to crack out something that i was pretty happy with and then uh where i fell over um was trying to get it working nicely with with multi-threading and maybe that was just my inability to express to the compiler that what i was doing was quote okay because i couldn't convince at the time the borrow checker that the way that i was sharing mutable state sorry sharing constant state and had some things that were mutable that had locks

around them I couldn't explain it to it they're like hey I've got eight threads here and they're all doing different parts of the picture so you don't have to worry about them treading on each other's toes I promise you again either maybe I was mistaken and I was actually doing something that wasn't safe and it was just but, or you couldn't explain it at the time or I just didn't know how to do it. But certainly I ended up writing unsafe around just one tiny bit of the code. And that's, again, somebody could probably go

and find it on GitHub and tell me what I was doing wrong. But that kind of was like a reminder that there is an escape hatch in Rust for things. And, you know, on the one hand i was disappointed i think at the time i was like oh gosh this is silly can't do any non-trivial program without invoking you know unsafe stuff which turns off all of the the things that rust guarantees you which we should actually talk about because obviously if people are listening here just to talk about rust the things that rust can do for you is pretty clever the compiler um but it occurs to me

on sober reflection that all of c++ has the unsafe keyword right at the very beginning that's like the first thing you open void main unsafe is what c++ is and so kind of anything anything that restricts the scope of the unsafety to smaller and smaller parts of your code is got to be it's got to be a good thing yeah um so you know but i think probably that is just something i've learned to carry around with me and then i trust myself rightly or wrongly not to write code that is unsafe inherently even though there's no protection in c++ from you doing you can easily do the wrong thing all of the time and that's why i turned on all the warnings i I have all the sanitizers, all of these things to try and give me a safe mode light.

But Rust has it kind of as the default, which is like a huge, huge, huge boon to Rust. And so one of the things that Rust has is the borrow checker. And this is like a technology, a relatively novel to my knowledge. I don't know where it came from. Maybe a research that was done just for the rust language but it is a way for the compiler to track in the type system the kinds of references that objects have and so you can pass an object to some other function by reference and the contract there is that the lifetime of the object

from the parser to the parsee um the lifetime of the uh the caller effectively has to be longer than the lifetime of the callee right the callee can't hang on to it unlike say in c++ where you could just go oh thank you for passing a pointer to me i'm going to store it in a in a member variable now inside my class like that would be an error in rust because it's like no no no i can't prove now that you aren't going to live longer than the person who called you so you can't do that and there are ways and means of explaining when it's okay one of the ways it's okay is like actually i'm not passing you the value i'm not giving you a copy of a reference to the value i am giving you the ownership of that value it It's yours now.

I can't see it anymore. I can't use it anymore. And now you have it. And now, again, that's fine. That's safe there. The lifetime now lives with you. And I can't see anyone. That's great. And there are all sorts of ways of dealing with mutability and non-mutability. So you can pass multiple references to multiple objects for an object that are read-only if the compiler can prove that the caller, again, has a longer lifespan than all of the things that it's passed to. But you can only pass out one mutable reference, and you can't have any read-only references at that point. So kind of a bit like um i suppose like

locking you know you're optimistic read locking you know everyone gets gets a read locker lock but the writer's lock uh requires all the readers to go away and then you are uniquely the person with the reference to that object and that's done again in the type system which is really really clever because it means that there's a category of bug that you just can't write you can't express it exactly as you were saying with right the test that you're writing um any test that says am i using the am i there's the lifetime of this object okay is moved because it just won't compile if it's not right yes exactly and that's amazing and powerful but because programs are complicated and obviously it is in general impossible to determine the flow of a program statically.

There are limitations of what the borrow checker can do in code. And that also takes a while. It's part of the reason that the compilation process is a little slower is it's going to do this kind of tracking. So that's my experiences with Rust was trying to explain to the borrow checker what i was doing was okay and then more recently i wrote a little command line tool to replace like 25 lines of python and it was about 25 lines of rust and it just worked and it was really easy um i found it quite like the the command line parsing library was was there and easy and we should say rust has an amazing community of of libraries that are easy

to install using cargo which is like the one size fits all yeah executable that is like build the code download the dependencies um package the code send the code up to um to be shared it's just great and it it does everything the right the right way by my own personal biases of how things should be done yeah yeah so um yeah that was a really good experience writing a little command line tool and as a pleasant surprise to me almost everything that is built by default is statically built bundled into the executable the resulting executable so as long as you have a somewhat contemporary libc and a couple of other like very core libraries that you're likely to have in your on your system

you can pretty much just copy that executable around and that was exactly the use case that we had um was to give be able to give people a little you know small binary that they can just run and get um a simple output it was just a like a log parser and that was great so that was a great experience i like that yeah i so that was a great experience i like that yeah i dig that model a lot i mean that's part of the reason i i think we've talked before on the podcast about like i've never taught myself go because i feel like someone should pay me to do it because it's just so useful for that category of problem that i i just know at some point in the future i'm gonna have to do that and i'm just like ah i'll do that on the clock yeah yeah go was it go was the sweet spot

for me before yeah and then actually so recently i hit an issue where i had um in fact people can't see this obviously on the podcast but behind me i have a little scrolly device it's like a physical device i plug in and it has uh 64 by 32 leds or like that, maybe a bit more than that. And I can put arbitrary scrolling pictures on there. And it just literally, they're animating GIFs I can post to a web server and it ends up on there. And so I have stats and things like that that appear on it. And it's great. It's fun. It's called a tidbit. You can still buy them, but they're more expensive than you think. But anyway, the little program that you can run to like write a

little script to push particular images to it that provides you know like here's a a framework for doing scroll texts and wipes and all that kind of stuff it's um it's written in go and so it's just a binary they say hey yeah just download this binary and so you do and you get it and that's great and i'm you know in my mind go binaries are just statical static statical god go binaries are just static executables you run and they just work everywhere right as long as you're on the right architecture and roughly the right operating system you're great but this was not true um for this particular thing it was linking with like lib web p which is some the logical successor to animating gifs is the webp format and that was dynamically loaded it just so happened that i had it on my system so it worked but i upgraded my

operating system and it no longer worked and i actually actually go and download it and build it from source so that i could get it working again i'm like this is not what i expected of you go what happened and maybe it's just a mistake on the part of the people who who packaged the uh the system but i i had never experienced this before so it obviously can happen and then actually i ran ldd on a few um binaries that go and i realized they are actually dynamically linking with something so it's it's more like the same as rust in this instance so maybe rust and go are equivalent in this, which is great if there are choices. Yeah. Yeah, kind of, you know,

reflecting back on what you were saying about the borrow checker and how it works and how it's sort of safeguarding things for you, I really felt, and I don't like this, but this is on me. When I was working in Rust, I have distinct memories of feeling feeling like I was just, you know, driving down the street,

bouncing off the guardrails because I didn't really fully understand what was going on. And I was just trying, basically just being empirical and experimental with the compiler to figure out, like try to figure out like what the the language was trying to do and what i was trying to tell the compiler to do this is like um the sort of like the c programmers you know someone who's new to c programming and putting ampersands and stars in

until they get the value out from the pointer or not pointer or do you need a pointer to a pointer i don't understand your star No, that didn't compile. Kind of feel for it. You know, like, do I need to make a ref of this? Do I need to box or unbox it? Which of these magical things do I need to do to make it get to the next thing? And what did I really say when I'm saying that? Yeah.

Is that not true in most languages, though? Well, I mean, it can be true in any language. But anytime I'm in that state, it just feels icky right like i feel like i'm just i'm i'm literally making it up as i go along which is not the kind of thing that i want to do and so it was it was hard for me um and maybe this is because more about not rust in particular but just the sort of programming style because you know like i said i i had done some scala before but i kind of got a little bit of that vibe in Scala 2, not nearly as bad.

So it's maybe just like that programming style in my brain just don't fit, or maybe I just haven't done enough of it. I don't know what. But it just sort of like, I really don't like a world where I'm like, all right, I wrote a bunch of code. Let's see what happens, right? Like, there's always a little bit of that. Of course.

I'm not going to make the assumption that I did this right, but I at least want to have some level of confidence that, like, I'm attempting to do the thing that I'm trying to do, and I'm not just basically just, just you know voodoo chicken coding where i'm like just like i don't know programming by coincidence like yeah right right in fairness though yeah i think there is a little of that in anything you do and if you were in the middle of a novel code base as well the it's exempt uh you know it's exacerbated by the fact that you not only didn't know the language you didn't know that maybe someone had made a call that wasn't

necessarily the right call about how something should be done and then you were suffering the consequences of it you know you get to that point where you can have a strong opinion about like this is just being done wrong and that's why i can't do this thing that should be obvious right so maybe a bit of that in there plus i think there's just that mastery feeling and if you've been working in languages for a while that you feel you've mastered, you know, if you can bang out 20 lines of code and know that it will compile and run and be probably right, you know, that's, that's, you'd realize you're in that, that, that sort of level of expertise. And then it's kind of difficult to go back and very frustrating to be in a situation where you aren't able to just do that. Yeah. So maybe anyway but but yeah overall i mean i loved cargo i love the ecosystem i love the theory behind the language um you know i i haven't found a problem yet where i'm like the right answer to this is rust but you know as you were pointing out about go maybe

maybe that's the language i should be thinking about when i do next time you want a little command line thing i need i need something command lining let's just need to like copy somewhere and have it work and run on like a bunch of computers that's it's not you could go far far wrong right so who do we know who is using rust because famously mozilla have sort of backed away from it and the rust foundation was born separate from mozilla have sort of backed away from it and the rust foundation was born separate from mozilla to sort of carry on the torch of um of the language um the only people i know of that are seriously involved in rust are some some acquaintances and pals at um at amazon who um amazon picked up quite a lot number uh of the

the rust core team after the mozilla um announcement that they were not continuing with it and um i mean to me that makes some level of sense i mean uh amazon want to hedge their bets for a lot of different use cases and so one of the many languages they support or could support is rust and so maybe they're looking in that support or could support is rust and so maybe they're looking in that particular direction i don't know but um what who else is using rust but you know everyone everyone knows someone who wants to use it and it's like oh for my next project i might use rust but no one i know is actually writing it that much uh i'm googling something real quick because i remember from when i was looking at this more deeply, there was a guy that was way into Rust for embedded software.

Oh, neat. And I'm trying to remember this person's name. And Google is failing me here. But that was an area that I thought... Like, he had gotten the Rust compiler working on these little ARM chips and

I really want to track this guy down. Maybe I'll see it. Maybe if I can find this and I'll just put it in the show notes. Put it in the show notes if we find it. Yeah. It was really interesting. This was the classic example of like,

wow, this is a solution that I really wish I had a problem for. Right. Because this stuff looks so interesting, but it's just like I don't know how I would use this right now. I got a drawer full of things that look like that just right down here, various things. Oh, this would be cool, and then never got anywhere with it. Yeah, yeah, yeah.

So, yeah, I'll track that down and put it in the show notes. But there was a guy, one person in particular, who was just, like, very committed to this and, like, trying to put it on as many platforms as he could get. Like embedded systems and, like, tiny systems, because it's a native thing, it has no runtime, it's kind of a sweet spot for this kind of thing. Right, and the guarantees that it provides, you know i mean nothing's more terrifying to me than the idea of i mean block

blockchain smart contracts also have this property and they are equally terrifying where it's like i'm gonna write this code and i'm gonna put it out in the world and there's no take backsies right like this is it this is it it's gonna to be out there and it's got to be right yeah yeah yeah yeah that's an interesting one yes um rust has you know a lot of i'll be a lot more patient with the slow compiler if i'm in that in that situation if you're like yeah writing an embedded system for a brake microcontroller in a car or something but yeah that's different i mean they're already yeah those folks are already in the world of like writing miseric C which is like a subset of yeah things in C so maybe yeah Rust could take over from there but i guess actually we're talking of things that are using it that

we know of obviously then you mentioned blockchain type stuff so the the ethereum node that you were writing uh modifying was obviously Rust is there other aspects of in the crypto world perhaps or is it got more traction in crypto than somewhere else not that i am aware of i'm trying to remember the name of that ethereum node parody parody is the name of the ethereum node um and parity p-a-R-I-T-Y. P-A-R-I-T-Y, yes. Not parity as in like a parrot. Right. Or parity like Weird Al Yankovic. Right. Oh, yeah. You Americans and your unclear diction.

Uh-huh. You want some water? Oh! Actually, the D out of water. Yeah, you know, looking at parity. Parity might not be be alive anymore i'm sort of looking at all right but it was a project that was around at least at some point in russ yeah absolutely so yeah i don't know if there's other places in in the crypto world that uses it but russ sort of has the always the bridesmaid, never the bride kind of feel to it. Everyone likes, wants to, it's the language you want to kind of look at next. But if we just get that one cool problem, we'll fit it.

And, you know, we haven't quite got there yet, except for like a little log parser in my case. And some now defunct Ethereum node. Blockchain software, yes, exactly. Exactly. Well, before we further show up our ignorance, really, as to the current state of Rust, maybe we should leave it there with that. Yeah, this is what I'm hoping we get a lot of, you know,

Twitter responses and people being like, oh, it's used here, it's used here. Yeah, that would be cool. I mean, maybe that would push us over the edge as well of using it ourselves in our day job, because I think that's where it really starts to matter, isn't it? It's where someone will pay you to do that work, that would push us over the edge as well of like uh of using it ourselves in our day job because i think that's where it really starts to matter isn't it is where someone will pay you to do that work is when something becomes uh worth talking about at least obviously obviously learning it

for your own sake is also very much worthwhile i mean i was writing javascript long before someone was paying me to write javascript but but um it definitely helps justify the investment of time to learn something if it's your primary or a primary responsibility I mean because then you get to do it every day right and it's like you get better at something cool well all right you want to call it

there let's call it there all right until next time my friend until next time you've been listening to Until next time. That's at T-W-O-S-C-P.