Rust Programming Language Spanish, 19 Jun 2017

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Erick Tryzelaar - Keynote: An Introduction to Rust #RustDayMX

Description

No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).

A

Oh, so, okay, so thank you so much for for coming. This is this is really exciting. I can't believe that there are all these people still who are interested in Russ, so I wanted to start off our day.

A

Talking about our language, giving you some foundation for the rest of the session today so, and also just the you know, this is our unofficial, mascot Paris, you know we we love them. There is someone who has a t-shirt with Paris on it as ah yes, you're a great person I need to get one of those shirts. They were sold out when I tried to get them so anyway to begin so this also, you know I want to say that, like you know, this is our third event of this style in the world.

A

We're calling these Ross bridge events we've had one in in the in Berlin one in a Pittsburgh and now Mexico. So this is all is very exciting. But to keep this in mind, this is also a bit experimental. So you know there are the curriculum that we've built today that it might be a little disorganized. You might run into the problem, so please tell us if you run into problems so that we can fix this in the future.

A

Also, there will be a survey at the end to ask you all where what we did well, what we did poorly anything that we could do better the next time we host one of these events will appreciate any any input, good or bad, so as I'm not sure what Sebastian said. Oh and also thank you so much Sebastian for inviting me down here.

A

This is this- is really fun, so I'm part of the thrust court team- you can see me down at the very bottom- is my little drain cover picture I'm also doing by Brian Anderson from the core team who's over there with a wonderful beard. So we've been working on rust for a number of years. We also are a part of our core.

A

The community team that is also trying to help encourage events like this around the world run our survey, which you may or may not have seen and do other things trying to like get our community engaged and trying to build out things like this. Try to do fun, games stuff, like that, we've also been around for a really long time. Someone actually asked me how long I've been doing rust, so this is my first commit that I've ever done to rust, which is was on May 17 2011, which I think is only about.

A

Like you know, five or six months after rust was was publicly announced, so I'm, really old, so and Brian actually I think was around even before that. But you know it was. It was nice back. Then you could actually follow what was happening in the language, and you know the the moment that I realized that rust was actually going to be. A real thing was when I couldn't keep up with what the community was doing anymore.

A

As a really nice experience, when I couldn't read, the commits I couldn't actually see what was going on and but like it's people like all of you that have been you know, kept me around, like it's just been so exciting, seeing all the encouragement inside the the environment so anyway to get into our session today. So this is a bit of an overview I'm going to talk about. You know a high level of why rust. Why we we built this then go into more of the details about how to get rust setup.

A

If any of you do not have rust, we'll we'll start talking through the steps of being installed, but we also have helpers here in order to help you get ready.

A

So so, okay, so to start out like why rust happens so rust was developed. It came out of Mozilla research where, if I remember the numbers correctly I think Firefox has 300 million users. Is that number correct?

A

Let's say that number is correct, so there's lots of people using Firefox in order to use the the web and it's for the most part almost and represent written in C++, and you know, after doing some analysis about, like they're all of their security, bugs that Firefox and Mozilla realized that that C++ was fundamentally unsafe, that you know as as much as they try to make C++.

A

You know safe using all sorts of like analysis tools in order to improve how how the code was working, sending a policies in order to do safe coding at just you know. It turned out that it was just are too easy to make one mistake and compromise. You know everyone's security, so here's a very simple. You know simple example of like one of the common problems, if you, if you've ever done a C or C++ programming, that you know this is called use after free.

A

So here we we, you know- and this is like an example of like you know, one of the bugs that the Mozilla was running- that as they were doing web audio, that they would download some sound file from the internet and they would play and the browser all pretty simple. But you know they evaluated all the security bugs that happen and one of the the most popular security bugs was things like this, where they would, they would allocate some memory for the audio file. Then you know some code paths.

A

You know clean up that pile, but then someone else would try to use it.

A

And then you know this itself could allow someone to take over someones browser and compromise their local machine get into banks, do all sorts of horrible things, and this is just like a you know, a trivial bug that you know someone doing code review might not necessarily see that something like this was would happen, and so you know there are languages like Java and Ruby and Python that they use things like garbage collection to avoid this particular problem like so, you can't have the use after free, but the problem that Mozilla was running into is that you know if they switched Firefox over to one of these other safer languages, that there would be a unacceptable performance hit.

A

That Java is, is really fast like it's a good strong language, but because it has a garbage collector that it's still, you know as a interactive user experience that the the interface might pause. You know every you know couple seconds for 50s or so milliseconds, so not horrible, but it would be. It wouldn't be a good user experience and for the.

A

Furthermore, it also you know once to like, if you've ever done, any multi-threaded programming that there's a lot of sharp edges to a multi-threaded programming like there's, there's various ways that you can make simple mistakes and run into these non-deterministic programming, languages or sorry non-deterministic, bugs where things might work 98% of the time but fail. You know this 1% of time and cause all sorts of problems which results in people not actually doing a lot of multi-threading coding, because it's hard and then we are now wasting resources on these.

A

These you know all of our laptops or own. That could give a more pleasant experience. So so rust is, you know what is called a systems programming language, so does anyone here, like you know, have a good definition of what systems programming is anyone? Okay, okay, so so you know one of the common definitions of like systems.

A

Programming is programming without a garbage collector, like you know, that's one of the nice binary things that define you know, systems language versus a non systems language, so you typically, you know if you're writing an operating system or kernel or even like a lot of like the you know, the high-performance video games that you need to be like as close to the metal as possible.

A

Like you want it to you, want you don't want to leave any performance on the table, you need it to be as fast as possible in order to have your game, be interactive and play on things. So another aspect is that you know a lot of these systems.

A

Languages either have a very small, runtime or no runtime at all, like so, if you're, if you're programming, an embedded device where you don't even have an operating system that you need to, you know systems languages, support that, whereas other non systems, languages like swift or go or Python, they have a lot of supporting infrastructure. In order to to support, you know how they are programming.

A

So one of the things, though, about like systems programming, is that there's I think some some misconceptions about. You know what it means to do systems programming that it doesn't mean that, like you have to be, you know an expert programmer that you know just because you want to write in a fast language doesn't mean that you have to be familiar with all these really archaic tools like make files and auto calls.

A

You know doing weird like flags on you know, GCC or clang, or all these other things or I have to like really conform hard to the environment. That you're running in it also doesn't mean that you only have to be like writing. You know Windows applications or databases. There's there's lots of ways that you can do systems programming, but you don't necessarily need to you know, have a PhD and in databases you also in in a lot of like the system languages.

A

You typically have to care very deeply about memory, so you might have to deal with like pointers and male' King and freeing memory and doing a lot of like manual management that you know it's not necessarily it's not building a website and just like being able to you know, make it easier for people to buy whatever stuff you're using like you know, there's it doesn't have to be defined by that, and so that's that's one of the things. The rust is working really hard on trying to make that usable and is everyone understanding me?

