Rust Programming Language Rust and Tell Berlin, 27 May 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Rust & Tell - May 2021

Description

All Details: https://berline.rs/2021/05/25/rust-and-tell.html

00:00 Introduction
04:13 Tim McNamara - 5 Traits for Beginners to Learn
33:12 Senyo Simpson - Ergonomic error handling in Rust
58:53 Konstantin Wünscher & Blas Rodriguez - Building a cryptocurrency derivative exchange with Rust

A

Good evening, good afternoon, depending on good morning as well, depending on where you are on the planet and thanks to our speakers today, uh this is another roast until day. So, uh just like we usually do. I will go and introduce myself so me as the co-organizer here with jannery, uh I'm a rust station from guinea republic of guinea, that is in west africa, and I currently work as a ros developer for a company called quick with develop.

A

We are developing a search engine, big by object, storage, and we are also the company behind tv, which is a rust search library. So, if you have time you can probably check on github uh what stan tv is and what it can do if you are interested or if you need search functionality.

A

So this meet up has a lot of support from jan eric and bastian and ryan david.

A

And this meetup is intended from for beginners level to expert level. We are here to share our struggles, ideas and hacks and projects, so rosten kelly is a space for the community to learn and grow together, and we expect you to also participate and help us in any way, especially through speak coming out and speaking here. At this meeting we follow the code of conduct from berlin, and if you have more info on it, you can go to berlin code of conduct.com.

A

If you see anything inappropriate, you can probably you can privately or directly report to us me via email or our twitter, handle or yannick or via email the same or his twitter.

A

So this is an online meetup, so we have it available here on zoom and then we also have the zoom chat. Where you can post your questions. uh We currently have three talks between those talks. After the second talks, mostly, we will hold breakout rooms.

A

This is uh an opportunity for every participant to talk to each other and then synchronize with each other, and it will last 20 15 minutes and after that you can come back for the last stop if you will be randomly assigned to break up rooms so if, for instance, your room is becomes empty before the end of the 15 minutes, you can come back onto the main room and we will always be able to assign it to another home.

A

We also have matrix charts available and where you can post your question and then this is live stream on youtube, as well as on our website. Again. As a reminder, you can type your question here on the chat or you can post it on matrix chat.

A

Another thing we really care about is that we want you to come in and speak at this meet up. We always have three spots, so we expect you and we feel like this- is a good place to to share your knowledge. Your experience on any level there you have with rust.

A

So today we have three talks.

A

And the first one will be from team five tracks for beginners to to learn rust.

A

Tim is a software developer, a data scientist, an artist and a technology writer, and he is the author of the famous roster in action book.

A

The second talk will be ergonomic error handling and the third one will be building cryptocurrency derivative exchange with rust. So without further ado, let's start with team.

B

B

Wonderful, okay, thanks very much for the introduction. It was very kind I'll just share my screen, so uh there should be a big white um box in front of you now perfect. um How does one start these things stronger.

B

Or something like that I uh used to be, I used to be able to speak german uh these days, um not so much, but um I miss berlin very much, um I'm currently speaking to you from new zealand. uh If I make mistakes, please accept my apologies. It's currently five past or seven past five a.m.

B

Here in wellington, okay, cool: where do we go? We are going to be doing a beginner talk today and uh like normal. We start these things with a bit of an introduction about who I am. I am a. I see myself as a as a mentor in the rus community. Follow me on twitter, youtube and twitch, for um I organized the russ wellington meetup group. Luckily, we are covered free here in new zealand.

B

um We haven't had any cases, I think for well over six months now so um yeah, it's actually an in-person meetup, which is interesting. uh As you once said. I am the author of rust in action uh day-to-day I do data science. um Actually, I am particularly focused on data engineering and at a small consultancy. Well, actually, large consultancy called dragonfly data science here in wellington.

B

Okay, about the talk, I want to reiterate. uh One thing to emphasize is that these are not the most common traits. um This talk is designed to inform you about how rust uh feels like as a programming language or how it is implemented, and so my intention is to be able, if you have only used java or c-sharp or python or javascript, to be able to understand a little bit but you're having difficulty with rust.

B

My intention is for you to be able to get an understanding for what's happening inside rust and traits are essential to how it operates so for those people who don't like listening to long talks, they have a 20 second version.

B

Partial equality is the trait is a the trait that relates to the equality operator. All operators are implemented with, or are defined by traits display is how you ask a type to convert itself to a string so that it can be printed to the console. Clone is a way, a mechanism for being able, as from the beginner's perspective, to avoid the borrow checker.

B

While you are understanding or taking the time to learn ownership, the iterator trait is how is one of the the first steps for being able to really understand how rust is um slightly different from other programming languages or its peer languages in particular, sort of c plus- and this provides us very, very ergonomic or very friendly way of using a for loop for any collection.

B

Drf. Is this ability for the dot operator so method calls to be able to automatically uh call methods that you can drift into, and that sounds very confusing, but it basically allows uh if your type can dereference itself to become another type. You can call the target types methods from the from the parent type itself. So that's the 22nd version, probably a bit more than 20 seconds.

B

If you have started with rust um or you're, just um just very, very new, a a struct is just a type which can uh be composed of multiple objects, so um it isn't the same as a class, but it's very similar, but you can think of a as a like a plain object, so we create them with um so here I'm defining. Oh sorry, it's saying that I this ignore, ignore this error. It's saying that I it doesn't know how to um the.

B

I can fix that.

B

uh I can define a cube and also create one, uh but there are no methods attached to this struct. Okay, and the other thing that I want to just spend 10 seconds talking about is the notion of a bit pattern, and this will become important when I describe uh something about floating point and it turns out that a well just the term bit pattern means a sequence of bits that represent a type.

