Technical requirements

For this chapter, we only need access to the internet as we will be using the online Rust playground to implement the code. The code examples provided can be run in the online Rust playground at https://play.rust-lang.org/.

For detailed instructions, please refer to the file found here: https://github.com/PacktPublishing/Rust-Web-Programming-3E/tree/main/chapter01

What is Rust?

Rust is a cutting-edge systems programming language that has been making waves since Mozilla Research introduced it in 2010. With a focus on safety, concurrency, and performance, Rust is a formidable alternative to traditional languages like C and C++. Its most notable feature, the ownership system, enforces rigorous memory safety rules at compile time. This approach effectively eradicates common pitfalls like null pointer dereferencing and buffer overflows, all without needing a garbage collector.

Designed for high performance, Rust provides granular control over hardware and memory, making it perfect for developing operating systems, game engines, and other performance-critical applications. Its syntax is both modern and expressive, offering features typically seen in higher-level languages, such as pattern matching and algebraic data types, while retaining the efficiency required for system-level programming. Consequently, Rust has rapidly attracted a strong and active...

Reviewing data types and variables in Rust

If you have coded in another language before, you will have used variables and handled different data types. However, Rust does have some quirks that can put off developers. This is especially true if the developer has come from a dynamic language, as these quirks mainly revolve around memory management and reference to variables. These can be intimidating initially, but when you get to understand them, you will learn to appreciate them.

Some people might hear about these quirks and wonder why they should bother with the language at all. This is understandable, but these quirks are why Rust is such a paradigm-shifting language. Working with borrow checking and wrestling with concepts such as lifetimes and references gives us the high-level memory safety of a dynamic language such as Python. However, we can also get memory safe low-level resources such as those delivered by C and C++. This means that we do not have to worry about dangling pointers...

Controlling variable ownership

As we remember from the beginning of the chapter, Rust does not have a garbage collector. However, it has memory safety. It achieves this by having strict rules around variable ownership. These rules are enforced when Rust is being compiled. If you are coming from a dynamic language, then this can initially lead to frustration. This is known as fighting the borrow checker. Sadly, this unjustly gives Rust the steep learning curve reputation, as when you are fighting the borrow checker without knowing what is going on, it can seem like an impossible task to get even the most basic programs written. However, if we take the time to learn the rules before we try and code anything too complex, the knowledge of the rules and the helpfulness of the compiler will make writing code in Rust fun and rewarding. Again, I take the time to remind you that Rust has been the most favorited language 9 years in a row. This is not because it's impossible to get anything...

Building Structs

In modern high-level dynamic languages, objects have been the bedrock for building big applications and solving complex problems, and for good reason. Objects enable us to encapsulate data, functionality, and behavior. In Rust, we do not have objects. However, we do have structs that can hold data in fields. We can then manage the functionality of these structs and group them together with traits. This is a powerful approach, and it gives us the benefits of objects without the high coupling, as highlighted in the following figure:

We will start with something basic by creating a Human struct with the following code:

#[derive(Debug)]
struct Human<'a> {
    name: &'a str,
    age: i8,
    current_thought: &'a str
}

In the preceding code, we can see that our string literal fields have the same lifetime as the struct itself. We have also applied the Debug trait to the Human struct...

Summary

With Rust, we have seen that there are some traps when coming from a dynamic programming language background. However, with a little bit of knowledge of referencing and basic memory management, we can avoid common pitfalls and write safe, performant code quickly that can handle errors.

In this chapter we also covered the concepts of borrowing and referencing in Rust. While adhering to borrowing rules requires more effort than coding in a garbage collected language, we have a deeper understanding of how variables are placed in memory. This deeper understanding is safer as we know exactly what data we are pointing to. For instance, if we were using a language like Python and we created an instance of an object when we then passed into two dictionaries (python's version of a hash map), then if we updated one instance, the other would also be updated because it is a shared reference to the same memory address, the developer however may never know. In Rust, the borrow checking...

Questions

1. What is the difference between a str and a String?
2. Why can't string slices be passed into a function (string slice meaning str as opposed to &str)?
3. How do we access the data belonging to a key in a HashMap?
4. When a function results in an error, can we handle other processes, or will the error crash the program instantly?
5. Why does Rust only allow one mutable borrow at a point in time?
6. When would we need to define two different lifetimes in a function?
7. How can structs link to the same struct via one of their fields?
8. How can we add extra functionality to a struct where the functionality can also be implemented by other structs?
9. How do we allow a container or function to accept different data structures?
10. What's the quickest way to add a trait, such as Copy, to a struct?

Answers

1. A String is a fixed-size reference stored in the stack that points to string-type data on the heap. A str is an immutable sequence of bytes stored somewhere in memory. Because the size of the str is unknown, it can only be handled by a pointer &str.
2. Since we do not know the size of the string slice at compile time, we cannot allocate the correct amount of memory for it. Strings, on the other hand, have a fixed-size reference stored on the stack that points to the string slice on the heap. Because we know this fixed size of the string reference, we can allocate the correct amount of memory and pass it through to a function.
3. We use the HashMap's get function. However, we must remember that the get function merely returns an Option struct. If we are confident that there is something there or we want the program to crash if nothing is found, we can directly unwrap it. However, if we don't want that, we can use a match statement and handle the Some and None output as...

Further Reading

1. Hands on Functional Programming in Rust (2018) Andrew Johnson: chapter one (generics and structs)
2. Mastering Rust (2019) Rahul Sharma and Vesa Kaihlavirta: chapter one (A tour of the language)
3. The Problem With Single-threaded Shared Mutability (2015) by Manish Goregaokar: https://manishearth.github.io/blog/2015/05/17/the-problem-with-shared-mutability/

Rust Project Developers, 2024. The Rust Programming Language. [online] Available at: https://doc.rust-lang.org/book/ [Accessed 21 June 2024]

Latimer, N., 2020. Programming Rust. [online] Available at: https://doc.rust-lang.org/stable/rust-by-example/ [Accessed 21 June 2024].