A

Am I doing okay, okay, good, okay, okay, so the the rest philosophy is that you know we we want to like try to address all these things and we want to try to like make it easier to do systems programming.

A

So we, you know, try to favor explicit programming versus like implicit like we don't necessarily want to have as much magic happening under the covers, but we also want to provide like there is a lot of really nice abstractions that you get in languages like Python or Ruby, where you have iterators and comprehensions and doing all sorts of these.

A

You know nice simple ways of walking through data structures, but we also don't like, if possible, we don't want you to have to pay for it like we want it to compile down into essentially the same code. You would write by hand, so we also want it to be memory safe, so that you don't necessarily like, so that all these bugs that that Mozilla was running into that, it's just impossible for you to write it in in rust that that will just fundamentally make everyone saver, but without without having to to you know pay.

A

You know any real cost work. We also want to have like really good air handling and really good a really good user experience like so that you don't have error messages that are just rolls of text that you can occasionally get with C++. We want it. We want to make it approachable and easy for people who are are, you know, ultimately, even new to programming easy to use rust, so I now I'm going to start walking through just getting rust set up?

A

If none of you have or if any of you do not have rust, set up on your computer, so does everyone have rust set up? Is there is there anyone who doesn't that?

A

Okay, so I'll try to go through this relatively quick? So there are a few tools that we have in order to make it a more pleasant experience. So rest up is: is our official installer for our language, like so Brian actually wrote this. So if you run into problems, you should use your bug Brian.

A

So we try to make it really simple to get rust setup. So one of the things that we do in the language is that we actually release a new version of our compiler every six weeks. So we do this because we want to try to make sure that we, the language, is not stagnating, that we, we aren't.

A

You know forcing people to just stay on like stay with bugs or you not take advantage of like new features that we develop that are stable, so Russ, Russ stuff is the way that you know we can easily roll these things out to the community without without having to like jump through a lot of Hoops. So it's pretty simple to install, so you can just you know you can just run this command in order to get it set up and it will install rust. So so does everyone, so everyone has rust installed.

A

If not, you know we can help you up. This is also like this is an interactive section. So if you want to run these commands- and if you run into problems just raise your hand and we'll will help you out so okay, so we also have a number of other installers that are, you know, set up for like if you're on Windows it just has a standard, Windows installer as well, likewise with Macs and Linux, which you can see on this gyro at the bottom of the page.

A

So the next thing that we have is cargo, which is our package manager, so for those of you that come out of like the Python ecosystem, so cargo is very similar, it's a pip or, if you're in Ruby, it's similar to Ruby gems or, if you're in Java, that there's maven and Ivy and all of that stuff. So this is our our simple thing to do. If it downloads dependencies, it can build your code, it can run tests and it can even publish to our central a package management system called crates IO.

A

So it's pretty simple to do so. If you have your computer's open, you can actually run this if you haven't actually built a rust project before that you just a cargo, comes with a very simple command called cargo new that will create a little skeleton environment for you.

A

So for you know, for the purposes of this talk that we're going to be. You know stepping, through a little bit of example, that you can walk through so here, I'll just do cargo new bin, which will create a binary or executable that that you can run, and so, if you you know just do cargo, do bin, Rus bridge or whatever you want, and then CD into this directory and if you're, using a version control that we've set up get by default.

A

So you're welcome to you know, do a commit now say one running in slums with us.

A

Okay, all right, so the files that cargo new will generate are just three files. So there's this cargo Tamil file that describes the metadata about your packages about any dependencies that you might use. We have a GUID ignore we actually set up get inside this environment, for you just as a convenient and then finally, this source / main dot RS, which is the actual rust file so before we get to actually doing rust, I'm going to step through the cargo file, which is very simple, so just is the name.

A

The version- and you know who is like setting up one of these projects, so rust or cargo, will try to pull out this metadata from like if you have get set up, that will try to get that your email address from there so you're welcome to change this to whatever you want. We don't have any dependencies right now, so this this will be blank. So the now here's rust this is a hello world that it should automatically generate for you.

A

So so, if you haven't done any rust whatsoever so to walk through what the code is. So this is the function, so we denote a function with FN and then we have the function. Name main and main is a special function. This is the the entry point into the executable. So when you execute the program, we'll execute this, so here we're going to print out hello, world and so println. This is actually called a macro, but you don't have to actually really know the details about it.

A

This is just how we the standard way for printing out to the standardout.

A

So if you want to try running this, you all you need to do is just run cargo run, so this should build the code for you execute it and it should print out hello world, as is anyone running into problems with this okay, and if you want okay, so the the things that they'll generate is there's a directory called target, which is where all of the artifacts will be stored and a cargo lock file, which is it's a file that that pins the dependencies so that if someone else tries to compile the code that it will use the same dependencies as whatever we set up.

A

But we don't have any dependency, so there shouldn't really be anything in that file. So here now welcome. If you want, you can start playing, you can like try, printing something else out. You can try printing out two things. You know you can just start having fun with the language.

A

So the next thing to talk about is that rust does have extensive documentation. So there's you can go to our website, dot, dot, rust line org or you can use the rust up command, rust up doc and it'll open up a local copy of the documentation.

A

If you want to just jump directly to the standard library, you can just add a dash dash STD.

A

Ok, so now that I've gone through that I'm going to start going into the how rust is like similar to other languages, the thing won't have any questions right now. Okay, so first off comments: surest is it has a you can do a slash, slash which is like you know, C style comments. We also have the block quotes. So your if you want you can try commenting out things.

A

Slash slash will just comment out things on a single line, whereas block quotes will comment out like multiple lines of code, so you're welcome to to play around with this. If you want, there is also a few other kinds of comments that are, you know, help drive the documentation, but we don't have to go into that now.

A

Next is variables, so variables are defined by using the keyword, let that denotes a variable. Then you have a variable named an equal sign and then you know some value. So here we have, you know a variable name, Eric, a variable age and I'm getting old, and then here we're just going to print out the the these variables. So here just to step through the string, this is actually kind of a little bit of a magic string.

A

So you know we have these curly braces that you know where the first argument is going to be put, and then the second curly brace is where the second thing is. So you should be able to you run this now and hopefully it will print out these things. Please let me know if anyone has any problems.

A

Ok, so so now an experiment, so we have a variable. So we we have. This is the separators a little bit off but like we're we're creating a number of apples. So we we say that we have a hundred apples and then we want to add fifty apples to it and then we try to print it out. So can someone try running this?

A

A