B

uh It is the rep. The internal representation for every type is a at some stage, turns into a sequence of zeros and ones, and that's what I mean by the term bit pattern. Okay, so now we are ready to talk about what a trait is uh traits are the foundation for all behavior inside rust and it's the foundation for all behavior that is shared between types. So, if you have all floating point, numbers or all integers behave in a similar way, even though they are different types and that is enabled through traits.

B

You can think of traits as being an abstract bass, class or an interface, um if that might be helpful if you're from an object, orientated object-oriented language, so almost all of rust is actually built with traits operators methods. The generic system is, uh and trade objects are all uh connected to traits in some way.

B

So, for example, you know, as I mentioned, addition is related. It's defined by this trait, which is standard, ops, add.

B

So, for example, I can define a so I can import to the trait add, and if we ignore what we say is it I can this triple function will work with any type t that implements add and out in the output of the edition is the same type, oh, and by the way it must be copy, which means that type t will copy itself instead of basically duplicate itself, if it needs to if it was going to encounter any borrow problems and what happens uh if I you know, we've seen rust generics um before so I can call triple with a floating point number or I could call it with an integer.

B

And it will quote unquote just work, which means that I have to find one function in source code and use traits to be able to uh specify that it must be a type that implements addition. But for some some types, don't well many types, don't implement addition, and so you cannot add a string size to another string slice and the type system will protect you from doing things that are illegal and it's all enabled by traits. So how do we define them?

B

A trait uh in this case, movement is defined by a set of methods and the distinguishing characteristic. They look a lot like a class without any data and structs look a lot like a class without any methods, and so I've got the struct here with node members. So it's just a what we call a zero size type and I've and a sentinel in english is just a thing that never moves so just to find movement here, sentinel and uh but a cannonball, let's say implements movement.

B

It can't change its direction once it's fired, and so, uh if it's in the air it can only change its speed, let's say, and so um the trait system does not impose any more restrictions. Apart from the type it can be a little bit more sophisticated we've, not we saw the output thing, but in general, um if you define a trait you're free to implement it. However, you want, with whatever type that you have.

B

This was a little bit confusing to me, because uh I sort of thought that trac, that these definitions were slightly more magical, that if I had a trait like movement, that I would expect it to always be moving, but actually it turns out that you can implement it just with with um with doing nothing, hopefully.

C

B

Sense: okay, right uh one distinguishing characteristic is that traits do not have data, so we can't say that the trait movement requires that the type it's has a speed attribute and a direction attribute. um It doesn't make sense from rust. uh Traits only relate to methods. Okay. So now we get to our first trait that we want to discuss for beginners clone and the reason why I think this is first is that if you're a beginner I want you know, have you ever seen this use of mood, value or something related?

B

I I feel that uh it's okay to spend a little bit of time at runtime cloning values if you're spending hours and hours and hours learning rust.

B

So this is this is my example. So I have this func a function, save which uh is supposed to save an object, or this is this vector of uh integers to disk, let's say, and so here's here's my list of my event vector of numbers, and I try and save it once, and so this is just a read, only method, and then I mutate or modify the value.

B

I add two extra elements and then I save it again so rust when you start will give you this horrible error and it turns out that one way to fix this is by asking for a read only or what we uh like a. uh We can take a reference to it, but another way to do it. While you learn it's complicated, so we can we've got this shortcut, which is, we can add a clone method.

B

Clone will duplicate all the values, and this one will, uh I hope, work correctly, and in this case it actually does so I'll. Just do that once more.

B

Oh okay, so now I'm getting a different one, because, oh so just the way that the execution environment, it's already diff, it's already used save, and so it thinks that the last call that I just executed is still present. So I can create a new variable and that might work.

B

uh In fact, I can't do it there either because save I'll need to clone it twice. If I want to print it out.

B

um Oh gosh, tada.

D

B

I should stop playing. How do I implement clone, uh so this is at the cheap way, so I've got these three structures, uh sorry three types and I need to implement phone for them. So how do I do so? um In particular, I want to I really care about this meeting thing. You actually saw me.

B

You know using this a derive attribute earlier, which is a request to the compiler to implement things on our behalf.

B

And now it that's, that's it whenever your many types in the standard library already know how to clone themselves, and so, if you have a a a struct that only includes members that already know how to clone themselves, which is the majority of your of uh the majority of cases when you're starting out, then you just need to derive clone, and then you will have access to a clone method, which is quite handy.

B

Okay, partial equality.

B

All operators are defined as traits, and you.

D

B

We take two values left and right and we return a boolean result, and so that's fine, um but the question is: why is it partial like that sounds very strange, and the reason is that rust tries very hard to get things right or model the environment model reality as quick as accurately as possible. Rust is very precise. It is a systems, programming language, which means that it really cares about details.

B

So floating points um take a bit pattern. You can see here that we have two floating point numbers with different bit patterns, this one's zero and this one's you know 2 to the 32 minus 1. and they both uh evaluate as true so there's two bit patterns that are not the same. That evaluate is true, and we have here the same bit pattern on both sides and if we try equality, they evaluate as false, and so you may, if you haven't encountered this behavior, it might be worthwhile.

B

Just for me, pausing to explain what's actually happening. um Floating point has a uh so I'll. Just cheat a little bit has the notion of a negative zero.

B

So this is zero, with the sign that uh assigned uh signed it flipped, and so both zero uh and negative, zero evaluate to uh are the same uh numeric value, and so they evaluates evaluate to to true when for equality. Now this one here. So that's that first example. um The bit pattern is a bit sneaky.

D

B

So, by the way just to prove to you, this is a oh. No, I shouldn't order 60, so f32.

