Rust Programming Language Rust Hungary Meetup, 25 Mar 2021

Previous Meeting

Next Meeting

⏯

youtube image

►

From YouTube: Rust Hungary - Meetup S03 E02

Description

00:00 Introduction
02:15 Balázs Söptei: Async programming in Rust & the Actix framework
- Slides: https://docs.google.com/presentation/d/15C3SiahvPhGxOMSn2v90jeHylqlcPk1n5PNtYuh27vU/view

Meetups are streamed live on https://meetup.rustl-lang.hu

A

So hello, everybody thanks for joining our beloved online guest meetup. My name is jonathan. I'm an idea, creator of mimox cafe remox was established uh 20 years ago. Now we are really open to developers needs. So that is why we decided to organize rust meetups in 2013..

A

We have organized rust fests as well, but we participated in paris and in rome too, and unfortunately, we have no rescue jobs yet, but if you are interested in other jobs, you can find hours on memox.com, slash jobs or if you have any questions or need some help about your it carrier. We can help you too contact us well with our website.

A

Today I represented bolaj, shertay and balajis is a standard developer at chorizo. He has been learning last since 2018. Besides programming music is his inspiration.

A

You can remember him from one of the presenter of um 9 20 90 last meetups in this presentation. He would like to show two things, and one is uh he's a scene programming in glass. The other one is the active framework which makes it easy to develop as in web applications.

A

um He will demonstrate the topic via data store, updates on the framework communicating through the protocol um yeah during the meetup. You can ask from balaj in our matrix group, and you know the link was sent yesterday via email and after the presentation you will have time to cheat chat on june link will be sent by us during the presentation.

A

Should stay on the stage.

B

Hi, thank you for the introduction, giuji and I am going to share my screen and begin the.

A

B

So welcome everyone to the season three episode, two of the rust hunger meetup. I am going to talk about async, await in rust and the actics web framework.

B

um Here I'm going to be scratching the surface, but I'm going to recommend some websites and documentation if you want to read further in any parts of of the topics, so I have divided this stock into three major parts. Part one is async await part two is actix web and part three. I am going to demo my toy project, which is an async web server based on the actics web framework.

B

Okay, so oops I'm going to talk about a single weight in this first part. So, let's start with what is a synchrony.

B

So asynchrony is a concurrent programming model which is an alternative to a series of other concurrent programming models, one of which is multi-threading. Most of you must know this. It is present in most of programming languages.

B

Another one is called co routines. um They are present in kotlin and the go language and in the letter they are even called go routines with the g, so they have a funny name and the third one I'm mentioning here are callbacks.

B

They are most known in in javascript and- and there are more, I'm only mentioning these ones, because these are the most famous.

B

So yes, and before we begin, I would like to mention this async book and here's the link to the async book. It is a very good summary of the topic in rust.

B

Going further, so I have brought you this diagram that compares a synchronous or sequential and an asynchronous program, so we have three separate tasks that take some time to complete.

B

Let's uh see what this represents first, so this in this model, these tasks are computed or executed uh one after another, and these color rectangles not only represent the time spent with the calculation, but they also represent time waiting this so the program or the thread is waiting for a task to complete.

B

So it's it cannot do anything useful while the calculation is going on, so these are executed one after another and the in contrast to that in the asynchronous model.

B

The whole idea is to enable the thread or the program make useful work, while it is waiting for a task to complete. So you can see it starts with the green test task one and when it cannot progress, it switches to another task and so on so and well the so. The whole idea is that you don't do not wait in ways, so the program does not waste time it. It can do something useful while one task needs to complete.

B

So that's the whole idea of of this model.

B

Okay, next thing I would like to talk about is the async and the await keywords in rus and the future trade from I, if I remember well from arrest version, 1.39, the async and the await keywords are stable, so you can use them in stable rest and the keyword async. It provides syntactic sugar, I'm going to show you an example what it does okay, so you can use the async keyword and you make the function or block or closure return a future.

B

So here is the link to the standard library documentation for the future trade.

B

The only thing I would like to mention here is that a future represent a task that may have not completed yet it will complete sometime later, if it's not completed yet, and as I mentioned before, the idea is to enable the thread or program do useful work, while it waits for a test complete. So it can switch between tasks that are asynchronous okay, async keyword, you can mark functions with async.

B

I will show you that later you can mark blocks with async. I have an example of that too, and currently you cannot mark closures as async and stable rest, but they are available in innightly.

B

One thing I would like to mention here that in trades the async functions are not yet supported in the standard library, but there is a uh crate called async trade which enables that. However, the async book says that the async trade comes with heap allocation, so you might want to consider that uh when, when using it, so it has a performance cost.

B