Yes, so you should probably get an error message like this, so this is surest draws a lot of inspiration from functional languages if you've heard of them that, by default, all of the Russ variables are immutable, which means that you know it's going to be a compile time error if you try to change them. The reason why we do this is that you know a lot of programming bugs actually come when people change variables out from under you and you aren't expecting it.

A

So in order to get this to work, you actually need to explicitly say a variable is that you can change it by doing let MutS then do the apples. So if you do this, the language or the you should now compile fine, and it should print that you have 150 apples.

A

So next up is is types so has surest is strongly typed and it strongly and statically typed. So this means that, like you know, so that when you assign a type to a particular value that it is, it is always going to be that type. So it's not like, if you're familiar with Python, that you could, you could have a variable. That is a string at one moment and then you can reassign it to an integer.

A

You can't do that in rust, so we have a number of different types like we have a lot of integer types. For example, we have unsigned 32-bit, integers I, signed 32-bit, integers floating point numbers. We also have like u8 in order to define a an 8-bit editor. So we also have strings so strings, unfortunately, are a little bit complicated rust, so we have a string and this ampersand ster, the we call ampersand stir as string slice, so I'm going to get into this later, because it's it's always like a point of confusion in the language.

A

We also have a boolean, so other things that you might have noticed is that when we were playing with variables that we actually didn't specify the type, so this is because rust has type inference. So this means that the hip, the compiler, can automatically figure out the type of a variable that you don't have to do the work so as opposed to Java and C, where you have to explicitly say that you know I want to do. Int 2 equals 5 that rest will save that work for you.

A

Sometimes, though, rust is not able to figure out the type. So then you have to explicitly specify the type so and you express a type like so here we have a variable age, and then you do some, you do colon, then the type name equals 30 and then one thing, though, with rust is that the place where you always, you always have to specify types on functions.

A

So you also so if this will be easy, if you're reading through code, to see what is the expected input and what you're supposed to be producing so really help out with that does. Does that make sense any any questions.

A

Okay, so functions so I mentioned. You know the main function before but like we also have other functions that you can define. It's defined the same way that you have FN and then the function name and then an argument. So here we have, you have parentheses, then the argument name colon the argument type and then you can have like multiple argument, types that are comma separated the output type. Is you know after this arrow and the i30 too? So then like here?

A

If any of you have used Ruby, that rust follows the same thing that, like it will be, the last expression inside a function will be automatically returned.

A

You could also explicitly say return n, plus 50 semicolon, and it would also return that pipe and then here we just are adding 50 to 100. So any questions, okay, moving on so okay, so now we're starting to get into more interesting control flow.

A

So here we want to do you know this is a movie rating I'm, not sure how they do movie ratings and in Mexico, but in the United States we have a few different ratings of like G and PG for kids, but then you know we have our rating, for you know if you're older than you know, 17 for you know other. You know more older movies. So so here we define our variable and then you just do. If you know n is less than 13, so this is very similar to other languages.

A

One of the nice things is that you don't actually have to specify the parentheses around the conditionals, like you do in other languages, and then you know we have, if else, if and then else so this should be. If you familiar with programming, this should be pretty common.

A

We also have match statements which, if you are familiar with switch statements or case statements and other languages, this is pretty similar to that. But ours are actually like a lot better than a lot of other languages. So here you know we could have written the other exam I'm. Like you know what what kind of what rating a movie someone could see by doing match than the variable name, and then here we have a few different options.

A

So here we say like between 0 and 12, you can you may CG or PG movies. So the way that this is written is like here we have this range expression, so we're saying like 0.12, that that is just saying that, like you know in between these two integer values that you know it will match this argument, and then we have what we in the community called the rocket or the equals arrow.

A

That has the expression that we're trying to run, and then it just needs to be comma separated for the next one. Then down here is the like. You know we have underscore which you know if you're doing a match statement. This is this is going to match all of the values like. So if it's outside of this range, it's always going to come down here if you're familiar with switch statements from C, this is analogous to the default.

A

The other thing kind of hard to see here is that there is a curly brace. So, like you know, you have curly braces for defined functions. If you want to have a multi-line, a match statement, you also have to put them in curly braces.

A

So next is arrays, so arrays are similar to other languages, but like they're, actually a like a little bit more complicated in rust that we'll get into a little bit later. So here, if you want, you can update the little example to say you know here we're going to create an array of 3, 3, integers and then we'll just modify one of them and then print it out.

A

So here you'll notice that we actually have a different thing like we have curly, brace calling question mark and curly brace, you know a bit of line noise, but you know it's actually. You know here. It is like a way that we can do formatting for specific types. So we have the curly brace close. Curly brace is what we call display. So this is for things that it actually makes sense that you know they're. They have a natural representation as a string, so like printing out an integer or printing out.

A

A string should always look like this, but sometimes you have some complex types like an array where there isn't just like one way of printing it out, so we don't necessarily want to just have a canonical way of printing it. So we have this thing called debug which just helps it it's designed for the developer for helping them figure out. You know what they're doing, whereas display is really designed for the user, the end user and also like for them to be.

A

You know able to see what you know is going on, so we we don't necessarily want to make assumptions about like how, like what kind of functions you're and how you want to use these things. We we just try to give people options in order to express like how they do things. So the other thing is that, like, if you have there's a mode called pretty debug, so this is colon or curly, brace colon hash, question mark and curly brace, it's kind of horrible if you aren't used to it.

A

But what this does is, like you know, if you're printing out an array, it will actually print out each item on a separate line. So if you have 100 items in your array, it's not just this one big mess of a line, so does this all make sense? Does anyone need me to rephrase things? Ok, yes, sir,.

B

In the previous light, as.

C

B

Slide now before another one, this one I don't know OH. Previously, that's not yeah. The return value did suppose. If not the main function is another function, the return value, it's whatever the age Mexico. Yes,.

A

So the in this case, like yeah, the the return value of this function, actually so so the return value like we didn't specify type here. So that means that, like we like, the main function doesn't like. You aren't supposed to return a value so conveniently the the println produces like this. This is the the unit type is, is what we call it. So this is. You can write this as open parentheses, close parentheses. It just means that you know there is no value, and so that's that's implicitly like implied by not specimens yeah.

B

But what I mean is they match? Being the last expression of the function? Is basically, they match a structure space. The return value, as it is the last expression of a function. Yes,.

A

Okay, yes, so yeah, so like you could, if you wanted to like, you, could do let flu equals. Whatever is the value out of this match, and so you could do more advanced things for, like you know deciding to like you could be returning a value instead of like you're printing out something okay.

B

A

So any other questions. Okay,.

A

So the other thing that will be useful, for you is a another macro that we have called panic, so panic will just abort your program, so you're welcome to like right now, modify your stuff and right panic and it will just throw an exception. Saying I. Well it here it'll, just they are so we also have Penix will be automatically thrown if you try to access a value outside of an array.