B

uh Nan, so what the heck is that.

B

Floating point has a representation for, uh in fact, many many bit patterns that evaluate to ex result from expressions that are mathematically undefined, so, for example, division by zero um is one of the or like division by infinity, for example, um and so the partial equality exists for floating point.

B

Because of these very strange um circumstances- and this is what I mean by what one of the things that to understand about rust- is that it is pedantic and precise um okay display display is very, very practical, because one of the first things that you want to do when you start out with programming is a is print things to the console.

B

uh And one thing to note, however, is that display is different from debug oopsie. Let's mark down um the debug tray is intended for programmers, whereas display is the trait that you will use. If you want a string for users now, there is also a subtle link to error handling.

B

But let's ignore that so ich been in berliner um relies on the. If I want to print that to the screen I uh use the display trait and the syntax uh here uses the debug, which is the programmer specific representation.

B

So this uh question mark is debug and just um curly braces is display. Now how does one implement display?

B

So I've got a place, let's say a city, let's change it to city that has a location uh represented as a coordinate and a and a city name, and then I want to.

B

Implement display for city, so I need to implement a I bring the trait into local scope, and this it includes one method which takes the strange type formatter with a kind of anonymous lifetime, and and the easiest way to implement display is to find some member of your type that already implements display and and to just use that rely on rely on that member.

B

So, for example, let's say I'm only relying on the on the name attribute, I'm actually ignoring coordinate for the purposes of display. Excuse me conflicting implementations.

B

uh That's a bit strange. I wonder if this is a problem, I think I pushed enter twice.

B

And so I'm actually not sure where berlin berliners, but if.

B

I said that you know what it would just say: none now, because that's easy, it's off the west africa um and then I want to print.

B

B

B

Oh, I expected it.

B

Let's see, uh it's all gone wrong.

B

Okay, there we are city, builder cool. That's me implementing display. Okay drift drift is quite special. It allows types to become other types and if you encounter any confusing behavior with rust, this may actually explain why rust supports a notion of a.

B

Auto drif and so for smart pointer types, dref provides access to the inner type. Here we have a box of a string slice and the drf operator, which is the star thing, actually returns the the string size itself. So I say this is the right. You know text is the wrong type. It is a box, but we've asked for a string slice and I can use the d reference operator to access what's inside it, but more momentarily it will actually the dot operator, which is the method.

B

How we call methods in rust will automatically derive things if the target type supports the method. So, for example, I've got this platooch string here on one line and um I still live in north germany. So maybe that's a dumb joke. Okay anyway, uh so string does not implement make s key uppercase, uh but string slices do occasionally. You will encounter some kind of counter-intuitive syntax.

B

So you see the d reference operator followed by the reference operator and then type t. uh This looks like it should do nothing. They should effectively cancel each other out. um But what is happening here is that the we're taking a reference to t and that type uh the referent might implement something else with drif, and so it isn't purely working uh if you've only used pointers before um just remember that rust is doing something more when it dereferences values.

B

It's actually relying on the trade implementation and every trait uh every type can define exactly what it means by every trait. uh So just as we had movement for sentinel did not actually move the sentinel. Here we have a dereference operator which isn't actually dereferencing a pointer. It's just doing some conversion, uh so here's some syntax, oh so. Here's some some wording from the rust reference. Just saying that on non-pointed types uh star x is equivalent to star of d reference of reference to x, so yeah I'll. Just leave that.

B

Actually, the last chat that I wanted to talk. I think this is the last one um is iterator, so it enables us to go through four loops and that's nice. um So one one question is: how do we uh we want to be able to implement? um We want to be able to create a year from season, and so how do I do so?

B

um Well, I start with I've got the the way to implement iterator is to create a like sister type, a type that it lives alongside. If I've already got one implementation excuse me, and this has already been evaluated evaluated so.

B

Oh man gosh. This did work just before when I was testing it. That's really perfect.

B

Excuse me I'll go back.

B

I should maybe so I've got now. I've got a year method on season, I'll go back to defining, describing what's happening here. So in current season I yield every iteration. I return an item which is the season type, so kind of like the sister.

B

This is the internal part of season and uh every iteration. I check like what follows summer. Well, that's autumn, and what follows autumn winter, and then I mutate the internal state and I return uh the the next. um I return the next item and I apologize for this just stuff at the bottom.

B

It's just because I implemented twice, and so the other thing that I need to do is tell season that, on the inter into ita method, that I should convert myself to the sister trait sorry, the sister type, and so what is happening in a for loop is that the for loop is actually iterating or calling a sister type of whatever you're iterating over so inside the definition of year.

B

We are asking season to call into iterator or into it, and then that is being used to create an iterator, okay cool right. uh I don't know if we have any extra time. I think I'm about at 20 minutes um sometimes trades have nothing. No, no time. uh Sorry, no methods and they're called markers, and my favorite implementation is assisted member drop, which is just defined for every type. um There is actually no no contents at all. I think this is my like.

B

So what's actually uh what's actually happening is that drop like drf acts as an operator implicitly and we'll just uh call call the drop method on on the type when it ends when it ends this? uh It's scope. Okay and I'm finished thanks very much, um I'm more than happy to receive questions. Hopefully you enjoyed the talk.

B

A

Right, thank you tim. I think we have a few questions like grace talk. uh The question is: is that a jupiter notebook used for the rust code.

B

A

It is actually.

B

A jupiter notebook being used for us, so there is a rust kernel for the jupiter notebook.

B

So if you search for rust, kernel, jupiter.

B

You will find it, I can also post the link and I can they're.

B

It's got a very strange name.

B

