Rust Programming Language RustFest Rome 2018, 7 Dec 2018

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: RustFest Rome 2018 - Pascal Hertleif: Declarative programming in Rust

Description

One of the secret ingredients in many successful, big code bases is that they found a good level of abstraction. One helpful technique is to write declarative code: You describe "what" you want to do, but don't mix it with the "how". While this is not specific to Rust, the language and its ecosystem help us write declarative code. This talk will go over some examples, covering famous crates and APIs as well as more obscure ones, to then dive into ways to use this to your advantage in your own code.

https://rome.rustfest.eu/sessions/declarative-programming-in-rust
https://media.ccc.de/v/rustfest-rome-5-declarative-programming-in-rust

A

Yeah today I'm here to talk to you about the cloud of programming and after Eric's, perfect introduction, I really don't have to introduce myself anymore. It seems, and but I've been working with rust since early 2014 and I've been loving every minute of it right now, I'm mostly concerned with making CLI tools in rust, really amazing, and also, if you happen to be in Cologne, you should come to Ronnie down. You can find me on the on the internet on deuce addresses and with that, let's start at the beginning, the very very beginning.

A

What is a computer program?

A

Let's think about that, for a minute now: okay, fine! So to make a program work, you basically have to tell the computer what to do step by step step by very tiny step. So this is imperative. This is literally called imperative programming and if you do enough of this, it's very hard to reason about the general behavior of your program, but you might be saying where this rust fest a lot of assembly camp. So what are you even talking about if you're here for assembly?

A

This is not the talk for you I'm, so sorry, but the common theme was my talks, said I'll at some point drift off and talk about what maintainable code looks like and that's always having maintainable code, it's in hiring demand, but it's also very hard to get there. So the question you need to ask yourself: this is my code maintainable, and this is a good question and I have some more questions.

A

First off like how much do you need to read to understand what is going on, but also how much do you need to write to make a change in your program code and last but not least, how easy is it to identify the core concepts of what's going on?

A

These are very generic questions, I know and they apply to basically every piece of code you've ever written I think so what does it actually have to do with this talk, because the talk is declarative programming, so let's define this and as always, when I need to find the definition of something I go to the Kapiti I write wikipedia tells me that the cloud of program is often defined as any style of programming. That is not in person.

A

It's that's true. Okay, not really helpful.

A

The Wikipedia page goes on and talks about some examples from the client of programming, for example, HTML or regular expressions or sequel, but also high school and Prolog headful yeah, okay, okay, fine. But what is it really about?

A

I'd summarize it as it's about the what, instead of the how the idea is that you don't write all the steps on how to get somewhere, but instead you try to express what you want to accomplish and basically, if your computer do stuff for you, which is nice, and you might be wondering how okay, so the few steps you might want to take is to identify concepts that your program is about and you try to extract their behavior.

A

You abstract, over control flow. That means you have in your editor, with syntax, highlighting less of those colorful key words and more expressive function, names and, in the end, you hope to be able to compose your application application from smaller parts. Okay, okay, I'm, fine, I know what you're saying can get to the point. What does it actually have to do with rust? The super abstract like okay?

A

How do I apply this, and this is very good question, because this is actually about introducing abstractions and if they're right, you end up as code, that's easier to reason about and declarative code in rust, okay, fine! So, as the cloud of code is ever saying, but imperative code, apparently and rust is totally able to give you all the emotive needs you ever need to have.

A

You might be wondering: okay, if this is a functional construct and I'm going to talk about functional programming.

A

Now and I am sad to say, I'm, not because rust to me is very pragmatic in that it has functional elements that allows you to write very functional, looking code, but it also allows you to embrace mutability and write imperative code if you so desire and I leave it to the experts to say if rust is actually a functional programming language, but I want to talk to you about how rust is able to abstract over ideas, and in fact one of the selling points of rust is to have a zero cost abstractions, which basically talks about the runtime cost of having abstractions.

A

That means you can write abstract high level code and, if you need it to be high-performance code as well, you don't have to drop down to a lower level and write it in an imperative style.

A

Instead, russ tries to give you high performance code with high abstraction, and this talk will be by example, because it's a short talk and I've also been talking for six minutes already, and I can't possibly give you a recipe to turn on your code into better code, at least not in this talk, and I hope to give you some examples in its value. So, let's start with something simple and that was loose in every piece of code. I've ever touched at some points.