A

So here we have an array with three items, but if we try to access like the ninth item in the array, we are also going to throw an error. Now. This is also like the source of like many bugs in in see. So you know we just automatically. You know if you do something like this, that we're just going to abort the program.

A

There are ways of doing this so that it doesn't cause a problem, but this is just one of the ways that we try to make make things a little bit safer for you, okay, so moving on, so arrays are actually pretty limited in rust that you know you, while you can modify the individual values inside entering, you can actually add new items to it like. So, if you want to actually mutate the length of an array, you actually need to use a vector rather than right, so it is like.

A

We actually write this just the same way as we do arrays. We just use the macro Zek bang in order to declare it so beyond that it acts just like a race. So you can, you can, you know, assign values to it, and you can also modify the the length you can add new values to it. So this is much probably a lot more similar to two arrays that you'll find in languages like like Ruby or Python.

A

They, you know, so we just give different options like we like, as I mentioned before, that we want to make things explicit rather than implicit, that this is one of these cases that we want to make sure that you understand that there is a cost to doing these. Things like we arrays are much cheaper than than vectors, but you know a lot of times. You actually want to use the vector, because you don't you, don't have a fixed length array that you're working with it could change dynamically.

A

So the next thing after we have a raise is that you might want to be able to step through all of the items in it. So so here we have a few different ways of iterating. We call these four loops, so you know we I showed you ranges before, so you can actually do a for I in you know, 0 to 10 it's and then we'll just print it out, but you might also want to step through all the items in a vector which is the you know.

A

Here we define a vector and then we we do for name and names hitter. So this either is a method call. So this actually produces an iterator that I'll go into a second, but we also have like a few other ways of stepping through things, so we have loops which are just infinite loops, so we have while loops.

A

So if you want to have an exit because of some condition and break which allows you to break out of loops at any point time, there's also I forgot to put on continue, which is just like you know, see continue. So if you just want to skip to the next loop iteration, did anyone have any problems with this? This doing good, okay feel free to oh, yes, sir, can you use the microphone in.

B

One of the previous slides, the syntax, was different for the iterator range or wherever the 0.10 in the previous life is like well, 0, dot, dot, dot. Yes, okay, all.

A

B

Used try that yeah.

A

And it's a well liked. Yeah yeah I didn't realize that we were using two different things. So this is so we have inclusive ranges. So you know if you do 0.10 and inclusive range, I think this is how it is so this will be. It will actually produce items zero through nine if you do 0.10, but that's only sorry that is 0.10 will be zero through ten, so produce one two, three, four: five: six, seven, eight nine ten!

A

So it's just whether or not you want the last items we included in the the the list or not okay, good catch I should fix that because I don't know if I really need to go into that all right here, any other questions: okay, okay, so iterators. So this is one of like the really super cool things about rust. That you know is one of my favorite things so so iterators like are in other languages, but we we actually have these really powerful ways of stepping through items.

A

So you know before we had like 0 through 10 but say we wanted to look at just the even numbers. So you could write a you know for loop and then have a use if, in order to like test to see, if an item like if the modulo is like some item is 2 or 0 against 2, which you know this is, is going to do so. That would test.

A

Tell you whether or not a integer value is even or odd, but instead we have these things called like iterator methods that allows you to write a very simple expression that is applied as you're stepping through things. If has anyone used, sequel.

A

Sequel, SQL yeah, so this is it actually, it's very similar to writing, like sequel expression, so you can, you can like filter is, is like a select statements and you can, you can do joins with you know other operators. So here we are this first one is just going to like for each item in this. This range that we are just going to apply this. This is called a closure.

A

So this this will be called on each item where the you know inside the the vertical pipes is the the name of the the argument, and then here we just have a little test where it's going to return a bool boolean. If the boolean is true, then it will keep it and if it's false, then it will filter out that that item we also have maps like mapping is just like for each item that we iterate or we are stepping over, create a new value.

A

That is just like we're multiplying this, so you know here we will do like 0 through 10, but this will produce you 0 1, 4, 6, 0, 4, 9, yeah, yes, okay and then the the last thing that, like there's, lots and lots of these methods, which you can see in our documentation but like another one from like functional programming, is called cold. Where you actually are you for each item you want to like in this case, we just want to add up all of the items inside this array, so you know we.

A

We are initializing it with a default value. We are like you're stepping through a closure of two values and we're just like we are adding the value and then the next cycle we're passing in the result of this to the next closure. If you haven't done functional programming this you know it took me a little bit more time before I really understood folds. If you don't quite understand this, that's fine I can try to walk you through it later so, and then I spoke about the closure has. Is there any questions about this? Yes, Oh.

A

Use the microphone so you're on the.

D

Video stream, this constructions are these macros, or these are.

A

Not macros, these are the macro in rust, is written with, like you always see the exclamation mark before macro. So these are just normal methods that you can define on on a on a type and then.

D

Obviously the the ranch are they vectors? Sorry, the representation of the the ranches are victims, I'm, not the zero dot. They arrange.

A

Other ranges, yes are.

D

The victors they.

A

Are not macros there's no vectors vectors, they are not they actually so so. This is actually like. Zero dot dot is actually an iterator like, so it is an iterator that, like as it is, so it's not computing like all of the items it is just under the covers. It just has a counter and each time you step through it. It's under the covers, adding one to that value and returning it like.

D

Even though generators in Python- yes exactly yes,.

A

So this is, this is just like a generator versus like iterators, and you.

E

A

So one thing also I forgot to mention about like the coolest thing about iterators- is that that these actually, like you, have all of these low expression, but it like compiles all the way down like into like. You know, pretty much the fastest way that you could write these expressions by hand like all of the like. You could have a huge number of these, like iterator methods being called like you could be mapping filtering, then grouping and then doing another mapping.

A

You can actually do really horrible things to these things and it all just like compiles away into essentially as fast as like possible. So you know all of the cool things that you can do with like Python generator expressions that this is. You know this allows you to do really complex things without come over. Yes,.

F

A

F

Case alveolar, where, where is the store this visit or resume? This talk is in the shape where this.

A

Is a so the this would all be on the stack, but inside the iterator it's opaque, like it could be internally doing something on the heat, so it could like like say, you're like if you want to iterate through a tree structure, but usually you have to have some kind of an internal stack and or it's like keep track of where you are inside this whole thing, so you might have to like allocate some memory, but it's all like. If you don't need to then like it's all along the on on the stack.

A

So it should be. You know quite fast, like okay, so any other questions. Yes, oh wait for the microphone.

G

Is there a way to make a shortcut instead of specifying that the function that you pass to filter or map or fold? Let's type in, for instance, in false that you pass like the name of the method and take that ya.