I'm just searching for it now: jobs executed the end of scopes. Oh sorry, oh sorry, I just saw the the the problem with the font. I apologize young eric. um I probably should have um yeah made that question so.

E

um Yeah: okay, thanks.

B

um David david has just posted a link to the rust kernel, which is in the google namespace under under github.

B

B

The other tool that I was using for turning it into a presentation is, it's called rise. Slideshow.

B

And I can give you the link to that. Also.

B

um So I apologize if the if, if the text was too small, hopefully things are still legible.

A

Yeah, it's all right.

A

I don't see any other questions for now. If you have questions please just post it.

B

A

A

All right so with that, thank you, tim and if they are for a question, probably you can check on the chat and we'll move on to the next. Oh, that's going to be given by.

A

Senior and he's going to be talking about uh ergonomic error handling in ros senior is a software engineer with focus on infrastructure before that he worked as a data scientist building computer vision model. So currently he lives in cape town and he works for a startup and building the next generation of smart technologies. For agriculture senior talk to you.

C

C

Awesome, thank you, evans for the introduction, uh yeah cool very excited for this um yeah.

C

So my talk is on ergonomic error handling the thrust so just a kind of like overview of where we're going so uh yeah, initially just an overview of error, handling and rust um kind of like yeah, just how it works, and the mechanics and for the veterans will probably be pretty standard and boring and then going on to like making uh error handling ergonomic and how yeah rust just tries to make the whole process um ergonomic and then going on to making areas informative and then just the future of error, reporting and- and you know what that kind of like, uh where we're going with with error reporting.

C

D

C

Evan's already introduced me, but yeah, I'm a software engineer. I work on the platform team at aerobotics, so yeah working with infrastructure and we're an agritech startup uh based in cape town, south africa and passionate about technology and how we can leverage it to improve the world around us. um Iraq, semi sent me regularly at senior simpson.com.

E

C

You can find me on twitter uh posting annoying tweets at saint jesus. um This is just a picture of cape town. I just thought I'd show everyone what it what it.

D

C

This is a sunset at one of the places we call sunset rock um yeah, I'm sure all the europeans are jealous awesome so getting into it. Why is error handling important, um so yeah? The most important uh thing I want to just emphasize through this talk and like the biggest takeaway, is that error handling um is really just about communication um and yeah, just being able to communicate to developers uh what's going on. You know why it happened where it happened, etcetera, etcetera,.

D

um It's really just about.

C

That communication, um but some other things are important, so it prevents undefined behavior. So we don't want our programs to continue executing um if they're you know in.

D

C

Valid states or ill-defined.

D

C

um Provides context to failure mode, so this is just again about communication.

E

C

The requisite information and makes developers advocate who doesn't want happy days cool so how rust does error handling um rust, has no exceptions um and instead, uh errors are returned. So it's similar to golang that not paradigm and it takes in inspiration from the immo family of language- is so different from curling and adapts and adopts the result type for handling recovery errors which I'll talk through um later in the slides um and yeah irrecoverable errors are signaled using panic again, which I'll go through so recoverable errors.

C

These are obviously areas that we know how to handle, um and you know in in the course of uh program execution we kind of like uh come across circumstances which we know what to do and how to handle them correctly. So a.

B

Good example, for instance, here.

C

Is you know if you want to read a file um and.

B

D

Have any expectation.

C

On that file existing that's an area that we know how to add, so um the result type is is, is how we sort of like denote, fallible, computation um or variable functions in this case. So a result, types in enum which has two variants: okay and error.

C

If the computation succeeds, it returns or it contains the value from that computation. Otherwise it contains an error, and this is really it's nice and super beneficial, because we get a quick view into the fact that, like a function, is fallible just from the function signature, so you know again just about communication um and we're easily able to tell like okay. You know if I run this function, I'll have to handle the error if it crops up um and then again it also forces us to to handle those errors.

C

um Awesome so just like an example of using results, so we create this file, um ferrous dot text and that returns a result file. Obviously you can succeed, otherwise, result error and then we have to unwrap the result to get the the um the value in the in the result.

C

So in this case we can use um uh sorry. So in this case, we can obviously use match, um and so, if it's okay, then we return the file or we assign the file to the variable. Otherwise, in this case, we just panic um if there's an error code and then similarly one um and the last thing that result allows us to do- is to bubble errors, and so just walking through that so oftentimes.

C

We don't want to handle the error where it's incumbent, because we don't have like full scope and full knowledge of what we're trying to do when we're trying to achieve, and we also don't have context in those situations, and so instead you want to propagate the error to the caller so um and then the caller implements logic to handle the error as required, so the caller has obviously um full scope and knowledge of what's going on and can decide you know in this context, I want to handle this area in.

D

This way, and in.

C

Another context I want to handle it in a different way, for instance, um and so yeah. The important thing is to be able to propagate those areas back to the chord, and so we can do this quite easily. um So here we see we have this function in it, which has a results with the unit type and an error, and then, when we're creating this file, so we obviously match them on the result type. If it's okay, we assign file to the variable. Otherwise um we return an error. So we have like this early return.

C

That says now encounter this area, I'm returning it back to the caller and the caller can then implement any logic to handle it, and so similarly here and then at the bottom. uh We have this. We can kind of think about this as the call of the function, some executable code and yeah we're just matching on this function call, and so in this case I mean it's obviously super trivial. But uh if it's okay, then you do.

E

C

And if it's, if there's an error, then we panic and say it could not initialize in this situation, so irrecoverable errors so irrecoverable errors are obviously errors that we can't recover from and those tend to happen like when we encounter bugs so we'll come across situations where, basically, what we're saying is that hey? I don't know how to handle the situation, um and I think that the best approach is to stop uh combat execution and that again is important for cases where you want to, for instance, um just stopping valid states from occurring cool.

