From ee953f00caebf0bf5ce60cb39cd4d698117151ed Mon Sep 17 00:00:00 2001
From: Stevan Freeborn <65925598+StevanFreeborn@users.noreply.github.com>
Date: Tue, 20 Jan 2026 14:42:45 -0600
Subject: [PATCH] talk: finish pres and yt script

---
 .../functional_options_pattern_in_go/index.md |   1 +
 slides/yours_mine_ours/index.md               | 263 ++++++++++++++++++
 slides/yours_mine_ours/script.md              | 111 ++++++++
 3 files changed, 375 insertions(+)
 create mode 100644 slides/yours_mine_ours/index.md
 create mode 100644 slides/yours_mine_ours/script.md

diff --git a/slides/functional_options_pattern_in_go/index.md b/slides/functional_options_pattern_in_go/index.md
index e997140..f1bc68b 100644
--- a/slides/functional_options_pattern_in_go/index.md
+++ b/slides/functional_options_pattern_in_go/index.md
@@ -1,4 +1,5 @@
 ---
+title: A Trick for Designing Friendly APIs in Go
 theme: default
 layout: center
 class: text-center
diff --git a/slides/yours_mine_ours/index.md b/slides/yours_mine_ours/index.md
new file mode 100644
index 0000000..dcbd648
--- /dev/null
+++ b/slides/yours_mine_ours/index.md
@@ -0,0 +1,263 @@
+---
+title: "Yours, Mine, Ours"
+theme: default
+layout: center
+fonts:
+  sans: "CaskaydiaCove Nerd Font Mono"
+---
+
+# Yours, Mine, Ours
+
+Understanding ownership and borrowing in Rust
+
+---
+layout: center
+---
+
+# Think about a book
+
+Rust treats data a lot like a physical book.
+
+---
+layout: center
+---
+
+# Three rules to remember
+
+<ul>
+    <v-click>
+        <li>
+        1. Each value has a single owner.
+        </li>
+    </v-click>
+    <v-click>
+        <li>
+        2. There can only be one owner at a time.
+        </li>
+    </v-click>
+    <v-click>
+        <li>
+        3. When the owner goes out of scope the value is dropped.
+        </li>
+    </v-click>
+</ul>
+
+---
+layout: center
+---
+
+# Sometimes we do want to buy the book
+
+<div class="grid grid-cols-2 gap-10 text-left">
+<div>
+```rust{|1|2}
+let owner_one = String::from("The Rust Book");
+let owner_two = owner_one;
+```
+</div>
+    <div class="flex flex-col gap-4">
+       <v-click at="1">
+            <div>
+                <code>owner_one</code> is the owner.
+            </div>
+        </v-click>
+       <v-click at="2">
+            <div>
+                <code>owner_one</code> transferred ownership to <code>owner_two</code>.
+            </div>
+            <div>
+                <code>owner_one</code> is invalid now.
+            </div>
+        </v-click>
+    </div>
+</div>
+
+---
+layout: center
+---
+
+# Sometimes we don't want to buy the book
+
+<div class="grid grid-cols-2 gap-10 text-left">
+<div>
+```rust{|1|2|3-4}
+let owner = String::from("The Rust Book");
+let borrower = &owner;
+println!("I borrowed: {} from the owner!", borrower);
+println!("The owner still has: {}", owner);
+```
+</div>
+<div>
+    <div class="flex flex-col gap-4">
+       <v-click at="1">
+            <div>
+                <code>owner</code> is the owner.
+            </div>
+        </v-click>
+       <v-click at="2">
+            <div>
+                <code>borrower</code> borrows from <code>owner</code>.
+            </div>
+        </v-click>
+       <v-click at="3">
+            <div>
+                Both are valid.
+            </div>
+        </v-click>
+    </div>
+</div>
+</div>
+
+---
+layout: center
+---
+
+# Sometimes I want to add notes to the book
+
+<div class="grid grid-cols-2 gap-10 text-left">
+<div>
+```rust{|1|2|3-4}
+let mut owner = String::from("The Rust Book");
+let borrower = &mut owner;
+borrower.push_str(" - with my notes!");
+println!("The owner has: {}", owner);
+```
+</div>
+<div>
+    <div class="flex flex-col gap-4">
+       <v-click at="1">
+            <div>
+                <code>owner</code> is the owner.
+            </div>
+        </v-click>
+       <v-click at="2">
+            <div>
+                <code>borrower</code> mutably borrows from <code>owner</code>.
+            </div>
+        </v-click>
+         <v-click at="3">
+                <div>
+                 The owner is mutated through the borrower.
+                </div>
+        </v-click>
+    </div>
+</div>
+</div>
+
+---
+layout: center
+---
+
+# We have to be thoughtful when borrowing
+
+You don't want to change the book while someone else is reading it.
+
+<v-click>
+```rust{1-4|6-8|11-13}
+// many immutable borrows allowed
+let owner = String::from("The Rust Book");
+let borrower1 = &owner;
+let borrower2 = &owner;
+
+// only one mutable borrow allowed
+let mut owner = String::from("The Rust Book");
+let borrower = &mut owner;
+
+// mixing mutable and immutable borrows is not allowed
+let mut owner = String::from("The Rust Book");
+let borrower1 = &owner;
+let borrower2 = &mut owner;
+
+```
+</v-click>
+
+---
+layout: center
+---
+
+# So when to do what?
+
+| Question                                 | Answer | Action           | Type   |
+| ---------------------------------------- | ------ | ---------------- | ------ |
+| Do I need to consume or delete the data? | YES    | Take Ownership   | T      |
+| Do I need to edit the data in place?     | YES    | Mutable Borrow   | &mut T |
+| Do I just need to read/analyze the data? | YES    | Immutable Borrow | &T     |
+| Is the data tiny (Integers, Bools)?      | YES    | Copy             | T      |
+
+---
+layout: center
+---
+
+# Calculate the length of a string
+
+```rust
+fn calculate_length(s: &str) -> usize {
+    s.len()
+}
+
+let my_string = String::from("Hello, Rust!");
+let length = calculate_length(&my_string);
+println!("The length of '{}' is {}.", my_string, length);
+```
+
+---
+layout: center
+---
+
+# Add a signature to a document
+
+```rust
+fn add_signature(doc: &mut String, signature: &str) {
+    doc.push_str(signature);
+}
+
+let mut my_document = String::from("This is an important document.\n");
+add_signature(&mut my_document, "\nSigned, Rustacean");
+
+println!("{}", my_document);
+```
+
+---
+layout: center
+---
+
+# Create a new book
+
+```rust
+struct Book { title: String, author: String }
+
+fn create_book(title: String, author: String) -> Book {
+    Book { title, author }
+}
+
+let title = String::from("The Rust Book");
+let author = String::from("Steve Klabnik");
+
+let my_book = create_book(title, author);
+
+println!("Created book: '{}' by {}", my_book.title, my_book.author);
+```
+
+---
+layout: center
+---
+
+# Doubling a number
+
+```rust
+fn double_number(num: i32) -> i32 {
+    num * 2
+}
+
+let my_number = 10;
+let doubled = double_number(my_number);
+
+println!("The double of {} is {}.", my_number, doubled);
+```
+
+---
+layout: center
+---
+
+# Ownership is the price we pay for memory safety without a garbage collector.
+
diff --git a/slides/yours_mine_ours/script.md b/slides/yours_mine_ours/script.md
new file mode 100644
index 0000000..f44a5e4
--- /dev/null
+++ b/slides/yours_mine_ours/script.md
@@ -0,0 +1,111 @@
+# Video Script: Yours, Mine, Ours
+
+[VISUAL: Face Camera]
+
+"If you are coming from C++ or C, you are used to managing memory manually—and eventually shooting yourself in the foot with a segfault."
+
+"If you are coming from Java or C#, you are used to a Garbage Collector cleaning up your mess—at the cost of random performance pauses."
+
+[VISUAL: Slide 1]
+
+"Rust offers a third way. It promises memory safety without a garbage collector. But the price of admission is understanding its most unique feature: Ownership."
+
+[VISUAL: Slide 2]
+
+"To understand Ownership, let's not think about computer memory, but instead about a physical book."
+
+"If I hand you a book, I don't have it anymore. I can't read it. I can't write in it. You have it."
+
+"Rust treats data exactly like that physical book."
+
+[VISUAL: Slide 3]
+
+"There are only three rules you need to memorize."
+
+[CLICK - Reveal Rule 1] "1. Each value in Rust has a variable that’s called its owner."
+
+[CLICK - Reveal Rule 2] "2. There can only be one owner at a time. No shared custody."
+
+[CLICK - Reveal Rule 3] "3. When the owner goes out of scope, the value is dropped. The memory is freed immediately."
+
+[VISUAL: Slide 4]
+
+"Let's look at this in code. This is what we call 'Move Semantics.'"
+
+"We create owner_one." [CLICK]
+
+"Then, we assign owner_one to owner_two." [CLICK]
+
+"In most languages, both variables would now point to the same data. But in Rust, owner_one has transferred ownership to owner_two."
+
+"Because of Rule #2 (Only One Owner), owner_one is now invalid. If you tried to print it, the compiler would stop you. It’s gone."
+
+[VISUAL: Slide 5]
+
+"But obviously, we can't just move data around forever. Sometimes we just want to look at it. This is Borrowing."
+
+"Here, we create owner." [CLICK]
+
+"Then we create borrower. Notice the ampersand. We aren't taking the book; we are just looking at it." [CLICK]
+
+"Because we didn't transfer ownership, both variables are valid. The owner still owns it, and the borrower can read it." [CLICK]
+
+[VISUAL: Slide 6]
+
+"What if we want to change the data without taking ownership? We need a mutable borrow."
+
+"We define owner as mut (mutable)." [CLICK]
+
+"Then we create a borrower with &mut. This is like me handing you the book and a pen. You don't own the book, but I'm allowing you to write in it." [CLICK]
+
+"When we call push_str, the data is mutated through the borrower." [CLICK]
+
+[VISUAL: Slide 7]
+
+"Now, here is the catch. Rust is very strict about borrowing."
+
+"You can have as many Immutable borrowers as you want. Infinite people can read the book at the same time." [CLICK]
+
+"OR... you can have exactly One Mutable borrower." [CLICK]
+
+"But you cannot mix them." [CLICK]
+
+"You cannot change the book while someone else is reading it. This rule prevents 'Data Races' at compile time. It is annoying at first, but it prevents a whole class of bugs when you start writing concurrent code."
+
+[VISUAL: Slide 8]
+
+"So, how do you choose? Here is my mental cheat sheet."
+
+"If you need to delete or consume the data? Take ownership." 
+
+"If you need to edit it? Mutably borrow."
+
+"If you just need to read it? Immutably borrow." 
+
+"And if the data is tiny, like an integer? Rust will just copy it automatically. Which in most cases is what you want."
+
+[VISUAL: Slide 9]
+
+"Let's rapid-fire some examples."
+
+"Here, calculate_length just needs to measure the string. It doesn't need to own it. So we pass an immutable slice. The string stays with my_string."
+
+[VISUAL: Slide 10]
+
+"Here, add_signature needs to modify the document. So we pass mutuable owned string. Allowing us to edit it in place."
+
+[VISUAL: Slide 11]
+
+"Here, we are creating a new object. The function creates the Book and returns it. We want the book to own its data, so we transfer ownership of the title and author strings into the Book struct by moving them into the function and then returning the Book."
+
+[VISUAL: Slide 12]
+
+"Finally, here we are just wanting to double a number. And since integers are tiny, Rust copies the value automatically and since we don't need to mutate it, we can just pass it by value and get our result."
+
+[VISUAL: Slide 13]
+
+"It feels restrictive at first. The borrow checker will yell at you. You will get frustrated."
+
+"But remember: Ownership is the price we pay for memory safety without a garbage collector."
+
+"Once you internalize these rules, you stop fighting the compiler, and you start writing code that is fast AND safe by default."