A

Solution, so you don't need to pass a closure, you could just give it a regular function like you.

G

Get a special syntax or download you just specify the name of potential name: okay, cool.

A

Yeah there's there is one place where you might need to do something slightly.

A

Fancy like if you have a so I haven't, talked about structures, but like instructors are like classes and in other languages, so you know it's an object that has some kind of it has fields and methods, and so, if you have a field that is a function pointer like so someone has assigned like you know one of the fields to a function pointer, then you occasionally need to put parentheses around that in order to help Russ to understand, if you're, trying to like call it versus like passes or something it's complicated like you probably won't see that now and if you ever do run into that, that you always can ask us questions here or like on any of our other resources.

A

Web pages and stuff I was.

E

Wondering in the previous is like you use it it'll and in the next you didn't use it, therefore, for to the folk. So I was wondering when, when I need to you, see Taylor and when not okay,.

A

So so, okay, so there are, let's see so the so in rust, like there are like one of these other things of like trying to pay-as-you-go that there are like for a vector. There is actually a few different kinds of iterators. So I haven't talked about this.

A

Yet there's there are things called reference, so, let's say say: each of these items say they're like some really complicated like expensive, large structure like so not just like these strings, but like something that is using like you know, tens of you know bytes and you don't necessarily want to copy them around. So either is going to create a reference to each of these items and so that all it's doing is under the covers.

A

It's just passing around a pointer to each of those items, so it's very cheap to pass a drop there's also a eight or month like eight or underscore mu T. So this will create a iterator that returns mutable references. So if you want to mutate like change the items that you're stepping through that, like you know it will it will allow you to do that. Then the last version of like a iterator is is a.

A

What do we call it? Brian is like into well yeah into it err, okay. So what this does is that it will consume all of the items. Like so say, you want to like move your expensive structure out of like a vector and into a like a hash map that you don't want to like.

A

You don't want to copy all of that, because it might actually be really expensive to copy these things, so you could actually consume all of the items out of the vector and move them into this other data structure without doing like any copies this would consume all of like it would ultimately destroy the vector because, like there are no more items in it, so there's there's a lot here and you know we'll I think we'll maybe talk about that later on today, but like happy to also talk off the other like during the breaks through all those things so.

A

Any other questions, oh.

A

Okay, so okay, so iterators, so he knows so. This is or one of the other like things that I really like about the language. If you've used C or Java C++, they have enums, which is like you want to have some values that only can represent like these three values, like you know, if we have traffic lights like I'm, not sure here, but in the u.s. like our traffic lights, are red, yellow green, and so we want to just make sure that you know we have some value.

A

That can only ever be these things and if you ever try to do something else, there will be a compile time error and then you can use these with match statements. So here we are just going to do something for each of you know. If it's green, we want to go. If it's red we stop. Yellow we want to slow down, is pretty similar to what you get in in other languages, but in rust our enums are actually like, so much more powerful than that, because we can actually pass in values.

A

So here like say, we were making a little video game and we wanted to, like you know, have you know either decide whether or not we're doing a single-player game or a multiplayer game where we want to say that you know how many players are in this, so you can define it just like you know you have. You know the enum type : :, then the enum variant that you want to use and parentheses the values.

A

And then you can use this with match statements in order to do something special based off of the particular values. So you can do multiplayer with parentheses to you call a thing off about like recommending a game of checkers with two-player game. If you have four people, you can recommend a game, a bridge or if you want to do something for any number of players that you can, you can suggest, like you know something like playing tag. Does this make sense.

G

So this UNAM is some sort of abstract data type. It.

A

Is a type it's it's.

G

Can you do fancy fancy stuff like defining a recursive type yeah like a tree or something yeah.

A

Yeah, so you can, you could very easily write like a tree structure where it's like you know. This could be. You know the root node and then this is like a tree and then you just have a recurse upon itself. Okay, so it's a very simple way of doing these kinds of complex structures. Thank.

G

A

Any other question: okay, so now I'm gonna start getting into things that are particular to rust itself, so the okay, so we saw enums before so one of the one of the other things that is special to rust is that we do not have this null type that you might have seen in other languages or nil. So there's like for all of our values, they you can't just assign null to them.

A

This is because, like they're just so many problems with like people dealing with like null pointer exceptions, getting thrown or, like you know, if you're in C, if you try to dereference a null pointer, who knows what could happen? You know someone could use that as avenue for compromising your your system, so we we've defined in our standard library. What we call is the option type, so this is just a normal in um that you know either represents some value, and this is a generic type.

A

So you know you have like this less than symbol, T greater than symbol. If you see it's just like generic types and and C so this option can represent like you, can use an option type in order to represent any any value and then like you, have to explicitly do a match statement in order to unpack the the option type.

A

So as an example like here, like you know, a lot of our libraries are written such that you know it's going to use option types in order to make you force you to handle the case that maybe there might not be a value. So here we have a vector, like you know, the vector just has my name in it and if we use the pop value, which just removes the last item in a row and if you print it out, then you will you should get a it should say.

A

You know a is some Eric, but if we call this again like at this point, the the instructors list is empty. That pop will return, none for you, so you know it. Will it forces you to like handle the case that, like you know that you might not actually have a value?

A

So you could either you can define a value by just doing some eric now option is like really popular, so you don't need to explicitly say: option colon colon.

A

Some we've imported this into the the namespace for all of you, so you could either use the match statement in order to pull apart like to handle the case that there's a value in the option, type or there's also a function that like, if you know like you're, doing just like some experimentation, or you know that it's impossible that you know this value will always have something that you can use.

A

This dot expect method and if it ever turns out that the OP that this value actually is none, then it's going to throw a panic and abort your program. So this is nice for your simple testing, but generally speaking like in real programs, you you shouldn't be using expect you should you should explicitly handle the use cases.

A

Does this make sense any questions?

A

Okay, so here's? This is just an example of using match in order to do something for a particular value like in this case, like we define a option. Type that you know has no value like we're using a none, and so when we match on this value, it's going to print out. You know name, but if you change this sum that you would you get a name printed out.

A

So the next thing that you know we have is what we call is a result type. So this also is just another enum, but this is generic on on two different types, so you could either like. If so this is like, we don't have exceptions in our language. This is how we we handle errors.

A

So so you either have the case that everything's fine and you get a okay value in your enum or you get some error and you know the system is you have to do something, but you don't necessarily want to abort the process like say you're, trying to access a website and it turns out the websites down that you don't want to kill your program. You want to, like maybe retry in five minutes when the websites back up.

A

So here's just like another example like in this case, like we're, trying to parse a string into a number. So this is another method that we have dot parse. So in this case, like parse like we can do parsing into a lot of like different types. So this is just one of the ways that you explicitly say: I want to parse this value into an I-32, a signed, 32-bit integer.