C

So this is an example that I've obviously shown before in previous images, where in this case, we routing to a file saying hey ferris, and if it's okay do nothing, but in this error branch we panic, and so when we panic the program crashes at that point in time and just says you know, there's nothing there's nothing further. I can do here um so cool. That's just like a quick overview of uh yeah, just error, handling and rust level, and so yeah making it ergonomic rust, really emphasizes language ergonomics.

C

I think it's one of the first things that I quite like picked up just from the community and when I started learning rust- um and this is- and this is obviously great so in.

D

C

In the sense or in the case of errors and this, the ergonomics come from having several convenience methods or syntax to reduce error handling boilerplate.

C

So an example of this is the tri operator, so try so for bubbling errors. uh It requires boilerplate due to that matching syntax. So we have to go like you know. If uh you you.

D

C

And then, if the result is okay, then you're signing.

D

C

You return the error and rust so introduced the tri operator or the question mark operator as I like to call it um as a solution to this to reduce the bullet plate. So in this case you know we have the match the matching syntax, and this is without trying or without the top rated phone and um yeah. You know similar thing. So if it's okay, we assign that file. Otherwise we return here.

C

So we can simplify this by using the straw operator, um and here we have file create, and then we have appended the question mark at the end, and so these two are functionally the same, achieve the same goal. um And so, if uh you know, if the function uh succeeds, then the variables assign and execution continues. Otherwise, the error is returned. Early, basically unwrap is quite similar, so the same principle can be applied to panic where we, you can reduce the amount of boilerplate that we write and it's achieved through the unranked function.

C

In this case, yeah, obviously it'll automatically panic. If an error is returned, so here we have this in it function and on the file create call. We uh we call this function, dot unwrap and that will basically fail if the if an error occurs. Otherwise um execution will continue, um and so in this case, for instance, you know we, we tried to write to a file and they didn't have permission to, and so you know panicked and the program crashed.

C

So those are like some small things and there's many more of them expect mapper and many others um yeah. I think like it's worth going over them uh and looking into them as you as you continue to write more and more rust. I certainly will, uh since I need a handful of them, um but it just shows like rust's commitment to ergonomics and really trying to make the language easy and fun to use and have a great developer experience so making informative. um This section just really ties in back to communication. So again, error.

D

C

Is all about communicating um to developers? You know what's going on and so yeah just going through, that good areas are highly informative. um They improve developer experience, I mean I'm sure everyone has uh incarnate. Obviously, if you've been riding rust, you've encountered the rust, compiler and oftentimes. um You know it's just the best in class in terms of like the error reporting, that's that's given and it's a it's such a huge quality of life improvement, and so that really improves the developed experience.

C

D

C

Debug issues much faster, I'm sure you've all been in situations where, like the error, you've gotten doesn't really point to. You know: what's really happened, or it's very opaque um and and doesn't really give you enough context, and you spend hours and hours and hours and hours trying to to debug an issue that would have just been solved way easier if you've got like a more informative error and so again talking about communication and of course, they make developers happy to make developers happy to get uh highly informative errors, but routing them so yeah.

C

When we're talking about uh informative areas, we've got to think about them in two types of ways like or in several ways when it comes to an application or library. So this just really has to do with how we structure um errors and the kind of like role they play in each in each case. So for a library um yeah, it's important to create meaningful custom error types. So this this is important, because obviously your application works in a certain domain and and failures are represented um within some certain domain.

C

So we want to really capture like areas that happen in that domain, with these custom error types um but and again being able to communicate to developers that these.

B

C

Kinds of errors happen in this sort of context that we're in um another thing is wrapping standard errors where necessary, um which allows applications to differentiate between various areas. So you can imagine, for instance, that if you have two crates crate, a and.

D

C

And they both uh produce io errors. For instance, you want to be able to differentiate uh if an I error came from crate, a or crate b, if they, because I errors are from the standard rb, for instance, and if they came from crate, a or crate b, and so we wrap them um in in our.

E

C

Types or our create specific error types uh so that we can differentiate for apps for applications. um Custom areas should always implement the error trade from the standard library.

C

This is just important because it allows compatibility within the ecosystem so before there was a popular crate, called failure which had its own trait fail, and it caused a lot of like compatibility issues at the application level when we're trying to stitch different uh libraries together um and so you're kind of like iterated and settled on always implementing the error trade from standard library and which just again improves the developer experience and then, ideally, um errors in a library should never panic um or library should never panic. It's it's kind of against.

C

You know what you would expect for a library call to like crash your program and so.

D

Instead, you would.

C

Want to return errors and the caller can enhance it. Applications are bit different, so in applications they consume errors and their task is to make informed decisions on how to handle those areas so they're at the level where they obviously are operating in the context that they're.

D

C

And and can decide how to handle certain situations depending on on obviously what's happening. uh They can panic uh so at the application level. You know if we come to a scenario that we don't know how to handle. It's easy to say you know, raise hands and uh and and just panic and crash at that point and they're also responsible for deciding how errors and uh formatted and displayed to use so effectively like how they communicated to to the user.

C

So for an an application like adding context, is extremely important, so walking through that areas need to include the context in which they were generated. uh This provides developers, clarity on the error case and it improves our ability to discover and diagnose failure cases so um like. Obviously, this is the question of like what does that mean so just walking through an example, sort of situation. So in this first case we have this error, no such file directory, which is not extremely informative.

C

We don't really know you know where it came from or like where in the lab would like. When the code came from what file or directory it was whether it's a file or a directory, um and so we're kind of like left open-ended with the fact that we just know, we've got this. We try to do some eye operation, um but there's not too much to that. So we can improve that, for instance, by adding um you know the the file that we failed to read.

