Gain insights into Rust programming fundamentals, explore its syntax, ownership, and type system, and delve into core components like memory management, traits, and generics to enhance your skills.

Rust is quickly becoming one of the most popular languages. With a strong basis as a systems and embedded language, its clean design and ergonomics makes it an emerging choice for general purpose programming tasks as well. This course will be your guide to the fundamentals of programming and Rust. Whether you have no experience or want to learn a new language, this is the place to start.

In this course, you’ll start off with the basics of the Rust programming language, learning the syntax, the philosophy of the language, and the anatomy of Rust. With that in hand, you’ll move onto some of the more unique parts of Rust, such as expression-oriented programming, ownership, and its strong type system.

In the latter half of the course, you’ll work through some of the core components of Rust such as references, memory management, mutability, traits, slices, and generics.

By the time you finish, you’ll have the foundations in place to learn more advanced concepts and take your Rust programming to the next level.

The Ultimate Guide to Rust Programming

There’s a big restriction on program memory versus stack; once the compiler creates your executable, the program memory is frozen. When your executable is running, it cannot change data in program memory or add new things there.

Let’s give a simple program we’d like to make work somehow. I’d like to create a new string that combines my first and last name together. Naively, I would try to write something like this:

fn main() {
    let first_name = "Michael";
    let last_name = " Snoyman";
    let full_name = first_name + last_name;
    println!("Full name is {}", full_name);
}


This program doesn’t work. We’ll look at the compiler error in a bit to get help fixing it. But first, let me ask you a basic question, where should the `full_name` value live in memory? We know it can’t live in program memory, since this string is going to be created while the program is running, after the compiler has frozen the program memory data. And it can’t live on the stack, since this is a dynamically sized type.

It’s time to introduce the third part of memory, the heap. The heap allows for *dynamic allocation*. This means that you can ask for a certain amount of memory, and be handed an address to that memory. You can then work with that memory as much as you want, and when you don’t need it anymore, you can *free* it so that it can be used again by your program or another program running on your computer.

What we would need to do in order to create `full_name` is:

  - Count the size of `"Michael"`, which is 7

  - Count the size of `" Snoyman"`, which is 8

  - Ask for a chunk of 15 bytes on the heap to store all that data

  - Copy in the first name at the beginning of that chunk

  - Copy in the last name after the first 7 bytes of that chunk

Fortunately for us, that’s exactly what an *owned string*, or the `String` data type, does. The `String` data type manages a chunk of data from the heap for you. It holds onto the address of that piece of heap address and does all of that data copying.

And here’s the great part: since the address it holds has a static size, `String` is a statically sized type, meaning it can live in the stack. In other words, an owned string lets you own a chunk of memory that can be created dynamically.

OK, let’s go back to that broken program above, and let the compiler tell us how to fix it. The error message our program generates is very helpful:

```text
error[E0369]: binary operation `+` cannot be applied to type `&str`
 --> main.rs:4:32
  |
4 |     let full_name = first_name + last_name;
  |                     ---------- ^ --------- &str
  |                     |          |
  |                     |          `+` cannot be used to concatenate two `&str` strings
  |                     &str
  |
help: `to_owned()` can be used to create an owned `String` from a string reference. String concatenation appends the string on the right to the string on the left and may require reallocation. This requires ownership of the string on the left
  |
4 |     let full_name = first_name.to_owned() + last_name;
```

The `+` operator does not work on references to string slices. However, the compiler mentions the method `to_owned()`. And it even tells you how to rewrite your program to use `to_owned`.

**Exercise**

Follow the advice of the compiler and fix your program. The output should be:

```text
Full name is Michael Snoyman
```

Welcome to Begin Rust

Hello World and variables

Anatomy of Rust

Functions

Booleans

Conditionals

Mutable variables and while loops

Structs and ownership

References

Methods

Strings

Arrays, Vecs, and slices

Type parameters

Traits

Enums

Iterators and for loops

Early exit

What’s next?

Owned Strings