A

There was a loop over a collection of items, and this looks like a good example to me: let's have a list of items I'm going with Latin here, because we are wrong and fubar is so over and the idea is to find the first element that ends with a character n, so we loop over our vector and we go from the zeros item up to the last item, it's defined by the length of the vector and you certain happens to end with name return, some and the content of sediment, otherwise return, none, okay!

A

This is simply enough. It's actually easy to read and if you're used to the style, it's very very common and you wouldn't question it, but in the real world we have gonna have some problems. For example, there are new requirements, it just happened to turn up one day. Imagine you're going into the office Monday morning, and your boss tells you ok, you've been doing this code, it's fine, it's working, but now you need to have something that finds the fifth five. The five elements that end with em.

A

So you're gonna extend this piece of code and you add a mutable result to it and to push items into it, and also you try to only go up to five elements. So this, if is pretty much twice the size and in the end you can return the result. Okay, this is still easy to reason about. It's count that fits on a slide. So I'd say it's fine, you can read it and you know what's going on, but there are some nuances.

A

For example, the very important piece is the five and less than or equal, and actually the font I chose has a ligature for it.

A

So it's actually lesser or equal sign, but in your code it might not look like this, and the five right in the middle is basically the new requirement, but for some reason it's right in the middle and not just visible, okay, okay, what's an alternative approach, your target of approach is to use iterators and if you've written rust, you've probably also come across iterators because in receiver will come and the advantage of this snippet of code is that the core concepts are right there in the method names you filter for items that end with nan, you take five of them and you collect them.

A

I know I've committed some type annotations, but this will work in the right context. Actually, this is faster than the Luke we've just seen, because the Luke I wrote behind that. I totally forgot that after I've already collected five elements, I can just stop and do an early return.

A

Okay, it stupid mistake, but it's Monday morning, right, I totally forgot about it and this code, just it's way slower than I actually needed to have it see.

A

So for the live stream, he pointed out that I'm taking six elements because I'm not able to count but like I, said Monday morning. This is a great example of how iterators can save me, because I don't have to count. You can just like take five elements and it's good to go. Yeah, nice, okay, okay, wasn't actually expecting that good. But what what have we done? In general, we've abstracted over this control flow of looping and conditioning and basically just create our intent on filtering and checking five elements.

A

Also note that this is an abstraction that is pretty pretty powerful. I have omitted to type annotations for one reason specifically, and that is I. Don't care that this is a vector and I don't care what I'm collecting into this could be hash sets I, don't mind. It's super generic actually, and this makes sense if you have a chain of iterator calls and it's all good, but it also makes sense if you are looking for just one condition in an iteration. For example, there is an any method that you can use to just check: hey.

A

Is there any element in my list and you don't have to write a for loop and you don't have to write a condition in it? You can just say any, because what you want is subjective, selves and the element, it's very, very expressive. Okay, that's it for iterators. Let's look at another example, and this is about pausing Jason, because Jason is a very simple format. You could say: okay, I, don't have to do any complicated things.

A

Maybe I don't know so you know there are 30 Jason and you know it has a value type, and you know if I have a string that looks like Jason I hope this is formatted correctly. I can get a value out of it probably, and if there is some value a that happens to be a number I can print it. Okay, easy enough, but next Monday arrives next requirements arrive and actually yes, this structure actually has three fields and we need to deal with this and, of course this is rust.

A

We know we can write data types, so we write our structure called response and say this has three fields, and so we continue to write our code, as we've been doing it for the last week and the difference is that it got a bit longer yeah and it's basically all the same. The only thing that changes is this character, and then we have our response easy enough right, but a bit boring okay. This looks like it's pretty pretty repetitive and not specific to the actual problem we have. That is dealing with our response.

A

Russ gives us a very neat feature, and that is procedural, macros and especially derive macros. So, as you may have seen in Sirte code, you can just say derive to serialize, and all this boilerplate codes is a repetitive piece of code that we've just seen gets generated, and in fact this is same as a loop, also faster, because there is no value that needs to be allocated and filled with generic JSON data, and it even has better errors too.

A