C

So in this case we get the error failed to read file which is fairest.txt, um and this was.

D

C

By this, uh no such file directory.

D

So, in this case,.

C

um Obviously, what's nice is that we're able to say you know which file uh we were trying to read and which one failed um and then in this in this case, we can augment this even more by adding, for instance, like a back trace just as an example, and so you know that again adds more context and information to uh to the error report in this case, and then we can think of other things like in this case, there's no location um in the code where this error occurred.

D

C

We can add something like that. um We could add a suggestion, for instance like create the file ferrous.txt, um and so you know in those in those cases we can keep thinking about how we can make these error reports or error messages way.

D

More informative.

C

At the application- and that adds context to what's happening so for a library, custom errors again are the most important thing again. That model like your domain.

D

C

And communicate exactly the kinds of areas that happen in your term, so just.

D

Walking through an example.

C

Again, um in this case, we're just using this area, which is a which is one of the commonly used crates in the rust ecosystem for creating like custom errors, um and in this case we have this beat maker error. So um some of the areas that we have is like invalid notes, invalid format and an invalid instrument, name whatever and then an interesting one here is that we can wrap all I o errors from the standard library and into like our own.

C

I o error type uh in in our beat maker era, and so that just speaks to again that that idea of wrapping errors so that we know that these.

D

C

Errors came from like the speed maker library, so uh this is yeah. This is just a simple trivial case of using um that error, so, in this function called raise, we have a result which returns it or can't have a beatmaker error, um and that's in this case just returned simply just for the sake of this, and here we just match on on that on that function call, and so, if it's okay, I mean write a data and then write a message and if it's an error, then we're too.

D

C

To write better errors, um so we get it um cool and then, uh in this case we have it for an io error. So what's really cool here um is that we can return an io error from in this case, like file.open or file open, um and this returns like an io from a standard library, but because.

D

C

Wrapped those errors, we can still return like a beatmaker, and so when we call this iras uh in this case, we haven't like taken any uh knowledge of that um into use. But we can. We will know that that sort of eye era came from beat maker um and that allows us to to basically handle that um like higher errors from different crates, quite easily um cool and so yeah wrapping up uh towards a better future.

C

So error reporting obviously can still be better. um As with pretty much everything in that uh and some ways you can kind of think about that is making masked lead error reports. So again, not the rust compiler areas of like really great area reports um and that's and that's like best in class and kind of like the the future that we're thinking about here. um Providing suggestions to resolve errors as well. So that's again something that the last compiler does and then just in general, like jane lesby's.

C

Air library is a experimental library that serves as a testbed for pushing the boundary on error reporting, um and so I'm just going to do like two sort of like error reports that come from that library, which are really cool in my opinion. So in this case um we have an error, and you know it's like it just describes: what's happened so unable to read the conflict and then command exited. So we get like an error uh messages.

C

Then we get the location, which is something that I mentioned earlier- that we can sort of like augment to our um error messages. So in this case we get this location. uh Then we get the the standard error error. So no such file directory we get a back trace, which is in this case really nicely formatted and then at the end we get a suggestion so try using a file that exits next time.

C

Obviously- um and that's really- that's really- nice gives a lot of context and a lot of information as to what happened um and kind of and kind of gives you, like all of the necessary uh pieces of information to go from their reports sorted out directly to fixing your error without having to do too much uh extra leg work, basically and then just another cool example here where in this case, we're chaining errors.

C

So multiple errors happened, um which is the first area that we got here and also gives us the location, and in this case, then we get these chains of error so that the task cannot be completed.

C

The machine's unreadable or unreachable. Sorry and the file could not be passed and um that's really cool. So now, we've got this like really informative, uh again, error report that kind of like walks through you know the.

E

C

The sequence of errors happened, and- and it's like nicely formatted and easy to read and again just reduces the amount of like extra network that you have to do to go from error report to debugging your issue and or fixing your issue so yeah. That's basically, that's basically it thank you um so yeah again, just the the main thing about uh this talk again, just highlighting that error.

E

C

Really is about communication and that that's the end goal um when we're writing errors and in our libraries and applications, is really just to be able to tell or communicate to other developers like this is exactly um what went wrong cool. Thank you.

A

Thank you senor. um We have a couple of questions coming up, so the first one is: how do you determine which error type e should be, whether it is an I o error or something else.

C

uh I'm not too sure. I understand the question too well, but I mean that that would come from you like. Obviously, if a certain function call um returns a certain error, then obviously you know that e is that error, otherwise you define them yourself um and then can handle that logic uh depending on what you've chosen. um I don't know if that answers the question well enough, but yeah.

A

All right, so the next question is, I try to use always expects. Instead of on wrap, do you use unwrapped? Often, do you have an adult heuristic to decide when to use expect or on rap.

C

So, for me, like I cut like and also I think, just pushed by the rust communities like unwrap usually is only used for sort of like prototyping or when you just you know when you think sort of like development, but ideally um you wouldn't you wouldn't use it ever really in production code. The only cases where I do know it's often used is uh when you don't expect something to occur and like there's pretty much like a guarantee, not even that you don't expect to go in, it should never occur or never does occur. Really.

C

So, if you have like a strong guarantee that this thing will always uh work, then you can just use tottenham, but in those cases I think using expect is probably better than unwrapped. Just in the event that something goes wrong um and then you do get like a uh at least some sort of like error message back basically,.

A

Cool yes, so on feedback. For the first question. Yes, it was already answered during the presentation and the.

D

A

We have so far is: do you have an opinion on the crate anyhow.

C