A

We we called this little expression. The colon colon angle bracket closed angle bracket the rocket fish because it kind of looks like a fish. That's moving really fast, so this will return a result. Type it will be like num will either be okay because, like in this case, it's actually an integer or if we are passing it a string, that's not a integer that it will be an error type.

A

You're welcome to try to run this now or if we can do this later, I think we're starting to run low on time. So here's like result also has the dot expects, which is just like what we had for options. So if you want, if you are like, if you're confident that you're always going to like the thing is going to succeed, then you can use expect and it will ill afford the program. It will panic the program if there is, if it turns out that your expectation was wrong.

A

Any questions about results are often okay, oh and then here is just like the match. Expression I think someone earlier was talking about using match as like part of like an expression.

A

So this is an example of this, so here we're parsing an integer, and then you know if it turns out that it's an integer, then we're just going to add 5 to it, but otherwise, in this case we're going to you know, we check to see it's an error and there's the underscore saying like we don't care what the error message is and we're just going to return zero.

A

So are one of the cool things like as another digression to this is that if you actually leave out like in a match statement like say we we remove the error statement, rust will actually will at a compile time. Errors say like hey: you haven't handled all the cases, so this is like a way that, like you know, it will make sure that they, you are like, if there's something that you a condition that you weren't handling like rust, will actually province, making sure that you're handling these conditions.

A

Okay, so the oh, yes,.

A

D

What does mean the double column after the birth? This.

A

This is so this is. This is the rocket fish, so this is saying that I am parsing like I, want to parse this value and that I want the I want you to parse into this particular type like so this will say the return value is going to be an I-32.

A

This is using like some generic programming that is like you could substitute this into like a I 64. If you want a 64 bit type but Parsons generic, so you can actually use parse for, like you can actually customize it. So if you have like your own type that you want to parse like say, you want to parse a string into some URL structure that you could. You could implement this parse thing, and then you know it's just you can use it like that.

A

That's getting you know a little bit more advanced, so I'm, not sure we'll end up talking about that, but I'm happy to talk offline, any other questions. Yes,.

G

So, in this case, the num variable is going to match that error. Okay, yes, equal is going to be its value. They.

A

Would would be the value for the air yeah like so this is a this will be some error type, so you can actually like. It depends on like this actually is like the error is coming from parse, so I think like parse could have its own error type thing like hey I, try to parse this thing, but the second character is a letter, not a.

G

Number, so you you have to split idli, throw the section through to the sender how good yes, yeah.

A

If you want like, if you are, if you are expecting a particular error type like you could like this could be something like you might want to manipulate. You might like a might say: hey. You should retry this inside seconds like it really depends on on the B implementation, okay, huh but that's actually a good lead-in to the next section that so sometimes you actually don't want to care about. Like the error message, like you know, like say you know, you are expecting like you're implementing something to you know.

A

You want to parse some string and then you want to add some number like 5 to it, but you don't like if it turns out that you're passing in a something. That's that's, not a string. You just want to like throw that error up to the the person who's, calling you and make them handle it.

A

So we have a shortcut called like the question mark operator, so you can just add that at the end of something that's returning an option and if it's, if it's a error, that it will automatically return a result, type or a result, value up the to the next level. But if it's, if it's, if it's okay, it's going to automatically unpack the result type for you and return the value. So you know the result of this is going to be. You know just another integer and then you can add to it.

A

In order to do this, you have to be using a function that is returning a result. Type though so in this case this is the the error type that that you're asking about before, and then you have to.

A

You have to make sure that, like you know you, you repack the result value in okay in order to like make sure that it's a result, type yeah.

G

Okay, so it's like, if you're always running code inside a try block or something like that, yeah.

A

Yes, it's like that, so it's! This is all it. This is what we call syntax sugar. So it's things that you could write explicitly by hand if you wanted to, but we for common cases we want to like make it. You know a little bit simpler for you in in most cases thank.

G

F

Hi so in this case use a clear result as on 2v2 integer and parse int arrow yeah, a new handle the okay answer, the okay result, just returning the the addition of the passing result plus five. So there is no air value because you are truly not the case of the parsing error. Yeah.

A

So so what so, when you use this question mark, so if say this, we passed in a a non integer string that this just as a short circuit, and it were just like return a it- will just return. The error, like this error up to the chain, but then there also like you know, will like, if everything's, okay, that it will like this expression, will evaluate into the parsed integer. Does that make sense?

A

Okay and then we just have to rewrap it and in the result, type in order to propagate up one of the other things that you can do like in this circumstance we're returning in I 32, but you could also like say we wanted to like reparse, listen to a string or like return, some other value that we could. The okay type could be something else if we wanted it any other questions before moving on.

F

A

Okay, so strings so I mentioned that strings are really complicated us and we're sorry about that. We we are trying really hard to come up with simpler ways of dealing with strings the the reason why they're complicated is because this is also like this whole explicit versus implicit like we're, trying to make it so that like, if you need to you, don't have to pay for something expensive, so strings are allocated they're, just they're, really just like vectors like they under the covers are allocating a block of memory.

A

You can, you can add, characters to string you can you can remove characters, it's it's easy to manipulate, but you don't necessarily always want to be allocating. You know strings like you know, if you're in a if you're, implementing a operating system that you don't want to like do unnecessary work of like string manipulation. It's like you can just pass round static, string arrays. So we also have this thing called like ampersand serve.

A

So that's that's what we call a string slice, so string slices are just a their view into a strength, so they like under the covers. They are really just a pointer and a length they so they're very cheap to copy around.

A

So where is like with strings you you, you like it's expensive to construct them like with with string slices, it's pretty cheap, so you know so one of the one of the common problems that you will probably run into and rust. Yes, oh yes,.

B

Thanks and the.

G

First example: something a string, a number of.

F

Boolean R objects or something yes,.

A

Yes, what's that again, a number.

D

I 3200 Leon are objects.

G

We can use the method to drink. Yes,.

A

Yeah, so the like, so you can actually like we've liked on all of the primitive types I think we've defined to string and that you can, you can manually, add them to types that you create yourself. So we try to add a lot of like helper methods that make things like this a little bit simpler.

F

A

They are like eight work like they are objects, in a sense that they are not message. They are not like allocated they're like real. You know they just fit inside of register inside of the CPU, but yeah they are kind of like objects. It's theirs yeah. They gets a little bit more advanced when we start going into that. So any other questions.

G

Is this one case of the spherical abstraction, so in terms of performance this you can consider this built-in value, but you manipulate it as an object. Well, so the.

A