Okay, a bit of a pet peeve of mine this year has been command line applications, so I couldn't go without writing or talking about command line arguments, the core concept, and so imagine you have programs that it's named tool for some reason, because I'm bad at coming up with project names, apparently- and it takes an input file, name and an output file name, and it does some weird stuff with this file and rides it to the output cool, that's easy using the standard library you can just say, stood and arcs and I get an iterator over my command arguments.

A

The first one I choose is wrong: I just realized the first one is actually the name tool but never mind the first one in this case. In this very specific case, where a stood and works differently is the input and the next one is the output cool.

A

You may have seen this pattern and let I'm now going to tell you that there are new requirements and two requirement is that this is not how command line tools should work. They should also take flags like OH, specify the output file, but don't worry, there's a crate for that. It's called get out and it allows you to write some easy enough code, so you can specify an opt, opt whatever. That is not an option. I don't know, but it's on opt and it's called oh and it sets your output file name.

A

This is from the documentation, I'm not kidding, and it's ok. It works for this specific case and it's not that much code I teased a bit with the scrolling. But it's it's ok. You can do this, so we may have to ask ourselves how much do you need to read? It's ok, how much you need to write to make a change. Actually, this right, get-ups has nice abstraction. You can write, many ourselves up, tops and a opt thingies, and you can basically build up your command line to it.

A

But how easy is it to reason about? What's actually happening there? I, don't know it's a bit: it's not very expressive. But, okay, let's look at the NASA crate that also implements an abstraction over command line. Arguments which is called clap and you may have heard of it- it gives you the possibility to write down what your application should look like. Basically, it's there is a type hood app, that's a type called arc and you can compose an app with arguments.

A

This also includes documentation and it's very very expressive, because all this methods allow you to express precisely what you want your application to look like very nice. If you run this with help, you get a nice help message. If you run it with version, you get a version number. This is abstracted right for you, because it's always assignments.

A

You don't have to write this code by yourself, but this too has one bit of an issue, and that is similar to our days in case before now, we're looking at some values of our arguments and we're going to deal with the data inside, and we have to do this by ourselves.

A

Interesting, maybe we can do something similar were studied it and yeah. We can because isn't commands and arguments just to take the structure. In fact, those library called struct up, which you may have also heard of, and it allows you to describe your command-line arguments as a structure and derive basically all the code we've seen before, including using the documents for health messages.

A

Ok, ok, I've talked quite a lot about procedural macros and derive macros, but I also want to touch on another subject, because this is not to talk about macros, even though it may seem like it. This is a talk about abstraction, and this requires me to use the scary-looking headline, I guess, and to make this crescendo of increasing complexity, an example it's usable and what I'm trying to get at is we write generic functions and our generic functions can use concrete types to declare what to do the walls.

A

A very nice example, I've recently rediscovered so to say, is in web frameworks. I know there are many web frameworks also for us, but let's imagine there is a very, very generic one and a very simple one, not generic in the scans and it's a framework where you specify a function that takes a request and returns a response simply enough and our request happens to contain a body of JSON data and we want to get in name filled out.

A

This looks like basically the same code we've seen in the earlier example, except a few also choosing the name. Nobody if there is nobody okay, so this is actually already quite good, but you might be wondering if we've previously managed to get rid of this rising value. May we can get rid of it in this case too, and actually we can go one step further, because C Rica's body doesn't have to be tracing for metal at all and that we are taking the Rica's body and dealing with it as if it were.

A

Jason is something that we spent two lines about and actually maybe also a third line, but we don't have to because our generic function could not only take a request, but maybe also some other type. That tells us what we actually want from our request, and the idea is that this Jason type here is a type that implements, for example, a trade called from request and when our framework calls it, it gives it a request and the type size.

A

Okay, this request, I'm gonna pass of Jason and the login data type defines what kind of structure we wants us Jason to parse into this allows you to express what data you want extracted from the request without having to do it yourself, and this also composes quite nicely, because you can say I now have a type that is Jason or from data or I can have two types: it's actually a tuple of a query, string and Jason powered and maybe also the path of the URL.

A

This is something we should use more often.

A

This is it for examples, but there's one more quite important topic I want to touch on, and that is please be aware of the magic BJ of your code base and it turns out that and sufficiently high abstraction is indistinguishable from magic.

A

Yeah and the next slide.

A