Oh yeah yeah, so I should have mentioned that that was my mistake, so this area is really good for um creating custom errors and that's like for the library context, context and anyhow is for like applications. So anyhow, that's also like another commonly used uh really like um great, I guess great use for application areas, and so that one obviously allows you to add like those with context and that runs at the application level. So when your application fails.

D

C

Any reason uh you get back a nice air report with your custom message and then whatever error happened, that's from your library, so of course yeah like I. I really advise using it cool.

A

All right, I think, uh that's all we have thank you senior for the presentation. That's all we have for the questions. Okay, so thank you. Everyone, the last talk for the night would be building cryptocurrency derivative exchange with rust, and this one will be given by constantine and blast. They are from collider.

A

Collider is the first real-time settled. Cryptocurrency derivative exchange using the bitcoin traders can instantly open or closed position without exposing themselves to excess contemporary risk or hefty transaction fees. So, yes, constant, 10, plus up to you.

E

Thanks evens, let me just share my.

E

Screen can everyone see my screen, appreciation, um sweet cool thanks evans for the introduction- um and this is pretty much more- a more applied talk about how rust is used in practice in a business sort of environment, um so yeah, I'm constantine, I'm the co-founder of collider and pretty much everything even said. We do it's not necessarily super important, because it's a lot of like jargon that he threw in, and I don't expect anyone to understand what he said, um and so the aim of this talk is basically to do.

E

You basically share our experience with uh russ our love hate experience, um because we have been used rust, sort of in production uh since pretty much day, one um and yeah. So the talk is on uh building a derivative exchange in rust and first thing I I want to say it doesn't matter whether it's a derivative or an equity or stock stock exchange. The basis is the same. So I don't want you to be confused about derivatives.

E

Basically, just forget it uh uh from now on um and also I don't assume any knowledge of what an exchange is. um You know, because I guess it's also very specific uh to finance. um So I'm just giving you a little primer on on what an exchange is and essentially what an exchange is. um It's pretty much just you know a database uh which we call the order book where buyers and sellers come together to make an exchange of any type of good uh could be.

E

You could be a stock, but it could be like apples or oranges. It doesn't really matter, but pretty much. You have a buy and a seller and one wants to basically buy apples. The other one wants to sell apples right.

E

So one wants to give the other person dollars, for example, and the other one wants to give apples four dollars, and this order book is pretty much um just a place where you know they come together and the the task of the exchanges is pretty much uh matching these buyers and sellers uh together so basically uh making the the price discovery of the of the um exchange and when it happens, um they match, and at that point the exchange or the the trade becomes finalized and the two parties um exchange sort of the goods uh whatever it is.

E

Apples oranges doesn't matter, and then at that point the exchange sort of gets a small cut from that transaction and we call exchange fees, and you know that is a very simple and beautiful business model, because you know the exchange always makes money because it doesn't matter whether prices go up or down. um They always take a small uh small cut of the money and you might be thinking now awesome. You know I could do that. You know I just set up a exchange, you know get copy trading.

E

You know it's awesome because you know it's it's a very bulletproof business model, but um uh you know um sorry that was actually uh I was. I jumped this slide ahead, but um yeah there's this. Basically this business model.

E

uh You know it attracts a lot of people, because it's so simple and beautiful in a way and that that's basically it's the reason why the cryptocurrency of markets is it's massive um and you know last year um it tops uh 3.5 trillion dollars in volume, which is basically saying that people traded 3.5 trillion dollars uh with each other, which is amazing in a way and that's just cryptocurrency so financial markets. um So traditional financial markets are not even included money.

E

What I was going to say is that you know this is great um in a way. You know everyone could just build an exchange and get people to trade, but you know the truth of the matter. Is it's quite hard actually and that's sort of what we experienced? You know sort of first-handed um and why is it hard? Well, you know, first of you really have to process a lot of messages uh when people, trade um and the whole process is really hard to parallelize.

E

um Just to give you an example of like a decent sort of like exchange, uh it's not even like a fast exchange. um You have to be able to process 1000 measures per second, um you have to sustain a capacity of 5 000 orders per second and you average trade latency, which means the the time it takes uh from uh submission of the order to response.

E

uh You know shouldn't take longer than three milliseconds uh and that's basically, wherever you are on the uh sort of in the world um and a lot of money is on the line uh which means um uh you're dealing with you know people's money, uh so you have precise, you have to be correct, you have to be deterministic and whatever you do uh just to give you a little example, uh the the five largest exchange and derivatives uh in crypto, uh they d, they process uh 200 billion dollars in um in transactions every day, um so yeah.

E

It is very small sort of um sort of a margin of error, uh and another thing is that you have to guarantee fairness, audibility and availability, and that's just to make sure you know people sort of come come back, because um you cannot allow people to queue, jump.

E

um You know front running, uh you have to be audible and that's because in every transaction needs to be sort of traceable, um that's again from from the from a regulation part, but also you know in instances where your your platform crashes, you have to basically be able to reverse every you know state in the system, and you have to be highly available uh with what means that you know this.

E

This platform has to run 24 7 um seven days a week uh and it can never go down because you know a second uh of sort of outage. That means you lose revenue um and you're constantly under attack, and that's because you know you are sort of a honey pot um you're dealing with a lot of money. You so have a lot of money and people try to either steal it from you or they try to um you know, gain your system.

E

You know, if there's a little bug in it, you can imagine um that you know a small. You know. A small bug in a small transaction um error can lead to like massive amounts of money. You know, if you repeat it like millions of times, and there are many stories about about these- these problems um so yeah I'll hand you over to blas to basically explain or share with you some problems that we face uh running this platform.

D

