add slides about panicking and string formatting

Author: wprzytula

content/lessons/02_ownership/dont_panic/dont_panic.html

@@ -0,0 +1,165 @@
+---
+marp: true
+author: Wojciech Przytuła
+backgroundColor: black
+color: grey
+transition: fade
+theme: gaia
+style: |
+  pre {
+      background-color: black;
+      border-style: solid;
+      border-color: grey;
+  },
+
+  code {
+      background-color: black; 
+  }
+---
+
+# Don't panic
+
+...or how should your Rust program behave when faced a critical error.
+
+---
+
+## A situation which unfortunately happens too often...
+
+```rust
+// This function returns Order, so we are forced to return
+// an Order even for incorrect inputs.
+fn create_order(num_dishes: usize) -> Order {
+    if num_dishes < Order::MAXIMUM_NUM_DISHES {
+        Ok(Order::new(num_dishes))
+    } else {
+        // ??? Order::INVALID ???
+    }
+}
+
+
+```
+
+---
+
+## LET'S PANIC!
+
+```rust
+// This function returns Order, so we are forced to return
+// an Order even for incorrect inputs.
+fn create_order(num_dishes: usize) -> Order {
+    if num_dishes < Order::MAXIMUM_NUM_DISHES {
+        Ok(Order::new(num_dishes))
+    } else {
+        panic!("Too many dishes for a single Order")
+        // This either unwinds the stack or aborts the program immediately.
+        // (configurable in Cargo.toml of your project)
+    }
+}
+
+
+```
+
+---
+
+## Hmm, maybe let's reconsider this...
+
+```rust
+/// Error signifying that there are too many dishes to fit in an Order.
+struct TooManyDishes;
+
+// This function returns Result, so that we are not forced to return
+// an Order for incorrect inputs - we just return Err.
+fn create_order(num_dishes: usize) -> Result<Order, TooManyDishes> {
+    if num_dishes < Order::MAXIMUM_NUM_DISHES {
+        Ok(Order::new(num_dishes))
+    } else {
+        Err(TooManyDishes)
+    }
+}
+
+
+```
+
+---
+
+## Another common case - `Option`/`Result`
+
+```rust
+struct DivisionByZero;
+
+fn div(dividend: i32, divisor: i32) -> Result<i32, DivisionByZero> {
+    if divisor == 0 {
+        // It is idiomatic to return errors after failed checks early in an imperative way, using explicit `return`.
+        return Err(DivisionByZero)
+    }
+
+    // It is idiomatic to have the "happy path" (the no-errors scenario) linear and using functional syntax.
+    Ok(dividend / divisor)
+}
+fn main() {
+    let res: Result<i32, DivisionByZero> = div(2137, 42);
+
+    // We are 100% sure division by 42 can't fail, so let's use this shorthand.
+    let quotient = res.unwrap();
+
+    // This is equivalent to:
+    let quotient = match res {
+        Ok(x) => x,
+        Err(err) => panic!("called `Result::unwrap()` on an `Err` value: {:?}", err),
+    }
+}
+```
+
+---
+
+### Let's encode more guarantees in the type system!
+
+```rust
+use std::num::NonZeroI32;
+
+fn div(dividend: i32, divisor: NonZeroI32) -> i32 {
+    dividend / divisor // Nothing can get broken here!
+}
+fn main() {
+    // let quotient = div(2137, 42); // This would not type check, because 42 is not NonZeroI32.
+    
+    // We have to create a NonZeroI32 instance:
+    let non_zero_divisor_opt: Option<NonZeroI32> = NonZeroI32::new(42);
+
+    // We are 100% sure 42 is not 0, so let's use this shorthand.
+    let non_zero_divisor = non_zero_divisor_opt.unwrap();
+
+    // This is equivalent to:
+    let non_zero_divisor = match non_zero_divisor_opt {
+        Some(x) => x,
+        None => panic!("called `Option::unwrap()` on a `None` value"),
+    }
+
+    let quotient = div(2137, non_zero_divisor);
+}
+```
+
+---
+
+### But wait, we ended up with an `unwrap()` anyway. Did we then improve at all?
+
+Actually, yes. Now, the function (here: `div()`) with some (possibly complex) logic **only accepts** (so that the compiler verifies that in compile-time) valid arguments. This way, the function's code can be simpler (no invalid-input-related error handling). Also, it's easier to convince yourself that your number is nonzero that to make sure that it upholds all guarantees required in the docs of the function containing logic. 
+
+---
+
+## To `panic` or not to `panic`
+
+Don't panic:
+- if the failure is caused by bad user input - you don't want to open up a highway for DoS attackers, do you?
+- if the failure only affects some task and not the program in general, e.g. when the server returned bad data for a request of one of the users; others are unaffected;
+- if the failure is recoverable (there is a reasonable action to be done in such situation, e.g. give user the default value when the server can't be queried for the actual value);
+
+---
+
+## To `panic` or not to `panic`
+
+Do panic:
+- if the failure is for sure caused by a bug in your code. It makes sense to inform the whole world that you wrote deficient software, by yelling at them. More seriously, this shortens the feedback loop and bugs are fixed earlier, instead of silently damaging production;
+- if the failure is not recoverable (there is no hope, the program is broken, *R.I.P.*, only the famous *restart* could help here);
+
+---

content/lessons/02_ownership/dont_panic/dont_panic.md

@@ -0,0 +1,149 @@
+---
+marp: true
+author: Wojciech Przytuła
+backgroundColor: black
+color: grey
+transition: fade
+theme: gaia
+style: |
+  pre {
+      background-color: black;
+      border-style: solid;
+      border-color: grey;
+  },
+
+  code {
+      background-color: black; 
+  }
+---
+
+# String formatting
+
+...printf(), sprintf() equivalents & related topics.
+
+---
+
+## Simplest possible output from Rust program
+
+```rust
+fn main() {
+    println!("Hello stdout!");
+    eprintln!("Hello stderr!");
+}
+```
+
+---
+
+### Formatted output (using `Display` trait)
+
+```rust
+fn agriculture() {
+    let num_animals = 42_usize;
+    let animal_name = "ducks";
+
+    println!("We have {} {} in our farm.", num_animals, animal_name);
+
+    let s: String = format!(
+        "Nothing is better than {0} {2}, except for {1} {2},",
+        num_animals, num_animals + 1, animal_name
+    );
+    
+    // Minimal assert.
+    assert!(num_animals >= 42);
+    // assert with a custom panic message.
+    assert!(
+        num_animals >= 42,
+        "Too few animals in our farm :( - only {} {}", num_animals, animal_name
+    );
+}
+```
+
+---
+
+### Formatted output (using `Debug` trait)
+
+```rust
+fn agriculture() {
+    let animals: &[&str] = &["Azor", "Mućka"];
+
+    // Does not compile: &[&str] does not implement Display.
+    // println!("We have the following animals in our farm: {}", animals);
+
+    // Concise printing for debug purposes:
+    println!("We have the following animals in our farm: {:?}", animals);
+    // Outputs:
+    // We have the following animals in our farm: ["Azor", "Mućka"]
+
+    // Pretty-printing for debug purposes:
+    println!("We have the following animals in our farm: {:#?}", animals);
+    // Outputs:
+    // We have the following animals in our farm: [
+    //   "Azor",
+    //   "Mućka"
+    // ]
+}
+```
+
+### Various ways to panic
+
+```rust
+fn panicking_is_fun() {
+    panic!("A general panic.");
+    assert!(false, "An assertion failed.");
+    
+    unimplemented!("This code is not implemented.");
+    todo!("This code is not YET implemented - it's going to change.");
+    
+    unreachable!("We should never reach this line of code!");
+}
+```
+
+---
+
+### Memory backing considerations
+
+```rust
+fn agriculture() {
+    let animals: &[&str] = &["Azor", "Mućka"];
+
+    let animals: [&str; 2] = ["Azor", "Mućka"];
+    let animals: &[&str] = &animals;
+
+    let animals: Vec<&str> = vec!["Azor", "Mućka"];
+
+    static ANIMALS: [&str; 2] = ["Azor", "Mućka"];
+    static ANIMALS_SLICE: &[&str] = &ANIMALS;
+
+    let animals: Vec<&str> = vec!["Azor", "Mućka"];
+    let animals_slice: &[&str] = &animals;
+
+    let animals: Vec<String> = vec!["Azor".into(), "Mućka".into()];
+}
+```
+
+---
+
+### Memory backing considerations - with hints
+
+```rust
+fn agriculture() {
+    let animals: &[&str] = &["Azor", "Mućka"]; // stack-allocated stack-backed slice.
+
+    // stack-allocated array (of statically-allocated strings).
+    let animals: [&str; 2] = ["Azor", "Mućka"];
+    let animals: &[&str] = &animals; // stack-allocated stack-backed slice.
+
+    let animals: Vec<&str> = vec!["Azor", "Mućka"]; // stack-allocated heap-backed slice.
+
+    static ANIMALS: [&str; 2] = ["Azor", "Mućka"]; // statically-allocated array.
+    static ANIMALS_SLICE: &[&str] = &ANIMALS; // statically-allocated statically-backed slice.
+
+    let animals: Vec<&str> = vec!["Azor", "Mućka"]; // stack-allocated heap-backed Vec.
+    let animals_slice: &[&str] = &animals; // stack-allocated heap-backed slice.
+
+    // stack-allocated heap-backed Vec of heap-allocated strings.
+    let animals: Vec<String> = vec!["Azor".into(), "Mućka".into()];
+}
+```
+
+---