No I'm not going to touch on that. So sorry, let let's talk about what magic is actually in the scientific sense, of course, and let's define magic as code whose behavior is hard to predict or to remember, because at least I am very forgetful like. If you show me code and say: I have written this like half a year ago. I will have no idea what this is about. So maybe it's also a good idea to write code. That is so expressive that you don't have to remember it to make sense.

A

Okay, so what code could be hard to predict and familiar macros? Obviously, people are a lot of people actually very fearful of using macros because they are magic.

A

This is a quote also very generic code and there are programming language that say: okay, it's a good idea to have generics, but actually not in our use case and there's a very, very solid argument, because if you want to have correctable code, that is easy to read that may not be as concise as you want it to be, but that is easy to understand. Generics will probably hinder us, but also like we've all been there like. We have tried to write clever code, but could you understand so clever code afterwards?

A

This is also magic and you can tell magic into science if you have the right tools, for example, if something like Iago expand will give you the output of what rust, C will actually compile if it has expanded audio macros. So, for example, this struct of example I gave you can paste it into your editor, run cago, expand and see how it generates clap code underneath codes that you didn't have to write but codes that will be there and codes that you can read if you want to.

A

Sadly, even the best tools will only move this complexity towards using the tool, but not actually resolvers. So I was wondering. How can we be aware of this? How can we come up with good ideas to write, even more declarative and even more expressive and even more useful code? And the next question obviously, is: how can we teach this? How can we get a community to the point we are using? Iterators is so complex that you do not question it.

A

How can we use macros in a non-magical sense because they're our macros, like Beck, did you? Did you see? I used the Veck macro? Now it doesn't really matter because it's very expressive. You know the types come back the macros contract and to expect it to generate the vector this just works, and so how can we actually teaches us?

A

So several approaches? The first one is through interactive learning. Ya know it's the first. This is an ambitious one, applause I'm. So sorry, but I really like flippy lands and I know there was a lot of potential for writing even more clip islands, for example, there is one issue that happened to be open by me about linting for loops to suggest iterators, for example. This is the code snippet that uses any could have been a for loop with an if statement and the return Clippy code to texas and tell you hey.

A

If you want to write this in a more maybe.

A

A

A

A

A

And I hope you've got some inspiration from it, or at least some.

B

Ideas on how to.

A

And maybe do something differently in your own code base or when you're writing code. Thank you. So much.

B

A

You very much are the questions to Pascal.

C

Do you think there is a conflict between declarative.

B

Programming and the performance in memory, consumption.

A

If I understood correctly performance implications of using declarative programming starts yes, okay. Well, it depends on what you're doing. Of course, for example, all the examples I showed using 30 and using iterators were actually faster because they did less work. But writing this code manually in an imperative style would be very tedious. You can, of course, do it and because, on an assembly level, everything is imperative. You can optimize every program as an imperative level more rigorously than you would be able to.

A

If you have to trust some abstraction but I believe, especially in rust, we've managed to come up with some very good abstractions that boil down to being the exact same assembly as an imperative style, for example, using iterators.

B

Any more questions.

C

It seems to me that sometimes declarative programming would almost require some additional magic. For example, when you did the take five and collect you know, it's sort of it does say what to do and not how to do it. But it's not sort of obvious what the resulting performance characteristics might be, because you don't know how it accomplishes that task.

C

A

You performance, no, it's fine, the resulting performance.

A

You have to measure it to be very, very certain, of course, but it happens to be the lazy to write as a very fast. So in this case you will find that it's actually the same performance is writing volume and, of course, in the end, you have to trust it or you have to measure it. I'd always err on the side of measuring it, but this magic you're talking about to make this fast, is called rusty and we always already using it so yeah.

B

Any more questions.

B

Thank you for your talk. You mentioned that. Sometimes you look at your old code and you wonder what you did there. What are the measure? What do you do then? Do you leave it like that, or do you start rewriting it or are you putting memos for yourself for your future self?

B

Do this better next time.

A

Depends on when I wrote the code I started, writing good, commit messages at some point. I realized that I couldn't remember what I wanted to do so. I, look at my commit messages and say: oh yeah, this. What's what okay? It works some of the time, but you're right, basically, I have to read it.

A

I have to understand it and have to guess- and this is the same for my own code as for everyone else's- making better guesses and being more confident that these guesses about expected behavior are what you wanted to have is one of the advantages of having declarative code in my opinions, but also read could commit.

B

B

All right, then,.

A

Thank you again, Pascal.