Yes, so essentially trying to put in practice a bit all these points. That constantly mention in terms of why it is so hard to to build an exchange. I like to go a bit more lower level and explain some of these particular issues that we we have been dealing with and why they are relevant to us and uh also somehow how we try to go around them. So the first one is um whenever we need to deal with money, accountancy and everything, we have to um think.

D

Okay, how we're going to model um these accounts, and one of the problems that we do have is a floating point is first, is not even like the steps between each of the the different points on the on the sort of the the the line. So so you actually have to go into something that you control more and understand, which is, in this case the decimal um expression, but essentially that that means that you're moving from a lot of good things.

D

That hardware gives you and a lot of auditability and things that work across all platforms, and you somehow model your problem a bit more with hardware software. Instead of hardware, and essentially a lot of um things that you thought they were in certain way, they're not necessarily like this. Also you, you have uh sometimes issues with the library panicking um and it's funny, because this is something we talked.

D

uh It was mentioned before the library, soon panic, but essentially this is an issue that we do have sometimes, and particularly something we I wanted to to mention is that uh when we think of floating point um operations, uh one thing they are constant time, so one can think of them as being free, but for us it happened once um that we were doing a benchmark.

D

uh Let me show you the flame graph that um we had on on our on our benchmarking and and, as you can see, uh this is this is one method, but it's quite important one and you can see like on top of it. It appears all the time rust decimal. That was one of the crates that we use, and particularly we saw the the division. Operation was very, very expensive. um So so then we started like investigating, uh and fortunately they they they submit a patch uh that actually changed our profile into.

D

uh You can see the the after um something a bit more, what we expected, and we we actually for this method, were able to go five times faster, which actually was was amazing.

D

um But essentially what I want to try to say again is that we do have problems in in parts of the code that sometimes we don't even think. That would be an issue in terms of both um the result that it has to be um like what we expect, but also uh the performance as well. um Another problem that we we face is that we need to somehow uh model parts of your system with the system uh so that we get this deterministic behavior.

D

Why is that? Because we need to be able to to guarantee some of things that constitute mention, but also in terms of like nobody, jumping the queue or having weird behavior, but also because we need to be able to to go back in time in case something breaks or also in order to be able to audit. So one of the tools that we we use often is we replay the system, perhaps offline, in order to be able to to get to a certain state.

D

I know that, okay, how is the the the engine looking at this point? What are the accounts? uh What are the transactions? What actually has been happening um and connected to this? We need. We need this mechanism to be actually safe and fast, because we do this very often uh at times uh and and also this is a mechanism that we we use in the case of going down, so whenever we need to actually recover from this uh event, we actually need to happen.

D

Make this happen as fast as we can and connected to high availability. uh It is the problem of how do we replicate uh the different parts of our system? How do we communicate uh between them?

D

How do we uh ensure that there's only one leader, because we cannot have two parts of the system in certain areas talking to the market, because then we duplicate, uh let's say an order and that's not what we want um so that that actually poses a restriction on us in certain places of the code or a system where we cannot scale horizontally, but only vertically uh and the and actually the delay.

D

The last issue that that we do have I mean as a sort of a common denominator, is, is io latency introduced by writing to the disk right into the database going to a network. So we do need to think. How do we log? How do we persist? Data? Which databases do we use? How do we actually go to the database?

D

How do we write because we can batch, for instance, but we need to be sure that when we batch, the data is actually being written and if there was an issue, we need to understand where it broke and communicate back to the system so that we can recover properly. um So why? Why do we actually enjoy using rust for solving all these problems?

D

For us testing is is paramount. We we sort of stand in every day on top of our tests. They are the ones who kind of give us the guarantees that the system performs the way we we expect it to to be, and both we we find rust. Like writing integration tests unit test is pretty nice, the same with benchmarking.

D

Whenever we want to test some some new feature or for regression, we we find that the crates and the built-in support from cargo and the language is pretty nice. We do use quite a lot. Interoperability from systems written in c or c, plus, plus that's also pretty nice, because, there's a ton of say, safe wrappers that work really well. We also make use in certain cases of meta programming, particularly procedural macros, and I mean downstream certainly a lot it's a blessing, and I think something else we we make.

D

I mean good use of is the fact that there's a lot of crypto primitives and libraries that are built natively from like directly in rust. um The cases for, for example, blockchain solana, entirely works uh out of the box from the rust client a bit.

D

The the ugly part is that particularly for the the disadvantages that we we do have is that, for the industry in which we are uh competitors and sort of the the status quo is, is writing everything in java and c, plus, plus and thereby we miss a lot of really performant and ergonomic libraries, because they don't have necessarily clients written in ros. There are some community available options, but very far away from the the ones that are mainly supported by by the libraries the same we see with some core dependencies that we actually use.

D

They do have low maintenance, because sometimes it's just somebody did it as a hobby and then we take it and we need to maintain it ourselves or rewrite it from scratch. But it's not necessarily the optimal, especially for startup uh and the last thing I is that we run a nightly, uh and sometimes it is a bit more painful because we run leading edge, which gives us a lot of features. But that makes our builds break for apparently no reason.

D

Of course, then we need to adjust the code, but it's it's been quite quite fine, all in all uh yeah and that's it. Thank you. um We we're looking for for good people to join us. So if anybody wants to come in on board, please go to collider xyz.

E

Cool yeah, I think.

A

E

That is it for our talk.

A

Thank you constantine. Thank you blast. This was a nice presentation on.

A

A

Yes, thank you, everyone for attending today. I think uh we are at the end of our meet up, and hopefully we want to see you next month and have a great time and again as a reminder. We are looking for speakers.

A

If you you have a topic or a project to show off here would be happy and excited to hear from you. uh I haven't seen any questions on the chat for the last talk, but if you have questions before we close, I think this is a good time to ask.