Okay, so the async keyword comes hand in hand with the await keyword, because in rust, futures are lazy, which means you have to drag them into completion until that they do nothing. So you need to use the await to make a future a an asynchronous task.

B

Do something: okay, um the one rule is that you can use the weight keyword only in async functions or blocks, or closures, oops, okay, one other thing I would like to mention here is that, in order to make futures work, you will need an executor or in other words you will need a runtime and the rust standard library doesn't have a built-in runtime.

B

However, there are crates that provide runtimes for executing and computing futures and asynchronous tasks, and uh the async book mentions a bunch of them and if you don't like those provided runtimes provided by creates, you can implement your own.

B

So I have some silly examples: these are very simple pieces of code just to make a point, and I have it on github. However, I copied and pasted it into the play, browse playground so and- and I can show you some examples of of asynchronous things. As I mentioned, there is no built-in runtime in rust.

B

For example, there is something in the futures crate. I am going to use this block on function as a workaround. You will see why I'm using it uh one. The first thing I would like to show you is this syntax, so you are using the async keyword here in this function. Definition- and you say it returns a u64, but actually what it returns is a feature of a u64.

B

The other way to write. This is a little bit more verbose, but it it is equivalent to this function notation.

B

So if you don't want to use the async keyword, you can use a function, a a regular function and make it return a something that implements a future, the output type of which is a u64 okay. The body is not quite equivalent, but it's it's simplification. It's already function it. It represents a feature that is ready uh on the spot.

B

Actually, actually async functions have some compiler magic under the hood so and I'm going to show you that the two functions uh return: the same output, I'm asserting the equality here in line 43, and you can see it run without errors and I'm using this block home because the regular main function cannot be marked as asynchronous.

B

uh I can show you to do it, so it is going to throw a compiler error.

B

And you can see it below.

B

However, there are solutions provided by crates and I am going to demonstrate it later during this talk.

B

Okay, so the next thing I would like to show is that the futures are lazy, as I mentioned, so here's an asynchronous function that panics in the body, so it throws an error, but if you don't await this function, if you don't drive it into completion, then it won't panic so because it it's not a simple function, it returns a future. So the type of this is a future unit or future void.

B

But if I uncomment this block, which called a another function that actually awaits the this one, then it is going to panic. So, let's see how it happens.

B

Yes, you can see the thread panicked with the panic buyers message and I'm going to comment it back, because I don't want it to panic anymore.

B

Another thing I would like to show in this simple example is that futures and asynchronous programming comes with different types of control flow and the futures create the link of which you have here provides a handful of options.

B

So, for example, there's this trade called future extensions and it provides a handful of other adapters, one of which is maps, so it takes a future and with the map function you can uh take uh provide a a closure that takes the result of the future and pro processes for it further, and this incremented square is still a future.

B

So if you don't await it or block it, it will be lazy still.

B

So here I will show you that the result is as expected, but you need to block, because this is still a future and map is just one of the dozens of of adapters that this future extension trade provides in the futures.

B

B

Feature script also has macros that help with the control flow. So here we have this macro called join and the documentation says that it pulls multiple futures simultaneously, and here comes the power of asynchronous computation. So it's much much more powerful than just simply awaiting them, one after another, because it says that they are pulled simultaneously.

B

And this macro can also be used only in async functions, racing blocks. As I mentioned, there is in blocks and I will show an example. This is one, so you just simply write async and you can do some asynchronous logic in within the curly braces and the whole thing returns a future and I can block it.

B

You run it into completion.

B

Okay, another macro in the future straight is the try join. It is similar to join, but it works with few pairs that return a result and it is a fail first mechanism. So if one of the features result in an error, then you get an error. So I have this: try plus function which returns a result.

B

It's actually a checked addition of of two u8 integers and.

B

I can make it return an error by adding to two large numbers because it is going to overflow, and thus this tri join of this two will result in an error, because one of them is an error.

B

Okay, last macro I would like to show is the select macro, so it says it runs multiple features simultaneously and allowing the user to respond as soon as any future completes. So it is going to have one result, whichever finishes first and let the user interact with the program.

B

um I can imagine this it's very useful in in user interfaces.

B

B

Last thing I would like to show you in this simple example: is testing so a way of testing actually because you can use block on in tests, but there are better ways- and I will show you that too, so there are crates that provide other solutions, so basically, by default, you cannot mark your test functions asynchronous, so I'm going to show if I try to run this, it's going to fail.

B

But it kind can run regularly and use black on. If you want a solution- and you can see this- this has passed. I'm going to show you later that if you have a crate that provides some annotations, you can mark your tests asynchronous.

B

Okay, um next thing I would like to show you is a benchmark of synchronous versus asynchronous mechanism or model in code, so I made this.

B

Program that does a linear regression, so it it takes a series of data points and it constructs a linear model from those data points here I have a sequential implementation, so this function is not asynchronous. It just calculates the necessary data for the regression one after another and in the end it returns a linear model.