Like so like, so if you call like, you, have an integer and you call dot to string on it that that is going to it has to allocate memory, has like parse the thing into some some string, so that is like there is some cost associated with it. But if you don't ever call to string on it that you aren't going to be allocating memory, okay,.

G

A

That is, like you know, part of our philosophy of like we as much as we can. We want it to be like opt in that, like you can always do things that are more expensive, but like we try to make sure that you don't have to do the expensive thing, but this is one of the ways that like Russ makes it like. We try to make you know in most cases, everything like as fast as I see any other questions.

C

Just a quick question: is there a preferred way of like to string or to specify it, but not.

A

Really Mac there's there's no like performance difference between calling to string or string from like it. If, like frankly, it just depends on you know, there's it's you know they're. So under the covers they're, like you know, we have these things called traits and like there are ways that you can generically program like you can make a function that says, like I, want to be able to take a generic type that has the ability to call to string on it, but I don't really care about what the type is so like.

A

There are some things like when you're going down there that, like you, might want to use one function or the other, but for the most part it doesn't really matter it's at this point, it's kind of like a style. It also is like somewhat of a implementation. Detail like as like some of these methods, like wewe, had to do some some changes inside the compiler in order to make them more efficient so that there are some like there's. Also another method called owned.

A

That does the same thing at one point in time, owned was cheaper than to string, but it's not anymore. So it's a like we are like. We are ultimately trying to like all the changes in rust. Like you know, we are trying to evolve the language over time in order to make it faster, but we also don't want to break people's code. So there's you know it's. You know there. There are a few things that are like. There are not necessarily the like the best way of doing things, but you know that's the life.

A

We have to live with, like lots of people using our language, okay, so the common problem that you all are going to run into is like you know, there are some cases where, like here, we're passing in an integer and we want to see if it's divisible by 3 and if so we want to return fizz.

A

Otherwise we want to just return. The number like you know it's just kind of a silly example. So if anyone is playing along is if you get the error message, anyone, okay! So if not you'll actually get an error. Saying, like you know, fizz is a string size, but you know you're trying to return a string.

A

So this is one of like the kind of the annoying parts of rust that, like we're trying to figure out, if we can, we can do this a little bit better, but usually you might just need to add like a dot to string on one of these. You know the the strings, because when you write like quotes something end quote: that's actually a string slice like it's. It's it's a compile-time thing. There's no reason to allocate memory for that, because we can.

A

We can store it in the executable itself, so you might just occasionally need to do these ads with the to string any questions. Oh yes,.

G

So if the stream flies and that in the stream is, can you see them some like in JavaScript that box values of that building, because in in JavaScript you can say new, extreme and we're a value? So it's something like that. You get like more functionality. Out of that a box, a stream that row a stream not.

A

Well, so you do have more functionality with with strings rather than string slices like strings you can you can mutate, like you can add, you can depend on extra like characters or even like other strings, but you can't do that to string slices because they they are just pointing to some memory. It's possible there you're actually looking inside of some other strings, so you can actually append values to it. So.

G

When, when you, when you define a variable with a mod keyword, a string in this case, are you, so you don't have to say anymore to a string is already an extreme, but if you don't use, the mod is going to be. A string looks like the.

A

No, so the so the okay, so the let's see how to answer this. So the south we say, okay so say we didn't have like so we're say we're here. So you're asking what happens if we didn't have the else expression, I.

G

Mean well at the time that you initialize up a stream variable is going to be a stream fly, so it's going to be a stream it. So the.

A

This will always be a string slice like you know, having like it doesn't automatically convert itself into a string. You have to explicitly call like to string on the you know this thing in order to make it into like a you know: a string with a capital S. Okay.

A

Does that answer your question then? Okay,.

A

Any other question over here.

D

Of the strings with capital, a bullet like in Java that you have a string pool and you can optimize the reference to strings so.

A

We don't have a string pool like under the covers this like we are. This is just like pointing out a block of memory that it's it's allocating. It is possible to write things that are trying to to to implement like pull strings. If you want it's just not in the standard library, I know that the rest of the Pilar has as one of these things in order to try to save on copying strings. So if it's a it's pretty common pattern, if you need it, okay,.

D

And the things posed are in the text segment. Sorry, those the strings it slices are in the text segment. Yes,.

A

ah Maybe so this you're talking about inside the cook the executable like the static section so this so this string actually would be in this static section, but it's also possible to create a string slice of like pointing inside of another string. So actually I think I talked about that oh yeah, under these the slices were there any other questions before we get to slices okay.

A

So, as I was saying, like string slices our views into some memory, so this is just a pointer at something, so it could be a pointer into the static part of the binary. So this is like you know it's completely free, like you know, there's there's! No, it's not on the stack. It's just like you know one of these things, but it can also be pointing inside of like some allocated string, the other. So the other thing about slices is that it's also understand how long of a slice it is.

A

So if you are looking at some allocated string that you might only be looking at a subsection of this string so slices like, we also have like array slices as well, which are the same as string sizes.

A

So you know here so we have a vector type, which you know, I, don't think I actually explicitly said is Veck of, like you know, a BEC of high 32s that a array slice into that back is just, whereas like ampersand bracket, then to type so in this circumstance like we have a vector of five items say we only want to look at the last two items in the the vector that you can use the you know the so it's kind of hard to see this is like ampersand V or the V is the the value that we defined before that.

A

We then use the range expression in order to say we want to look at like from the third item, all the way to the end. So this should, if you are writing this in in code, will print only like when you print this. It will just print out four and five.

A

So just like, oh yes, is there that microphone.

H

So I'm kind of out of the loop with rod. This is actually the first time I'm, seeing this rod hint of syntax and a.

C

H

Coming from go and I see that this is right and like liking in go where you have a static right, that if the sights are right and you can make it dynamic and make a dynamic array using this light, is this correct? Is this liking implementing.

A

Lingo, it's not quite like I! Think in so I I haven't done much go but I think in go slices. You can you can append items to a slice if yeah.

H

Yeah I think yeah. They create on the right if they.

A

Yeah, you can't do that like, so there are a lot of like methods that you can do to two slices, but you cannot. Actually you can't change the length of base lives.

A

However, it actually is possible, like you, can take a sub price of a slice so yeah after we've, like created this slice, you could be like I want to look at the first two items in this slice as all that is possible to do, but you can't actually manipulate the the underlying data structure and grow it to be like bigger or larger or smaller.

A

Thank you. Okay. Any other question.

D

Though they I don't know the the vectors or the slices is those have a header for the links or some property of the memory that they are pointing to so.

A

The vector does so the vector has under the covers. It has like a block of memory, and it knows how much memory has been allocated for the slices. All our slices is a pointer to like some, you know, someplace in memory and then the amount of items in that slice, so all it is, is just a pointer and alike. Okay,.

G

