feat: update docs order and examples

Author: jeastham1993

docs/docs/module0/2_why_not.md

@@ -4,12 +4,12 @@ sidebar_position: 2
 
 # Why not Rust
 
-1. **Learning Curve**: I'll be honest with you—Rust has a steeper learning curve than many languages, including C#. The ownership and borrowing concepts will challenge you, especially in your first few weeks. You'll likely experience what Rustaceans call "fighting with the borrow checker" as you learn to structure your code to satisfy Rust's strict rules. Don't be discouraged! The struggle is temporary, and most developers report a "click moment" when these concepts suddenly make sense. The compiler provides extremely helpful error messages that guide you toward correct code, and the community is exceptionally welcoming to beginners.
+1. **Ecosystem Maturity**: While the Rust ecosystem has grown impressively, it's still younger than .NET's. Some specialized libraries might be less mature or feature-complete than their .NET counterparts. You may occasionally need to implement functionality yourself that would be available out-of-the-box in .NET. The good news is that the ecosystem is growing rapidly, and many libraries are already production-ready.
 
-2. **Ecosystem Maturity**: While the Rust ecosystem has grown impressively, it's still younger than .NET's. Some specialized libraries might be less mature or feature-complete than their .NET counterparts. You may occasionally need to implement functionality yourself that would be available out-of-the-box in .NET. The good news is that the ecosystem is growing rapidly, and many libraries are already production-ready.
+2. **Team Adoption**: If you're working on a team, transitioning to Rust requires bringing everyone along on the learning journey. Finding experienced Rust developers for hiring can be more challenging than finding .NET developers, though this is changing as Rust's popularity continues to grow. You'll need to factor in training time and potential short-term productivity impacts when considering adoption.
 
-3. **Team Adoption**: If you're working on a team, transitioning to Rust requires bringing everyone along on the learning journey. Finding experienced Rust developers for hiring can be more challenging than finding .NET developers, though this is changing as Rust's popularity continues to grow. You'll need to factor in training time and potential short-term productivity impacts when considering adoption.
+3. **Compile Times**: Rust is slower than compiling code than .NET. The compiler toolchain is complex, and as you'll see throughout the workshop there are a lot of safety checks that happen at compile time. This is beneficial, as it removes a whole class of runtime bugs. Equally, you will find yourself sat around waiting for compilation to happen. Particularly if you're working on a large code base with lots of dependencies.
 
-4. **Compile Times**: Rust is slower than compiling code than .NET. The compiler toolchain is complex, and as you'll see throughout the workshop there are a lot of safety checks that happen at compile time. This is beneficial, as it removes a whole class of runtime bugs. Equally, you will find yourself sat around waiting for compilation to happen. Particularly if you're working on a large code base with lots of dependencies.
+4. **Strictness**: The Rust compiler is strict. At some point in your Rust journey you'll find yourself swearing at the compiler wondering why the code you've written won't compile. The strictness is intentional, it stops you being a lazy programmer. Eventually, you'll come to appreciate this feature. I promise.
 
-5. **Strictness**: The Rust compiler is strict. At some point in your Rust journey you'll find yourself swearing at the compiler wondering why the code you've written won't compile. The strictness is intentional, it stops you being a lazy programmer. Eventually, you'll come to appreciate this feature. I promise.
+5. **Learning Curve**: I'll be honest with you—Rust has a steeper learning curve than many languages, including C#. The ownership and borrowing concepts will challenge you, especially in your first few weeks. You'll likely experience what Rustaceans call "fighting with the borrow checker" as you learn to structure your code to satisfy Rust's strict rules. Don't be discouraged! The struggle is temporary, and most developers report a "click moment" when these concepts suddenly make sense. The compiler provides extremely helpful error messages that guide you toward correct code, and the community is exceptionally welcoming to beginners.

docs/docs/module2/8_mutability.md

@@ -0,0 +1,34 @@
+---
+sidebar_position: 8
+---
+
+# Mutability
+
+:::important
+
+Every variable in Rust is immutable by default.
+
+:::
+
+To see this in action, go and run the `module3` code:
+
+```rust
+let integer_example = 99;
+integer_example = 12;
+```
+
+And oops! There's a problem:
+
+**error[E0384]: cannot assign twice to immutable variable `integer_example`**
+
+So how would you go about declaring a variable that you could change? That's easy, introducing the `mut` keyword.
+
+:::important
+The `mut` keywords explicitally declares a variable as something you want to mutate later. If you declare a variable as mutable but never actually change it, the compiler will give you a warning and recommend you remove the `mut` keyword. Neat!
+:::
+
+```rust showLineNumbers
+let mut str_example = "This string is now mutable";
+str_example = "And can be edited";
+println!("{}", str_example);
+```

docs/docs/module2/8_challenge.md docs/docs/module2/9_challenge.mddocs/docs/module2/8_challenge.md renamed to docs/docs/module2/9_challenge.md

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 8
+sidebar_position: 9
 ---
 
 # Challenge
@@ -12,7 +12,7 @@ Open up Activity Monitor on Mac, or Task Manager on Windows, and then run both t
 
 ## Challenge
 
-The code in [src/examples/module2/rust_app](/src/examples/module2/rust_app/) contains the beginnings of a user management application. But it **doesn't compile** 🥺, your challenge is to get this small code snippet working. There are issues with borrowing, ownership and mutability.
+The code in `src/examples/module2/rust_app` contains the beginnings of a user management application. But it **doesn't compile** 🥺, your challenge is to get this small code snippet working. There are issues with borrowing, ownership and mutability.
 
 If you get past that, you can also try to better handle errors in the `update_name` function. Instead of always updating the name, let's return an error if the length of the new name is less than or equal to zero.
 

docs/docs/module3/3_0_mutability.md

@@ -2,22 +2,6 @@
 sidebar_position: 3
 ---
 
-# Mutability Part 2
-
-If you delete the line assigning the `integer_example` then congrats 🎉 You're a Rust developer now.
-
-So how would you go about declaring a variable that you could change? That's easy, introducing the `mut` keyword.
-
-:::important
-The `mut` keywords explicitally declares a variable as something you want to mutate later. If you declare a variable as mutable but never actually change it, the compiler will give you a warning and recommend you remove the `mut` keyword. Neat!
-:::
-
-```rust showLineNumbers
-let mut str_example = "This string is now mutable";
-str_example = "And can be edited";
-println!("{}", str_example);
-```
-
 ## Shadowing
 
 When you're working with Rust, you'll often encounter a concept called shadowing. Here's how it works:

…cs/docs/module3/3_5_mutability_part_2.md docs/docs/module3/3_shadowing.mddocs/docs/module3/3_5_mutability_part_2.md renamed to docs/docs/module3/3_shadowing.md docs/docs/module3/3_5_mutability_part_2.md renamed to docs/docs/module3/3_shadowing.md

@@ -31,8 +31,6 @@ async fn main() {
     let bool_example: bool = true;
     println!("{}", bool_example);
 
-    integer_example = 99;
-
     // Everything is immutable by default in Rust
     let mut mutable_string = "Hello";
     mutable_string = "Hello World";