B

On the other hand, I have this asynchronous version of of the regression, so it does the same thing regarding the input and the output. It takes a series of data points and it provides a linear model based on those data points and instead of doing it all sequentially.

B

There are some uh pieces of data that do not depend on each other, so they can be calculated independently and they can be calculated by using the joint macro. So they can be pulled simultaneously, and there is another point that where this can be done, this to the kind that don't depend on each other, so they can be run uh asynchronously independently and again they can be pulled simultaneously. Using the join macro and the output is is the same.

B

The difference is how we get to the result.

B

Okay, so uh the thing I did using this, these two functions is that I run a benchmark using the criterion crate.

B

And I have the source in this benchmarks benchmarks.rs, so I'm using criterion that supports asynchronous executing during benchmarks, and I have a data point series that is a size of 1 million and I provided both functions with this input and I measured the time using criteria. uh I'm going to enlarge this a bit so.

B

This is the synchronous or sequential model. um What you need to see is the mean estimate and the this is around 24 milliseconds.

B

For a million of data points, and compared to that, I have the asynchronous version that have 16 point. Something, uh and what I like to emphasize here is that not not the absolute value is that counts here, but the difference between the model.

B

Okay, here's it with a simple measurement to demonstrate this, and if you would like to re reproduce it you can uh navigate to this github repo and and clone it and run your own measurements.

B

Okay. Next thing I would like to talk about is the actix web framework.

B

Which is a framework that enables you to build web servers that are asynchronous.

B

A

B

Before, if you have a create that supports marking your main function, asynchronous, you can do so and based on the actics runtime, you have this annotation and you can mark the main function as asynchronous and it's necessary because the when you create and run the server you need to await it um in in this web framework.

B

So what do we see here?

B

This main function constructs an http server with an application inside and buys these to a host and port, and that's it I'm going to show you what goes on in the background, but so it's as simple as that. You can configure your server like that.

B

I'm going to show you the fine details, so basically the http server instance allows you to accept http requests and and server responses, and the application is responsible for routing the requests and connecting them to the business logic.

B

Okay, so I mentioned this is a toy project which operates with an in-memory store and this store can be uh replaced with an actual database connection. However, if you want to further develop this, but what this store actually looks like is that it's a trait and it it supports basic, create, read, update, delete operations, as I mentioned, you can only use async functions in trades with with some workarounds with one of which is the async trade, and it has some performance costs.

B

However, I didn't perform any benchmarks to compare if this would be replaced with a regular trade with with non asynchronous functions. So this is the data store trade and.

B

The handlers the endpoints are going to use this with because they will delegate the mechanism to to this data store.

B

Okay, so the app data is a function that makes it possible to provide the application with shared data, so this data store is going to be shared while the application is running and this configure function makes it possible, but it makes it possible to configure the application.

B

What I'm configuring here are the end points and the endpoints look like this. So basically, we have two kinds of urls. One is the simple dash data and the other one is dash data dash key, which in here key, is a placeholder. It's a pattern and you can extract the key, which represents a key in the data store itself.

B

Okay, so what this configure endpoint does it's it. It connects the urls are here with http methods and connects them to specific functions which are called handlers in the actix web framework.

B

So this is what it does, and you can see the names of the handlers here, I'm going to show the anatomy of handlers right away. So what is and points function is it's. Basically, it's calling the route function with different inputs, and it it does the routing for the application.

B

You can do it in place right here, so you don't have to outsource this to the through a an external function. However, it is better for for testability to do so. So I'm doing it here.

B

Okay, so here are the handlers which are async functions, and these are the ones that connect that accept the results of the http requests and and return an http response.

B

And here you can see the handlers that correspond to create, read, update, delete methods and what they do. As I mentioned, they delegate it to the store. Let's see what these function notations mean.

B

Okay, so here let's take this function here we have a path variable which can be extracted from the url of the request. So I have shown you here this.

B

You can call this endpoint with any kind of key and this key is extracted, and that is the uh functionality of this path of of the framework and it's type safe. So the type of key is you size? If I remember well, so it extracts the key and passes on to the handler function.

B

Another thing is, the store is in this function, notation and it is wrapped inside this web data, which is, as I mentioned, is responsible for for shared data. So this is shared data and, in this handler functions operate on the data by delegating it to the delegating the functionality to to the data store.

B

Okay, besides the path and the data, we have a json type that can be passed on by the framework, so it works with http requests that have a json body and it's extracted from the json and passed to the function in a type safe way.

B

Okay, I believe uh I'm using only the js and the pass and the data the framework provides more than that, so the actix web framework has other kinds of extractors such as a web form. You can pass on the results of web forms via that.

B