If, if you safe to assume that any method that I have fun on back doors like filter, whatever are going to be available on our eyes? Well, yep, it's part of the philosophy of the standard library belong dish, yeah, okay, that's nice! Oh.

E

A

E

A

I think we're we only have one other thing to cover so well: okay, actually we're two other things. So, as I mentioned that there are string slices there, just like sector slices. So here we can. You know we create some some string and then we can do a slice inside of that in order to only look at the first four four characters. So one thing with strings: if you ever do this- that we're actually looking at the number of bytes, not the number of characters.

A

So if you ever need to look at just the first number of characters like there are other methods for that, it turns out that like strings and encoding and utf-8 and like what exactly is the character versus the glyph versus, like all sorts of other things, so it's really complicated.

A

So if you ever need anything like that, you can ask for help and I can point you at documentation.

A

Okay, so the last thing- and this is actually one of the most important concepts in rust- is so I- think we're going to be talking about this a lot more later on today. But ownership is all about like how rust is able to work without needing garbage collection like at a really high level.

A

It's actually it's a relatively simple thing like it's like you know it is the compiler tracks who owns what so in this circumstance, like you know, I at this water bottle like if I give this to someone else, then you know their responsibility. They can do whatever they want with the water bottles. They could throw it away or they could give it back to me. So this is this is basically you know like by tracking this and the compiler.

A

Then the compiler knows when to deallocate things, so so under the covers we're implementing this with like free and malloc. So we're doing all that memory management for you, so the as I mentioned that there's this whole transferring ownership. So, like you know, if you want to like here, we've allocated some block in memory and then we call this function print Veck.

A

So this actually is going to produce an error because we're actually like in this first line we're transferring ownership of this vector to the function and then at the end of the function it actually is going to delete all the memory associated with the vector. So when we call quick Beck again, we actually, this is going to result in a compile time. Error saying that you know the vector was moved into this other function. Does that make sense?

A

Okay, so you don't always want to be moving these things around, because that's actually inconvenient, like you know in this case like we just want to print out a vector, and so we don't actually need to take ownership over that. So this is where references come in, so references is help us implement borrowing. So this is saying, like you know, I want to retain ownership over a piece of things like you know, my water bottle I'm going to loan it to you for you to, like you know, I could either you know in this case.

A

I could just you know, I want you to give it back to me when you're done with it, so the way that we represent, like you, know, giving someone else a reference to something is by using this ampersand symbol. So this is just saying like I want to, like you, give someone a temporary loan, but I want to own it, so that I can delete it when you're done with it. So here this should work fine, where we are just doing an and present.

A

So one special thing about the syntax is like we are doing like we actually like the way that you create a slice from a vector. As that you do this ampersand. You know the value, then we do dot dot. Saying like we want to grab a slice of the entire thing and then down here. We just have a slice that you can print out. So the nice thing here is that you could actually use this.

A

This method, print SEC with you know, if you have one of these, like an array, that's stored, like a static array, that's stored inside, like the executable that you can't modify, that you can use this function on it as well as using it with like vectors that are dynamic. This is also really useful for Strings, like if you want to be able to use one of these methods to print out strings.

A

So the other thing that I kind of touched upon with iterators is that you can have mutable references as well. So say you want to pass like I, have a vector I want to allow someone to modify one of the values inside of my my array, slice that you can use just ampersand mut and pass it. You know this slice and then it's okay for it to change it, and then you can do this a few times and then print it out, but it shouldn't be a problem. Are there?

A

Are there any other questions about this like this? Is the studs get complicated? So it's okay! If, like you know it sounds okay now, but it might get confusing later, but we're here to help yeah.

F

In the interchange web function, if the square brackets really needed- or you can just put it be so.

A

You could just do, ampersand might be, and so the what I can actually remember is is. Is that going to give you a amperes like a reference to a vector or if it's going to like under the covers, give you a reference to splice I, think it might do that. This might just be all that marks explicit.

A

Yeah any other questions.

D

Can you return the reference it.

A

Depends so the like? You say you had you know your this wasn't the main function. It was just something that created a like: it created a vector, and then you try to return a slice to that the you would actually get a compile-time error, because you know someone has to delete the memory, so the in that circumstance like the compiler would say like at the end of this function, I'm trying to delete this thing, but you're trying to return a reference to something that.

A

However, there are ways of like you can have methods, so you could express a method that is returning a reference to something and, like you know, as long as you like, someone is like the original object that but has the block of memory that you want to return a reference to as long as that is still alive, that you can return references to it so that that gets into. Hopefully, we'll talk a little bit more about that today. If not like you know, there's I I can talk offline about that it.

A

That is like trying to get into like some of the complicated advanced things that we can do with with references any other questions.

A

Okay, so okay, so I would. The last thing is that, like this is one of the other fancy things that rust has. Is that you, you cannot have like a mutable reference active at the same time as any other references. So here like say, we have a vector.

A

We grab a immutable reference to one of the items inside this vector, and then we try to clear memory so in languages like C this can actually. This is actually one of the really big sources of like you know, causing you know, security exceptions because, like you now have this you're, pointing at like undefined memory and who knows what that's pointing to so. This is the result in the compiler.

A

This is also going to be, like probably one of the areas where Russ gets kind of confusing, like it might take a little bit of time to like understand how to manage mutable references and immutable references to things. So, if you feel confused about this, that's normal we'll help you get through all of this so Oh were there any other questions about this.

A

Okay, so, finally, all right. So that is there's a lot of other things that I am NOT going through, but we're going to talk about some of these things later on today, but you know this hopefully gives you. You know a little bit of a touch of like you know all of the the core concepts in the language.

A

So you know you might run into these today. You might run with them run to them over the next couple weeks, as you play with rust. There's lots of really cool things out here, so yeah, so the so yeah. These are just some of the concepts.

A

So the last thing that I want to mention before I'm done and then like I'm, actually going to be done, is that, like I mentioned a long time ago about like cargo and cargo crates that we actually have like a really large community that has been building like a bunch of libraries that you can use like this is one of like our big things that we are trying to encourage our our ecosystem to develop, like so I grabbed this picture from a few days ago. This is our website, crates, IO.

A

So you can see here that, like we've already had 9600 individual libraries that you can use, but all you have to do is add a line in your cargos, a Tamil file and you can just start using like any number of these things and we've already had like over 161 million people or vote. You know million downloads of all of these different grits, so we have a really large ecosystem.

A

We are trying to make it so that, like you, don't necessarily need to like implement a lot of things they you know we can have a really broad standard library without actually having to implement it all ourselves. So with that, I am I'm done. Thank you. So much so I don't know if we necessarily have time for a question because I'm really over time, but so thank you all. Thank you all for paying attention and barring missing.

D

D