It's also has a one called query, so you can pass on queries in the requests and the urls.

B

And I I think, that's it: okay, let's take a look in the body of this one of these handlers.

B

So this constructs this okay constructs in http response builder and you can further process it with this body function and you can pass a body which is already serialized, because the this data store works like that and since the store has asynchronous functions, you need to await it here to actually get the value and pass it on as a response body.

B

So the framework provides a handful of http responses. um I think this project operates with okay responses, most of the time, because it's a toy project, but you have these methods that correspond to most of the commonly used http responses response codes.

B

Okay, um so basically, this is what this toy application does. The framework, however, provides a much much more that you can use. So, for example, you can serve static files, you can pre and post process the requests. I mean you can pre-process the requests and post processor responses, um and I will I will show you a link to the hectic's official website and you can read it and you can experiment with it for your own purposes.

B

Okay, what I would like to show here another thing in the tests that, as I mentioned basically by default, you cannot mark your test functions async, but the run time provides a test annotation.

B

That makes it possible to do so so here first, you can mark your asynchronous function with with the keyword and you can, since you can mark it with async. You can use the await keyword inside.

B

This is a powerful feature of the framework. Another powerful feature is that you can use a test service and configure a test application there, and you can send test responses test request, sorry to do this test application and do assertions on the responses that it provides based on your requests, so you can test the whole application test. All the end points without having to run around your application.

B

B

I have this toy project on github, here's the link, so you can watch that you can examine the code and you can fork it and clone it and and play around with it if you want to in your free time and here's the link to the acting's official website, it's a really well documented framework. So here you have a handful of examples that can help you get started.

B

If you want to get started with this with the active framework, I definitely recommend, starting with the official website of of the framework.

B

Okay, now we have arrived to part three and I'm going to demonstrate this toy project of mine, see what you can see here uh I will represent. I will demonstrate it right away, so I have deployed this application to heroku and now I'm going to wake it up, because it runs on three dinos that are asleep currently, and here you can see the application runs properly, which means we can now test it.

B

So I'm going to use a command line version of for for demonstrating, because I haven't made any front end to this application. So basically, I will just send requests.

A

B

Line so the first is, I'm I'm sending a post request with a json body that includes some data. So it's a very simple: it's it's a very simple piece of data. It has a first name and last name and I'm sending it to the data endpoint.

B

And now I have my response so here what I have done is that I have sent a post request with this.

B

And point url to and it routes it to the create.

B

Which creates the data in the data store? So now I have a single piece of data. I can query my data so.

B

I will send a get request for this data endpoint and it it's going to return a an array which currently has a single piece of data, and here I have the key- and I can take this key and copy it and paste it here so like if we just makes it possible to query the data one by one. So if I turn this response, it returns the single one based on the key.

B

There are other things I can do because if they create read, update and delete, so I can also update my data, I'm adding another field which is an age. So jando is 40 years old.

B

And I have my response back and I, if I query undo again, you can see that it has an age of 42 now, because I have updated it before.

B

Okay. Another thing I would like to show you is deleting.

B

Oh, have I pasted no, I haven't. I need to update the key.

B

I can delete my data from the store and, if I query it again, you can see there is no entry with such a key and if I query all the data again, you can see it returned an empty array. So this toy project was like works like this.

B

Basically, and as I mentioned, so it's not it's not meant for production purposes, but it demonstrates well how easy it is to to create a web server using the actix web framework and you can play around with it and you can replace the in-memory store with an actual one. If you want to use it for actual data store purposes,.

B

Okay, so I have arrived to the summary so in this talk I have shown you the surface of the async, await keywords and the future trading rust how to use it, what you can do with it the power it has- and I have uh demonstrated the features of the actix web framework using a toy project of mine, which is a in-memory data store running based on the actics web framework.

B

You want to read more, I promise to send to to display some links of websites and documentation. So, as I mentioned, you have the async book, which has more on the topic much much more and in detail.

B

You can read the standard library starting with the future trait and you can learn about the the details of how it works and how it's designed and you can use the hectic's official website to be to get acquainted with the active framework and and start your project using it.

B

As I mentioned, I have my code examples on github, so these are. These are the examples I've shown in the in the playground. These are just silly examples to make a point. These are not very useful, so this is much more useful because it shows how you can leverage the powers of asynchrony and you can and how to benchmark using the criterion crate, and here I have the github link for the repo for my toy project.

B

I have shown and demonstrated in this talk, so you can fork and and clone it and play around with it if you want to so. This is all I wanted to say in this talk. Thank you for your attention and, if you have questions or comments, uh feel free to ask. Thank you.

A

Sorry, sorry, so thank you so much um for the great talk that was the second stock of the year and the next one will be on the 29th of april and you can schedule on meetup.com as well. So you can.