diff --git a/.gitignore b/.gitignore
index 79cc9017..7b080490 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,4 @@ po/*.po~
 .idea/
 .iml
 .iws
+count.dat
diff --git a/Cargo.lock b/Cargo.lock
index c76c6c86..e97d4749 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -176,6 +176,10 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "borrowing"
+version = "0.1.0"
+
 [[package]]
 name = "bstr"
 version = "1.8.0"
@@ -314,6 +318,10 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "control-flow-basics"
+version = "0.1.0"
+
 [[package]]
 name = "core-foundation"
 version = "0.9.3"
@@ -541,6 +549,14 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "error-handling"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "thiserror",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.0.1"
@@ -689,6 +705,10 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "generics"
+version = "0.1.0"
+
 [[package]]
 name = "getopts"
 version = "0.2.21"
@@ -985,6 +1005,10 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "iterators"
+version = "0.1.0"
+
 [[package]]
 name = "itoa"
 version = "1.0.9"
@@ -1139,11 +1163,15 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "clap",
+ "lazy_static",
  "log",
  "matter",
  "mdbook",
  "pretty_env_logger",
+ "regex",
+ "serde",
  "serde_json",
+ "serde_yaml",
 ]
 
 [[package]]
@@ -1163,6 +1191,14 @@ version = "2.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
 
+[[package]]
+name = "memory-management"
+version = "0.1.0"
+
+[[package]]
+name = "methods-and-traits"
+version = "0.1.0"
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -1374,6 +1410,10 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "pattern-matching"
+version = "0.1.0"
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.0"
@@ -1642,6 +1682,10 @@ dependencies = [
  "bitflags 1.3.2",
 ]
 
+[[package]]
+name = "references"
+version = "0.1.0"
+
 [[package]]
 name = "regex"
 version = "1.10.2"
@@ -1880,6 +1924,19 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_yaml"
+version = "0.9.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cc7a1570e38322cfe4154732e5110f887ea57e22b76f4bfd32b5bdd3368666c"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "servo_arc"
 version = "0.3.0"
@@ -1947,12 +2004,23 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "slices-and-lifetimes"
+version = "0.1.0"
+dependencies = [
+ "thiserror",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
 
+[[package]]
+name = "smart-pointers"
+version = "0.1.0"
+
 [[package]]
 name = "socket2"
 version = "0.4.10"
@@ -1988,6 +2056,14 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
+[[package]]
+name = "std-traits"
+version = "0.1.0"
+
+[[package]]
+name = "std-types"
+version = "0.1.0"
+
 [[package]]
 name = "string_cache"
 version = "0.8.7"
@@ -2106,6 +2182,10 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "testing"
+version = "0.1.0"
+
 [[package]]
 name = "thiserror"
 version = "1.0.50"
@@ -2312,12 +2392,20 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "tuples-and-arrays"
+version = "0.1.0"
+
 [[package]]
 name = "typenum"
 version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
+[[package]]
+name = "types-and-values"
+version = "0.1.0"
+
 [[package]]
 name = "ucd-trie"
 version = "0.1.6"
@@ -2360,6 +2448,19 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
 
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa"
+
+[[package]]
+name = "unsafe-rust"
+version = "0.1.0"
+dependencies = [
+ "tempfile",
+]
+
 [[package]]
 name = "url"
 version = "2.4.1"
@@ -2371,6 +2472,10 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "user-defined-types"
+version = "0.1.0"
+
 [[package]]
 name = "utf-8"
 version = "0.7.6"
diff --git a/Cargo.toml b/Cargo.toml
index 00ef3fb3..600c3481 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,24 @@
 members = [
   "mdbook-exerciser",
   "mdbook-course",
+  "src/types-and-values",
+  "src/control-flow-basics",
+  "src/tuples-and-arrays",
+  "src/references",
+  "src/user-defined-types",
+  "src/pattern-matching",
+  "src/methods-and-traits",
+  "src/generics",
+  "src/std-types",
+  "src/std-traits",
+  "src/iterators",
+  "src/testing",
+  "src/memory-management",
+  "src/smart-pointers",
+  "src/borrowing",
+  "src/slices-and-lifetimes",
+  "src/error-handling",
+  "src/unsafe-rust",
   "src/exercises",
   "src/bare-metal/useful-crates/allocator-example",
   "src/bare-metal/useful-crates/zerocopy-example",
diff --git a/NOTES.txt b/NOTES.txt
new file mode 100644
index 00000000..a0685152
--- /dev/null
+++ b/NOTES.txt
@@ -0,0 +1,39 @@
+# Before Merging:
+* Remove the timing / existing-content information from view
+* Remove cr2-organization/
+
+# Plans for Later:
+
+## High Priority
+
+* Address slides that are too large for the aspect ratio, either by breaking
+  them up, shrinking them down, or some other creative solution.
+
+## Other Fixes
+
+* Can the segment headers (src/segname.md) be auto-generated, or done with a
+  macro? (#1415)
+  * Can these include timing information
+  * Can the per-day and overall-course sections also include timing info?
+
+* Can CI detect deletion of a slide without corresponding book.toml entry?
+  (#1417)
+* Simplify the GUI exercise (methods-and-traits)
+* Better examples for trait-bounds and impl trait, since students haven't yet
+  seen std traits
+* Traits slide should mention associated types, trait parameters, trait
+  "inheritance"
+* Improve iterator example (per suggestions from reader)
+* Modify `Interior Mutability` to use Mutex instead of Cell/RefCell, as noted
+  in the comment in that file.
+* Replace the health-statistics exercise, which really has little to do with
+  borowing. Maybe something that tempts students to use &mut self at the same
+  time as an exclusive reference to a field of self?
+* Talk about `ref` and `mut` modifiers in pattern matching
+* Add "recaps" at the beginning of each day
+* "9.5. Type Aliases: The example shows how to declare, but on how it looks in
+  practice is not clear enough (there is a use of one type alias but it's
+  hidden in a complex type). Ideally I would add some function signatures or
+  custom structs that showcase the cleanliness of this." (@deavid)
+* Cover trait objects after memory management, since they require some
+  understanding of Box.
diff --git a/book.toml b/book.toml
index c7ef9426..57b9f2d0 100644
--- a/book.toml
+++ b/book.toml
@@ -34,7 +34,6 @@ additional-css = [
   "theme/css/svgbob.css",
   "theme/css/speaker-notes.css",
   "theme/css/language-picker.css",
-  "theme/css/frontmatter.css",
   "theme/css/rtl.css",
 ]
 site-url = "/comprehensive-rust/"
@@ -68,8 +67,6 @@ line-numbers = true
 "exercises/day-4/solutions-morning.html" = "../concurrency/solutions-morning.html"
 "exercises/concurrency/elevator.html" = "chat-app.html"
 "generics/closures.html" = "../traits/closures.html"
-"generics/impl-trait.html" = "../traits/impl-trait.html"
-"generics/trait-bounds.html" = "../traits/trait-bounds.html"
 "generics/trait-objects.html" = "../traits/trait-objects.html"
 "outros-recursos.html" = "other-resources.html"
 "running-the-course/day-4.html" = "course-structure.html"
@@ -78,7 +75,6 @@ line-numbers = true
 "unsafe/mutable-static-variables.md" = "mutable-static-variables.html"
 "unsafe/unsafe-functions.html" = "calling-unsafe-functions.html"
 "welcome-bare-metal.html" = "bare-metal.html"
-"welcome-day-4.html" = "concurrency.html"
 # Moving exercises between days
 "exercises/day-2/luhn.html" = "../day-1/luhn.html"
 "exercises/day-2/points-polygons.html" = "../day-3/points-polygons.html"
@@ -90,5 +86,143 @@ line-numbers = true
 [output.html.search]
 use-boolean-and = true
 
+# redirects from course v1 to v2
+'welcome-day-1.html' = 'hello-world/welcome.html'
+'welcome-day-1/what-is-rust.html' = '../hello-world/what-is-rust.html'
+'hello-world/small-example.html' = '../hello-world/hello-world.html'
+'why-rust.html' = 'hello-world/benefits.html'
+'why-rust/compile-time.html' = '../hello-world/benefits.html'
+'why-rust/runtime.html' = '../hello-world/benefits.html'
+'why-rust/modern.html' = '../hello-world/benefits.html'
+'why-rust/an-example-in-c.html' = '../hello-world/example.html'
+'basic-syntax/variables.html' = '../types-and-values/variables.html'
+'basic-syntax/scalar-types.html' = '../types-and-values/values.html'
+'basic-syntax/type-inference.html' = '../types-and-values/inference.html'
+'basic-syntax.html' = 'control-flow-basics.html'
+'control-flow.html' = 'control-flow-basics.html'
+'control-flow/if-expressions.html' = '../control-flow-basics/conditionals.html'
+'control-flow/while-expressions.html' = '../control-flow-basics/loops.html'
+'control-flow/for-expressions.html' = '../control-flow-basics/loops.html'
+'control-flow/break-continue.html' = '../control-flow-basics/break-continue.html'
+'control-flow/loop-expressions.html' = '../control-flow-basics/loops.html'
+'basic-syntax/scopes-shadowing.html' = '../control-flow-basics/blocks-and-scopes.html'
+'control-flow/blocks.html' = '../control-flow-basics/blocks-and-scopes.html'
+'basic-syntax/functions.html' = '../control-flow-basics/functions.html'
+'basic-syntax/rustdoc.html' = '../std-types/docs.html'
+'basic-syntax/methods.html' = '../control-flow-basics/functions.html'
+'basic-syntax/functions-interlude.html' = '../control-flow-basics/functions.html'
+'exercises/day-1/morning.html' = '../../control-flow-basics/exercise.html'
+'exercises/day-1/afternoon.html' = '../../control-flow-basics/exercise.html'
+'exercises/day-2/morning.html' = '../../control-flow-basics/exercise.html'
+'exercises/day-2/afternoon.html' = '../../control-flow-basics/exercise.html'
+'exercises/day-3/morning.html' = '../../control-flow-basics/exercise.html'
+'exercises/day-3/afternoon.html' = '../../control-flow-basics/exercise.html'
+'basic-syntax/compound-types.html' = '../tuples-and-arrays/tuples-and-arrays.html'
+'control-flow/match-expressions.html' = '../tuples-and-arrays/match.html'
+'pattern-matching.html' = 'tuples-and-arrays/match.html'
+'pattern-matching/match-guards.html' = '../tuples-and-arrays/match.html'
+'pattern-matching/destructuring-arrays.html' = '../tuples-and-arrays/destructuring.html'
+'exercises/day-1/for-loops.html' = '../../tuples-and-arrays/exercise.html'
+'basic-syntax/references.html' = '../references/shared.html'
+'basic-syntax/references-dangling.html' = '../references/shared.html'
+'exercises/day-3/points-polygons.html' = '../../references/exercise.html'
+'structs.html' = 'user-defined-types/named-structs.html'
+'structs/field-shorthand.html' = '../user-defined-types/named-structs.html'
+'structs/tuple-structs.html' = '../user-defined-types/tuple-structs.html'
+'enums.html' = 'user-defined-types/enums.html'
+'enums/variant-payloads.html' = '../user-defined-types/enums.html'
+'enums/sizes.html' = '../user-defined-types/enums.html'
+'traits/deriving-traits.html' = '../methods-and-traits/deriving.html'
+'pattern-matching/destructuring-structs.html' = '../pattern-matching/destructuring.html'
+'pattern-matching/destructuring-enums.html' = '../pattern-matching/destructuring.html'
+'control-flow/novel.html' = '../pattern-matching/let-control-flow.html'
+'control-flow/if-let-expressions.html' = '../pattern-matching/let-control-flow.html'
+'control-flow/while-let-expressions.html' = '../pattern-matching/let-control-flow.html'
+'exercises/day-1/pattern-matching.html' = '../../user-defined-types/exercise.html'
+'welcome-day-2.html' = 'methods-and-traits/welcome.html'
+'methods.html' = 'methods-and-traits/methods.html'
+'methods/receiver.html' = '../methods-and-traits/methods.html'
+'methods/example.html' = '../methods-and-traits/methods.html'
+'traits.html' = 'methods-and-traits/traits.html'
+'traits/default-methods.html' = '../methods-and-traits/traits.html'
+'traits/trait-objects.html' = '../methods-and-traits/trait-objects.html'
+'exercises/day-3/simple-gui.html' = '../../methods-and-traits/exercise.html'
+'generics.html' = 'generics/generic-functions.html'
+'generics/monomorphization.html' = '../generics/generic-functions.html'
+'generics/data-types.html' = '../generics/generic-data.html'
+'generics/methods.html' = '../generics/generic-data.html'
+'traits/trait-bounds.html' = '../generics/trait-bounds.html'
+'traits/impl-trait.html' = '../generics/impl-trait.html'
+'std.html' = 'std-types/std.html'
+'std/option-result.html' = '../std-types/option.html'
+'error-handling/result.html' = '../std-types/result.html'
+'std/string.html' = '../std-types/string.html'
+'std/vec.html' = '../std-types/vec.html'
+'std/hashmap.html' = '../std-types/hashmap.html'
+'exercises/day-2/book-library.html' = '../../std-types/exercise.html'
+'traits/important-traits.html' = '../std-traits/comparisons.html'
+'traits/operators.html' = '../std-traits/operators.html'
+'traits/from-into.html' = '../std-traits/from-and-into.html'
+'traits/read-write.html' = '../std-traits/read-and-write.html'
+'traits/default.html' = '../std-traits/default.html'
+'traits/closures.html' = '../std-traits/closures.html'
+'exercises/day-1/implicit-conversions.html' = '../../std-traits/exercise.html'
+'traits/iterator.html' = '../iterators/iterators.html'
+'exercises/day-2/iterators-and-ownership.html' = '../../iterators/intoiterator.html'
+'traits/from-iterator.html' = '../iterators/fromiterator.html'
+'exercises/day-2/strings-iterators.html' = '../../iterators/exercise.html'
+'modules.html' = 'modules/modules.html'
+'testing.html' = 'testing/unit-tests.html'
+'testing/unit-tests.html' = '../testing/unit-tests.html'
+'testing/integration-tests.html' = '../testing/other.html'
+'testing/doc-tests.html' = '../testing/other.html'
+'exercises/day-1/luhn.html' = '../../testing/exercise.html'
+'welcome-day-3.html' = 'memory-management/welcome.html'
+'memory-management/stack-vs-heap.html' = '../memory-management/review.html'
+'memory-management/stack.html' = '../memory-management/review.html'
+'memory-management.html' = 'memory-management/approaches.html'
+'memory-management/manual.html' = '../memory-management/approaches.html'
+'memory-management/scope-based.html' = '../memory-management/approaches.html'
+'memory-management/garbage-collection.html' = '../memory-management/approaches.html'
+'ownership.html' = 'memory-management/ownership.html'
+'memory-management/rust.html' = '../memory-management/ownership.html'
+'ownership/move-semantics.html' = '../memory-management/move.html'
+'ownership/moved-strings-rust.html' = '../memory-management/move.html'
+'ownership/double-free-modern-cpp.html' = '../memory-management/move.html'
+'ownership/moves-function-calls.html' = '../memory-management/move.html'
+'ownership/copy-clone.html' = '../memory-management/copy-types.html'
+'traits/drop.html' = '../memory-management/drop.html'
+'std/box.html' = '../smart-pointers/box.html'
+'std/box-recursive.html' = '../smart-pointers/box.html'
+'std/box-niche.html' = '../smart-pointers/box.html'
+'std/rc.html' = '../smart-pointers/rc.html'
+'ownership/borrowing.html' = '../borrowing/shared.html'
+'ownership/shared-unique-borrows.html' = '../borrowing/shared.html'
+'std/cell.html' = '../borrowing/interior-mutability.html'
+'exercises/day-2/health-statistics.html' = '../../borrowing/exercise.html'
+'error-handling.html' = 'error-handling/panics.html'
+'error-handling/panic-unwind.html' = '../error-handling/panics.html'
+'error-handling/try-operator.html' = '../error-handling/try.html'
+'error-handling/converting-error-types.html' = '../error-handling/try-conversions.html'
+'error-handling/converting-error-types-example.html' = '../error-handling/try-conversions.html'
+'error-handling/deriving-error-enums.html' = '../error-handling/error.html'
+'error-handling/error-contexts.html' = '../error-handling/thiserror-and-anyhow.html'
+'error-handling/dynamic-errors.html' = '../error-handling/thiserror-and-anyhow.html'
+'basic-syntax/slices.html' = '../slices-and-lifetimes/slices.html'
+'basic-syntax/string-slices.html' = '../slices-and-lifetimes/str.html'
+'ownership/lifetimes.html' = '../slices-and-lifetimes/lifetime-annotations.html'
+'ownership/lifetimes-function-calls.html' = '../slices-and-lifetimes/lifetime-elision.html'
+'ownership/lifetimes-data-structures.html' = '../slices-and-lifetimes/struct-lifetimes.html'
+'unsafe.html' = 'unsafe-rust/unsafe.html'
+'unsafe/raw-pointers.html' = '../unsafe-rust/dereferencing.html'
+'basic-syntax/static-and-const.html' = '../unsafe-rust/static-and-const.html'
+'unsafe/mutable-static-variables.html' = '../unsafe-rust/mutable-static.html'
+'unsafe/unions.html' = '../unsafe-rust/unions.html'
+'unsafe/calling-unsafe-functions.html' = '../unsafe-rust/unsafe-functions.html'
+'unsafe/writing-unsafe-functions.html' = '../unsafe-rust/unsafe-functions.html'
+'unsafe/extern-functions.html' = '../unsafe-rust/unsafe-functions.html'
+'unsafe/unsafe-traits.html' = '../unsafe-rust/unsafe-traits.html'
+'exercises/day-3/safe-ffi-wrapper.html' = '../../unsafe-rust/exercise.html'
+
 [output.exerciser]
 output-directory = "comprehensive-rust-exercises"
diff --git a/mdbook-course/Cargo.toml b/mdbook-course/Cargo.toml
index 92463f52..165fcd26 100644
--- a/mdbook-course/Cargo.toml
+++ b/mdbook-course/Cargo.toml
@@ -11,8 +11,12 @@ description = "An mdbook preprocessor for comprehensive-rust."
 [dependencies]
 anyhow = "1.0.68"
 clap = "4.4.4"
+lazy_static = "1.4"
 log = "0.4.17"
 matter = "0.1.0-alpha4"
 mdbook = "0.4.25"
 pretty_env_logger = "0.5.0"
+regex = "1.10"
+serde = "1.0.192"
 serde_json = "1.0.107"
+serde_yaml = "0.9"
diff --git a/mdbook-course/README.md b/mdbook-course/README.md
index c349630c..c2784a59 100644
--- a/mdbook-course/README.md
+++ b/mdbook-course/README.md
@@ -6,12 +6,70 @@ Rust.
 ## Frontmatter
 
 The preprocessor parses "frontmatter" -- YAML between `---` at the beginning of
-a Markdown file -- and removes it from the rendered result. At the moment, to
-aid review of the new course, it places this content in a `<pre>` block.
+a Markdown file -- and removes it from the rendered result.
 
-## Future Work
+Frontmatter is optional, and can contain any of the following fields, defined
+below:
 
-- Parse the `minutes` property from frontmatter and
-  - Generate a course timeline
-  - Include timing information in the speaker notes
-- Generate per-segment tables of contents.
+```yaml
+minutes: NNN
+course: COURSE NAME
+session: SESSION NAME
+```
+
+## Course Structure
+
+A book can contain multiple _courses_. Each course is made up of _sessions_,
+which are blocks of instructional time (and include breaks). Typically two
+sessions are taught per day, morning and afternoon.
+
+Each session is comprised of _segments_, which are slides on a related theme.
+Breaks are scheduled between segments.
+
+Each segment is comprised of _slides_. A slide can be made up of one or more
+mdBook chapters.
+
+The course structure is derived from the mdBook structure. Each top-level mdBook
+"section" is treated as a segment, and may optionally begin a new session or
+course. Within each section, the first chapter and subsequent second-level
+chapters are each treated as a slide. Any further-nested chapters are treated as
+parts of the parent slide. For example:
+
+```ignore
+- [Frobnication](frobnication.md)
+  - [Integer Frobnication](frobnication/integers.md)
+  - [Frob Expansion](frobnication/expansion.md)
+    - [Structs](frobnication/expansion-structs.md)
+    - [Enums](frobnication/expansion-structs.md)
+  - [Exercise](frobnication/exercise.md)
+    - [Solution](frobnication/Solution.md)
+```
+
+In this segment, there are four slides: "Frobnication", "Integer Frobnication",
+"Frob Expansion", and "Exercise". The last two slides are made up of multiple
+chapters.
+
+The first chapter of a segment can use the `course` and `session` fields in its
+frontmatter to indicate that it is the first segment in a session or course.
+
+## Timing
+
+Each chapter should specify an estimate of the instructional time it will
+require in the `minutes` field. This information is summed, with breaks
+automatically added between segments, to give time estimates for segments,
+sessions, and courses.
+
+## Directives
+
+Within the course material, the following directives can be used:
+
+```
+{{%segment outline}}
+{{%session outline}}
+{{%course outline}}
+{{%course outline COURSENAME}}
+```
+
+These will be replaced with a markdown outline of the current segment, session,
+or course. The last directive can refer to another course by name and is used in
+the "Running the Course" section.
diff --git a/mdbook-course/src/course.rs b/mdbook-course/src/course.rs
new file mode 100644
index 00000000..02543aa3
--- /dev/null
+++ b/mdbook-course/src/course.rs
@@ -0,0 +1,451 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Representation of Comprehensive Rust as a hierarchy of types.
+//!
+//! ```ignore
+//! Courses -- a collection of courses
+//!   Course -- the level of content at which students enroll (fundamentals, android, etc.)
+//!     Session -- a block of instructional time (typically morning or afternoon)
+//!       Segment -- a collection of slides with a related theme
+//!         Slide -- a single topic (may be represented by multiple mdBook chapters)
+//! ```
+//!
+//! This structure is parsed from the format of the book using a combination of the order in which
+//! chapters are listed in `SUMMARY.md` and annotations in the frontmatter of each chapter.
+//!
+//! A book contains a sequence of BookItems, each of which can contain sub-items. A top-level item
+//! can potentially introduce a new course, session, segment, and slide all in the same item. If
+//! the item has a `course` property in its frontmatter, then it introduces a new course. If it has
+//! a `session` property, then it introduces a new session. A top-level item always corresponds
+//! 1-to-1 with a segment (as long as it is a chapter), and that item becomes the first slide in
+//! that segment. Any other sub-items of the top-level item are treated as further slides in the
+//! same segment.
+
+use crate::frontmatter::{split_frontmatter, Frontmatter};
+use crate::markdown::{duration, relative_link};
+use mdbook::book::{Book, BookItem, Chapter};
+use std::fmt::Write;
+use std::path::{Path, PathBuf};
+
+/// Duration, in minutes, of breaks between segments in the course.
+const BREAK_DURATION: u64 = 10;
+
+/// Courses is simply a collection of Courses.
+///
+/// Non-instructional material (such as the introduction) has `course: none` and
+/// is not included in this data structure.
+#[derive(Default, Debug)]
+pub struct Courses {
+    pub courses: Vec<Course>,
+}
+
+/// A Course is the level of content at which students enroll.
+///
+/// Courses are identified by the `course` property in a session's frontmatter. All
+/// sessions with the same value for `course` are grouped into a Course.
+#[derive(Default, Debug)]
+pub struct Course {
+    pub name: String,
+    pub sessions: Vec<Session>,
+}
+
+/// A Session is a block of instructional time, containing segments. Typically a full day of
+/// instruction contains two sessions: morning and afternoon.
+///
+/// A session is identified by the `session` property in the session's frontmatter. There can be
+/// only one session with a given name in a course.
+#[derive(Default, Debug)]
+pub struct Session {
+    pub name: String,
+    pub segments: Vec<Segment>,
+}
+
+/// A Segment is a collection of slides with a related theme.
+///
+/// A segment is identified as a top-level chapter within a session.
+#[derive(Default, Debug)]
+pub struct Segment {
+    pub name: String,
+    pub slides: Vec<Slide>,
+}
+
+/// A Slide presents a single topic. It may contain multiple mdBook chapters.
+///
+/// A slide is identified as an sub-chapter of a segment. Any sub-items of
+/// that chapter are also included in the slide.
+#[derive(Default, Debug)]
+pub struct Slide {
+    pub name: String,
+    /// Minutes this slide should take to teach.
+    pub minutes: u64,
+    /// Source paths (`.md` files) in this slide.
+    pub source_paths: Vec<PathBuf>,
+}
+
+impl Courses {
+    /// Extract the course structure from the book. As a side-effect, the frontmatter is stripped
+    /// from each slide.
+    pub fn extract_structure(mut book: Book) -> anyhow::Result<(Self, Book)> {
+        let mut courses = Courses::default();
+        let mut current_course_name = None;
+        let mut current_session_name = None;
+
+        for item in &mut book.sections {
+            // We only want to process chapters, omitting part titles and separators.
+            let BookItem::Chapter(chapter) = item else {
+                continue;
+            };
+
+            let (frontmatter, content) = split_frontmatter(chapter)?;
+            chapter.content = content;
+
+            // If 'course' is given, use that course (if not 'none') and reset the session.
+            if let Some(course_name) = &frontmatter.course {
+                current_session_name = None;
+                if course_name == "none" {
+                    current_course_name = None;
+                } else {
+                    current_course_name = Some(course_name.clone());
+                }
+            }
+
+            // If 'session' is given, use that session.
+            if let Some(session_name) = &frontmatter.session {
+                current_session_name = Some(session_name.clone());
+            }
+
+            if current_course_name.is_some() && current_session_name.is_none() {
+                anyhow::bail!(
+                    "{:?}: 'session' must appear in frontmatter when 'course' appears",
+                    chapter.path
+                );
+            }
+
+            // If we have a course and session, then add this chapter to it as a segment.
+            if let (Some(course_name), Some(session_name)) =
+                (&current_course_name, &current_session_name)
+            {
+                let course = courses.course_mut(course_name);
+                let session = course.session_mut(session_name);
+                session.add_segment(frontmatter, chapter)?;
+            }
+        }
+        Ok((courses, book))
+    }
+
+    /// Get a reference to a course, adding a new one if none by this name exists.
+    fn course_mut(&mut self, name: impl AsRef<str>) -> &mut Course {
+        let name = name.as_ref();
+        if let Some(found_idx) =
+            self.courses.iter().position(|course| &course.name == name)
+        {
+            return &mut self.courses[found_idx];
+        }
+        let course = Course::new(name);
+        self.courses.push(course);
+        self.courses.last_mut().unwrap()
+    }
+
+    /// Find a course by name.
+    pub fn find_course(&self, name: impl AsRef<str>) -> Option<&Course> {
+        let name = name.as_ref();
+        self.courses.iter().find(|c| c.name == name)
+    }
+
+    /// Find the slide generated from the given Chapter within these courses, returning the "path"
+    /// to that slide.
+    pub fn find_slide(
+        &self,
+        chapter: &Chapter,
+    ) -> Option<(&Course, &Session, &Segment, &Slide)> {
+        let Some(ref source_path) = chapter.source_path else {
+            return None;
+        };
+
+        for course in self {
+            for session in course {
+                for segment in session {
+                    for slide in segment {
+                        if slide.source_paths.contains(source_path) {
+                            return Some((course, session, segment, slide));
+                        }
+                    }
+                }
+            }
+        }
+
+        return None;
+    }
+}
+
+impl<'a> IntoIterator for &'a Courses {
+    type Item = &'a Course;
+    type IntoIter = std::slice::Iter<'a, Course>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.courses).into_iter()
+    }
+}
+
+impl Course {
+    fn new(name: impl Into<String>) -> Self {
+        Course {
+            name: name.into(),
+            ..Default::default()
+        }
+    }
+
+    /// Get a reference to a session, adding a new one if none by this name exists.
+    fn session_mut(&mut self, name: impl AsRef<str>) -> &mut Session {
+        let name = name.as_ref();
+        if let Some(found_idx) = self
+            .sessions
+            .iter()
+            .position(|session| &session.name == name)
+        {
+            return &mut self.sessions[found_idx];
+        }
+        let session = Session::new(name);
+        self.sessions.push(session);
+        self.sessions.last_mut().unwrap()
+    }
+
+    /// Return the total duration of this course, as the sum of all segment durations.
+    ///
+    /// This includes breaks between segments, but does not count time between between
+    /// sessions.
+    pub fn minutes(&self) -> u64 {
+        self.into_iter().map(|s| s.minutes()).sum()
+    }
+
+    /// Generate a Markdown schedule for this course, for placement at the given path.
+    pub fn schedule(&self, at_source_path: impl AsRef<Path>) -> String {
+        let mut outline = String::from("Course schedule:\n");
+        for session in self {
+            writeln!(
+                &mut outline,
+                " * {} ({}, including breaks)",
+                session.name,
+                duration(session.minutes())
+            )
+            .unwrap();
+            for segment in session {
+                if segment.minutes() == 0 {
+                    continue;
+                }
+                writeln!(
+                    &mut outline,
+                    "   * [{}]({}) ({})",
+                    segment.name,
+                    relative_link(&at_source_path, &segment.slides[0].source_paths[0]),
+                    duration(segment.minutes())
+                )
+                .unwrap();
+            }
+        }
+        outline
+    }
+}
+
+impl<'a> IntoIterator for &'a Course {
+    type Item = &'a Session;
+    type IntoIter = std::slice::Iter<'a, Session>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.sessions).into_iter()
+    }
+}
+
+impl Session {
+    fn new(name: impl Into<String>) -> Self {
+        Session {
+            name: name.into(),
+            ..Default::default()
+        }
+    }
+
+    /// Add a new segment to the session, representing sub-items as slides.
+    fn add_segment(
+        &mut self,
+        frontmatter: Frontmatter,
+        chapter: &mut Chapter,
+    ) -> anyhow::Result<()> {
+        let mut segment = Segment::new(&chapter.name);
+        segment.add_slide(frontmatter, chapter, false)?;
+        for sub_chapter in &mut chapter.sub_items {
+            let BookItem::Chapter(sub_chapter) = sub_chapter else {
+                continue;
+            };
+            let (frontmatter, content) = split_frontmatter(sub_chapter)?;
+            sub_chapter.content = content;
+
+            segment.add_slide(frontmatter, sub_chapter, true)?;
+        }
+        self.segments.push(segment);
+        Ok(())
+    }
+
+    /// Generate a Markdown outline for this session, for placement at the given path.
+    pub fn outline(&self, at_source_path: impl AsRef<Path>) -> String {
+        let mut outline = String::from("In this session:\n");
+        for segment in self {
+            // Skip short segments (welcomes, wrap-up, etc.)
+            if segment.minutes() == 0 {
+                continue;
+            }
+            writeln!(
+                &mut outline,
+                " * [{}]({}) ({})",
+                segment.name,
+                relative_link(&at_source_path, &segment.slides[0].source_paths[0]),
+                duration(segment.minutes())
+            )
+            .unwrap();
+        }
+        writeln!(&mut outline,"\nIncluding {BREAK_DURATION} minute breaks, this session should take about {}", duration(self.minutes())).unwrap();
+        outline
+    }
+
+    /// Return the total duration of this session.
+    pub fn minutes(&self) -> u64 {
+        let instructional_time: u64 = self.into_iter().map(|s| s.minutes()).sum();
+        let breaks = (self.into_iter().filter(|s| s.minutes() > 0).count() - 1) as u64
+            * BREAK_DURATION;
+        instructional_time + breaks
+    }
+}
+
+impl<'a> IntoIterator for &'a Session {
+    type Item = &'a Segment;
+    type IntoIter = std::slice::Iter<'a, Segment>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.segments).into_iter()
+    }
+}
+
+impl Segment {
+    fn new(name: impl Into<String>) -> Self {
+        Segment {
+            name: name.into(),
+            ..Default::default()
+        }
+    }
+
+    /// Create a slide from a chapter. If `recurse` is true, sub-items of this chapter are
+    /// included in this slide as well.
+    fn add_slide(
+        &mut self,
+        frontmatter: Frontmatter,
+        chapter: &mut Chapter,
+        recurse: bool,
+    ) -> anyhow::Result<()> {
+        let mut slide = Slide::new(frontmatter, chapter);
+
+        if recurse {
+            slide.add_sub_chapters(chapter)?;
+        }
+        self.slides.push(slide);
+        Ok(())
+    }
+
+    /// Return the total duration of this segment (the sum of the durations of the enclosed
+    /// slides).
+    pub fn minutes(&self) -> u64 {
+        self.into_iter().map(|s| s.minutes()).sum()
+    }
+
+    pub fn outline(&self, at_source_path: impl AsRef<Path>) -> String {
+        let mut outline = String::from("In this segment:\n");
+        for slide in self {
+            if slide.minutes() == 0 {
+                continue;
+            }
+            writeln!(
+                &mut outline,
+                " * [{}]({}) ({})",
+                slide.name,
+                relative_link(&at_source_path, &slide.source_paths[0]),
+                duration(slide.minutes())
+            )
+            .unwrap();
+        }
+        writeln!(
+            &mut outline,
+            "\nThis segment should take about {}",
+            duration(self.minutes())
+        )
+        .unwrap();
+        outline
+    }
+}
+
+impl<'a> IntoIterator for &'a Segment {
+    type Item = &'a Slide;
+    type IntoIter = std::slice::Iter<'a, Slide>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.slides).into_iter()
+    }
+}
+
+impl Slide {
+    fn new(frontmatter: Frontmatter, chapter: &Chapter) -> Self {
+        let mut slide = Self {
+            name: chapter.name.clone(),
+            ..Default::default()
+        };
+        slide.add_frontmatter(&frontmatter);
+        slide.push_source_path(&chapter.source_path);
+        slide
+    }
+
+    fn add_frontmatter(&mut self, frontmatter: &Frontmatter) {
+        self.minutes += frontmatter.minutes.unwrap_or(0);
+    }
+
+    fn push_source_path(&mut self, source_path: &Option<PathBuf>) {
+        if let Some(source_path) = &source_path {
+            self.source_paths.push(source_path.clone());
+        }
+    }
+
+    /// Add sub-chapters of this chapter to this slide (recursively).
+    fn add_sub_chapters(&mut self, chapter: &mut Chapter) -> anyhow::Result<()> {
+        for sub_slide in &mut chapter.sub_items {
+            let BookItem::Chapter(sub_slide) = sub_slide else {
+                continue;
+            };
+            let (frontmatter, content) = split_frontmatter(sub_slide)?;
+            sub_slide.content = content;
+
+            if frontmatter.course.is_some() || frontmatter.session.is_some() {
+                anyhow::bail!(
+                    "{:?}: sub-slides may not have 'course' or 'session' set",
+                    sub_slide.path
+                );
+            }
+            self.add_frontmatter(&frontmatter);
+            self.push_source_path(&sub_slide.source_path);
+            self.add_sub_chapters(sub_slide)?;
+        }
+        Ok(())
+    }
+
+    /// Return the total duration of this slide.
+    pub fn minutes(&self) -> u64 {
+        self.minutes
+    }
+}
diff --git a/mdbook-course/src/frontmatter.rs b/mdbook-course/src/frontmatter.rs
index 842cdfb7..2237cb0a 100644
--- a/mdbook-course/src/frontmatter.rs
+++ b/mdbook-course/src/frontmatter.rs
@@ -12,30 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use anyhow::Context;
 use matter::matter;
-use mdbook::book::{Book, BookItem};
-use mdbook::preprocess::PreprocessorContext;
+use mdbook::book::Chapter;
+use serde::Deserialize;
 
-pub fn remove_frontmatter(
-    ctx: &PreprocessorContext,
-    book: &mut Book,
-) -> anyhow::Result<()> {
-    let is_html = ctx.renderer == "html";
-    book.for_each_mut(|chapter| {
-        let BookItem::Chapter(chapter) = chapter else {
-            return;
-        };
-        if let Some((frontmatter, content)) = matter(&chapter.content) {
-            if is_html {
-                // For the moment, include the frontmatter in the slide in a floating <pre>, for review
-                // purposes.
-                let pre = format!(r#"<pre class="frontmatter">{frontmatter}</pre>"#);
-                chapter.content = format!("{pre}\n\n{content}");
-            } else {
-                // For non-HTML renderers, just strip the frontmatter.
-                chapter.content = content;
-            }
-        }
-    });
-    Ok(())
+#[derive(Deserialize, Debug, Default)]
+pub struct Frontmatter {
+    pub minutes: Option<u64>,
+    pub course: Option<String>,
+    pub session: Option<String>,
+}
+
+/// Split a chapter's contents into frontmatter and the remaining contents.
+pub fn split_frontmatter(chapter: &Chapter) -> anyhow::Result<(Frontmatter, String)> {
+    if let Some((frontmatter, content)) = matter(&chapter.content) {
+        let frontmatter: Frontmatter =
+            serde_yaml::from_str(&frontmatter).with_context(|| {
+                format!("error parsing frontmatter in {:?}", chapter.source_path)
+            })?;
+
+        Ok((frontmatter, content))
+    } else {
+        Ok((Frontmatter::default(), chapter.content.clone()))
+    }
 }
diff --git a/mdbook-course/src/main.rs b/mdbook-course/src/main.rs
index 1da819e0..ec9e142e 100644
--- a/mdbook-course/src/main.rs
+++ b/mdbook-course/src/main.rs
@@ -12,9 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+mod course;
+mod frontmatter;
+mod markdown;
+mod replacements;
+mod timing_info;
+
+use crate::course::Courses;
+use crate::markdown::duration;
 use clap::{Arg, Command};
+use mdbook::book::BookItem;
 use mdbook::preprocess::CmdPreprocessor;
-use mdbook_course::frontmatter::remove_frontmatter;
 use std::io::{stdin, stdout};
 use std::process;
 
@@ -37,9 +45,65 @@ fn main() {
 }
 
 fn preprocess() -> anyhow::Result<()> {
-    let (ctx, mut book) = CmdPreprocessor::parse_input(stdin())?;
+    let (_, book) = CmdPreprocessor::parse_input(stdin())?;
 
-    remove_frontmatter(&ctx, &mut book)?;
+    let (courses, mut book) = Courses::extract_structure(book)?;
+
+    book.for_each_mut(|chapter| {
+        if let BookItem::Chapter(chapter) = chapter {
+            if let Some((course, session, segment, slide)) = courses.find_slide(chapter) {
+                timing_info::insert_timing_info(slide, chapter);
+                replacements::replace(
+                    &courses,
+                    Some(course),
+                    Some(session),
+                    Some(segment),
+                    chapter,
+                );
+            } else {
+                // Outside of a course, just perform replacements.
+                replacements::replace(&courses, None, None, None, chapter);
+            }
+        }
+    });
+
+    let timediff = |actual, target| {
+        if actual > target {
+            format!(
+                "{}: {} OVER TARGET {}",
+                duration(actual),
+                duration(actual - target),
+                duration(target)
+            )
+        } else if actual < target {
+            format!(
+                "{}: {} shorter than target {}",
+                duration(actual),
+                duration(target - actual),
+                duration(target)
+            )
+        } else {
+            format!("{}: right on time", duration(actual))
+        }
+    };
+    // Print a summary of times for the "Fundamentals" course.
+    let fundamentals = courses.find_course("Fundamentals").unwrap();
+    eprintln!(
+        "Fundamentals: {}",
+        timediff(fundamentals.minutes(), 8 * 3 * 60)
+    );
+
+    eprintln!("Sessions:");
+    for session in fundamentals {
+        eprintln!(
+            "  {}: {}",
+            session.name,
+            timediff(session.minutes(), 3 * 60)
+        );
+        for segment in session {
+            eprintln!("    {}: {}", segment.name, duration(segment.minutes()));
+        }
+    }
 
     serde_json::to_writer(stdout(), &book)?;
     Ok(())
diff --git a/mdbook-course/src/markdown.rs b/mdbook-course/src/markdown.rs
new file mode 100644
index 00000000..0128fbe8
--- /dev/null
+++ b/mdbook-course/src/markdown.rs
@@ -0,0 +1,149 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::path::Path;
+
+/// Given a source_path for the markdown file being rendered and a source_path for the target,
+/// generate a relative link.
+pub fn relative_link(
+    doc_path: impl AsRef<Path>,
+    target_path: impl AsRef<Path>,
+) -> String {
+    let doc_path = doc_path.as_ref();
+    let target_path = target_path.as_ref();
+
+    let mut dotdot = -1;
+    for parent in doc_path.ancestors() {
+        if target_path.starts_with(parent) {
+            break;
+        }
+        dotdot += 1;
+    }
+    if dotdot > 0 {
+        format!("{}{}", "../".repeat(dotdot as usize), target_path.display())
+    } else {
+        format!("./{}", target_path.display())
+    }
+}
+
+/// Represent the given duration in a human-readable way.
+///
+/// This will round times longer than 5 minutes to the next 5-minute interval.
+pub fn duration(mut minutes: u64) -> String {
+    if minutes > 5 {
+        minutes += 4;
+        minutes -= minutes % 5;
+    }
+
+    let (hours, minutes) = (minutes / 60, minutes % 60);
+    match (hours, minutes) {
+        (0, 1) => "1 minute".into(),
+        (0, m) => format!("{m} minutes"),
+        (1, 0) => "1 hour".into(),
+        (1, m) => format!("1 hour and {m} minutes"),
+        (h, 0) => format!("{h} hours"),
+        (h, m) => format!("{h} hours and {m} minutes"),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn relative_link_same_dir() {
+        assert_eq!(
+            relative_link(Path::new("welcome.md"), Path::new("hello-world.md")),
+            "./hello-world.md".to_string()
+        );
+    }
+
+    #[test]
+    fn relative_link_subdir() {
+        assert_eq!(
+            relative_link(Path::new("hello-world.md"), Path::new("hello-world/foo.md")),
+            "./hello-world/foo.md".to_string()
+        );
+    }
+
+    #[test]
+    fn relative_link_parent_dir() {
+        assert_eq!(
+            relative_link(Path::new("references/foo.md"), Path::new("hello-world.md")),
+            "../hello-world.md".to_string()
+        );
+    }
+
+    #[test]
+    fn relative_link_deep_parent_dir() {
+        assert_eq!(
+            relative_link(
+                Path::new("references/foo/bar.md"),
+                Path::new("hello-world.md")
+            ),
+            "../../hello-world.md".to_string()
+        );
+    }
+
+    #[test]
+    fn relative_link_peer_dir() {
+        assert_eq!(
+            relative_link(
+                Path::new("references/foo.md"),
+                Path::new("hello-world/foo.md")
+            ),
+            "../hello-world/foo.md".to_string()
+        );
+    }
+
+    #[test]
+    fn duration_no_time() {
+        assert_eq!(duration(0), "0 minutes")
+    }
+
+    #[test]
+    fn duration_single_minute() {
+        assert_eq!(duration(1), "1 minute")
+    }
+
+    #[test]
+    fn duration_two_minutes() {
+        assert_eq!(duration(2), "2 minutes")
+    }
+
+    #[test]
+    fn duration_seven_minutes() {
+        assert_eq!(duration(7), "10 minutes")
+    }
+
+    #[test]
+    fn duration_hour() {
+        assert_eq!(duration(60), "1 hour")
+    }
+
+    #[test]
+    fn duration_hour_mins() {
+        assert_eq!(duration(61), "1 hour and 5 minutes")
+    }
+
+    #[test]
+    fn duration_hours() {
+        assert_eq!(duration(120), "2 hours")
+    }
+
+    #[test]
+    fn duration_hours_mins() {
+        assert_eq!(duration(130), "2 hours and 10 minutes")
+    }
+}
diff --git a/mdbook-course/src/replacements.rs b/mdbook-course/src/replacements.rs
new file mode 100644
index 00000000..ebc5e522
--- /dev/null
+++ b/mdbook-course/src/replacements.rs
@@ -0,0 +1,61 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::course::{Course, Courses, Segment, Session};
+use mdbook::book::Chapter;
+use regex::Regex;
+
+lazy_static::lazy_static! {
+    static ref DIRECTIVE: Regex = Regex::new(r#"\{\{%([^}]*)}}"#).unwrap();
+}
+
+/// Replace supported directives with the relevant content.
+///
+/// See the mdbook-course README for details.
+#[allow(unused_variables)]
+pub fn replace(
+    courses: &Courses,
+    course: Option<&Course>,
+    session: Option<&Session>,
+    segment: Option<&Segment>,
+    chapter: &mut Chapter,
+) {
+    let Some(source_path) = &chapter.source_path else {
+        return;
+    };
+    chapter.content = DIRECTIVE
+        .replace(&chapter.content, |captures: &regex::Captures| {
+            let directive_str = captures[1].trim();
+            let directive: Vec<_> = directive_str.split_whitespace().collect();
+            match directive.as_slice() {
+                ["session", "outline"] if session.is_some() => {
+                    session.unwrap().outline(source_path)
+                }
+                ["segment", "outline"] if segment.is_some() => {
+                    segment.unwrap().outline(source_path)
+                }
+                ["course", "outline"] if course.is_some() => {
+                    course.unwrap().schedule(source_path)
+                }
+                ["course", "outline", course_name] => {
+                    let Some(course) = courses.find_course(course_name) else {
+                        return captures[0].to_string();
+                    };
+                    course.schedule(source_path)
+                }
+                _ => directive_str.to_owned(),
+            }
+        })
+        .to_string();
+}
diff --git a/mdbook-course/src/timing_info.rs b/mdbook-course/src/timing_info.rs
new file mode 100644
index 00000000..2eb3bd05
--- /dev/null
+++ b/mdbook-course/src/timing_info.rs
@@ -0,0 +1,38 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::course::Slide;
+use mdbook::book::Chapter;
+
+/// Insert timing information for this slide into the speaker notes.
+pub fn insert_timing_info(slide: &Slide, chapter: &mut Chapter) {
+    if slide.minutes > 0 && chapter.content.contains("<details>") {
+        // Include the minutes in the speaker notes.
+        let minutes = slide.minutes;
+        let plural = if slide.minutes == 1 {
+            "minute"
+        } else {
+            "minutes"
+        };
+        let mut subslides = "";
+        if slide.source_paths.len() > 1 {
+            subslides = "and its sub-slides ";
+        }
+        let timing_message =
+            format!("This slide {subslides}should take about {minutes} {plural}. ");
+        chapter.content = chapter
+            .content
+            .replace("<details>", &format!("<details>\n{timing_message}"));
+    }
+}
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index e150e236..36db5b6c 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -10,178 +10,192 @@
   - [Running Cargo Locally](cargo/running-locally.md)
 
 
-# Day 1: Morning
-
 ----
 
+# Day 1: Morning
+
 - [Welcome](welcome-day-1.md)
-  - [What is Rust?](welcome-day-1/what-is-rust.md)
-- [Hello World!](hello-world.md)
-  - [Small Example](hello-world/small-example.md)
-- [Why Rust?](why-rust.md)
-  - [Compile Time Guarantees](why-rust/compile-time.md)
-  - [Runtime Guarantees](why-rust/runtime.md)
-  - [Modern Features](why-rust/modern.md)
-- [Basic Syntax](basic-syntax.md)
-  - [Scalar Types](basic-syntax/scalar-types.md)
-  - [Compound Types](basic-syntax/compound-types.md)
-  - [References](basic-syntax/references.md)
-    - [Dangling References](basic-syntax/references-dangling.md)
-  - [Slices](basic-syntax/slices.md)
-    - [String vs str](basic-syntax/string-slices.md)
-  - [Functions](basic-syntax/functions.md)
-    - [Rustdoc](basic-syntax/rustdoc.md)
-    - [Methods](basic-syntax/methods.md)
-    - [Overloading](basic-syntax/functions-interlude.md)
-- [Exercises](exercises/day-1/morning.md)
-  - [Implicit Conversions](exercises/day-1/implicit-conversions.md)
-  - [Arrays and for Loops](exercises/day-1/for-loops.md)
+- [Hello, World](hello-world.md)
+  - [What is Rust?](hello-world/what-is-rust.md)
+  - [Hello, World](hello-world/hello-world.md)
+  - [Benefits of Rust](hello-world/benefits.md)
+  - [Playground](hello-world/playground.md)
+- [Types and Values](types-and-values.md)
+  - [Variables](types-and-values/variables.md)
+  - [Values](types-and-values/values.md)
+  - [Arithmetic](types-and-values/arithmetic.md)
+  - [Strings](types-and-values/strings.md)
+  - [Type Inference](types-and-values/inference.md)
+  - [Exercise: Fibonacci](types-and-values/exercise.md)
+    - [Solution](types-and-values/solution.md)
+- [Control Flow Basics](control-flow-basics.md)
+  - [Conditionals](control-flow-basics/conditionals.md)
+  - [Loops](control-flow-basics/loops.md)
+  - [`break` and `continue`](control-flow-basics/break-continue.md)
+  - [Blocks and Scopes](control-flow-basics/blocks-and-scopes.md)
+  - [Functions](control-flow-basics/functions.md)
+  - [Macros](control-flow-basics/macros.md)
+  - [Exercise: Collatz conjecture](control-flow-basics/exercise.md)
+    - [Solution](control-flow-basics/solution.md)
 
 # Day 1: Afternoon
 
-- [Control Flow](control-flow.md)
-  - [Blocks](control-flow/blocks.md)
-  - [if expressions](control-flow/if-expressions.md)
-  - [for expressions](control-flow/for-expressions.md)
-  - [while expressions](control-flow/while-expressions.md)
-  - [break & continue](control-flow/break-continue.md)
-  - [loop expressions](control-flow/loop-expressions.md)
+- [Welcome](welcome-day-1-afternoon.md)
+- [Tuples and Arrays](tuples-and-arrays.md)
+  - [Tuples and Arrays](tuples-and-arrays/tuples-and-arrays.md)
+  - [Array Iteration](tuples-and-arrays/iteration.md)
+  - [Pattern Matching](tuples-and-arrays/match.md)
+  - [Destructuring](tuples-and-arrays/destructuring.md)
+  - [Exercise: Nested Arrays](tuples-and-arrays/exercise.md)
+    - [Solution](tuples-and-arrays/solution.md)
+- [References](references.md)
+  - [Shared References](references/shared.md)
+  - [Exclusive References](references/exclusive.md)
+  - [Exercise: Geometry](references/exercise.md)
+    - [Solution](references/solution.md)
+- [User-Defined Types](user-defined-types.md)
+  - [Named Structs](user-defined-types/named-structs.md)
+  - [Tuple Structs](user-defined-types/tuple-structs.md)
+  - [Enums](user-defined-types/enums.md)
+  - [Static and Const](user-defined-types/static-and-const.md)
+  - [Type Aliases](user-defined-types/aliases.md)
+  - [Exercise: Elevator Events](user-defined-types/exercise.md)
+    - [Solution](user-defined-types/solution.md)
 
-- [Variables](basic-syntax/variables.md)
-  - [Type Inference](basic-syntax/type-inference.md)
-  - [static & const](basic-syntax/static-and-const.md)
-  - [Scopes and Shadowing](basic-syntax/scopes-shadowing.md)
-- [Enums](enums.md)
-  - [Variant Payloads](enums/variant-payloads.md)
-  - [Enum Sizes](enums/sizes.md)
-
-- [Novel Control Flow](control-flow/novel.md)
-  - [if let expressions](control-flow/if-let-expressions.md)
-  - [while let expressions](control-flow/while-let-expressions.md)
-  - [match expressions](control-flow/match-expressions.md)
-
-- [Pattern Matching](pattern-matching.md)
-  - [Destructuring Enums](pattern-matching/destructuring-enums.md)
-  - [Destructuring Structs](pattern-matching/destructuring-structs.md)
-  - [Destructuring Arrays](pattern-matching/destructuring-arrays.md)
-  - [Match Guards](pattern-matching/match-guards.md)
-
-- [Exercises](exercises/day-1/afternoon.md)
-  - [Luhn Algorithm](exercises/day-1/luhn.md)
-  - [Pattern Matching](exercises/day-1/pattern-matching.md)
+----
 
 # Day 2: Morning
 
-----
-
 - [Welcome](welcome-day-2.md)
-
-- [Memory Management](memory-management.md)
-  - [Stack vs Heap](memory-management/stack-vs-heap.md)
-  - [Stack Memory](memory-management/stack.md)
-  - [Manual Memory Management](memory-management/manual.md)
-  - [Scope-Based Memory Management](memory-management/scope-based.md)
-  - [Garbage Collection](memory-management/garbage-collection.md)
-  - [Rust Memory Management](memory-management/rust.md)
-- [Ownership](ownership.md)
-  - [Move Semantics](ownership/move-semantics.md)
-  - [Moved Strings in Rust](ownership/moved-strings-rust.md)
-    - [Double Frees in Modern C++](ownership/double-free-modern-cpp.md)
-  - [Moves in Function Calls](ownership/moves-function-calls.md)
-  - [Copying and Cloning](ownership/copy-clone.md)
-  - [Borrowing](ownership/borrowing.md)
-    - [Shared and Unique Borrows](ownership/shared-unique-borrows.md)
-  - [Lifetimes](ownership/lifetimes.md)
-  - [Lifetimes in Function Calls](ownership/lifetimes-function-calls.md)
-  - [Lifetimes in Data Structures](ownership/lifetimes-data-structures.md)
-- [Structs](structs.md)
-  - [Tuple Structs](structs/tuple-structs.md)
-  - [Field Shorthand Syntax](structs/field-shorthand.md)
-- [Methods](methods.md)
-  - [Method Receiver](methods/receiver.md)
-  - [Example](methods/example.md)
-- [Exercises](exercises/day-2/morning.md)
-  - [Storing Books](exercises/day-2/book-library.md)
-  - [Health Statistics](exercises/day-2/health-statistics.md)
+- [Pattern Matching](pattern-matching.md)
+  - [Destructuring](pattern-matching/destructuring.md)
+  - [Let Control Flow](pattern-matching/let-control-flow.md)
+  - [Exercise: Expression Evaluation](pattern-matching/exercise.md)
+    - [Solution](pattern-matching/solution.md)
+- [Methods and Traits](methods-and-traits.md)
+  - [Methods](methods-and-traits/methods.md)
+  - [Traits](methods-and-traits/traits.md)
+  - [Deriving](methods-and-traits/deriving.md)
+  - [Trait Objects](methods-and-traits/trait-objects.md)
+  - [Exercise: GUI Library](methods-and-traits/exercise.md)
+    - [Solution](methods-and-traits/solution.md)
+- [Generics](generics.md)
+  - [Generic Functions](generics/generic-functions.md)
+  - [Generic Data types](generics/generic-data.md)
+  - [Trait Bounds](generics/trait-bounds.md)
+  - [Impl Trait](generics/impl-trait.md)
+  - [Exercise: Generic `min`](generics/exercise.md)
+    - [Solution](generics/solution.md)
 
 # Day 2: Afternoon
 
-- [Standard Library](std.md)
-  - [Option and Result](std/option-result.md)
-  - [String](std/string.md)
-  - [Vec](std/vec.md)
-  - [HashMap](std/hashmap.md)
-  - [Box](std/box.md)
-    - [Recursive Data Types](std/box-recursive.md)
-    - [Niche Optimization](std/box-niche.md)
-  - [Rc](std/rc.md)
-  - [Cell/RefCell](std/cell.md)
-- [Modules](modules.md)
-  - [Visibility](modules/visibility.md)
-  - [Paths](modules/paths.md)
-  - [Filesystem Hierarchy](modules/filesystem.md)
-- [Exercises](exercises/day-2/afternoon.md)
-  - [Iterators and Ownership](exercises/day-2/iterators-and-ownership.md)
-  - [Strings and Iterators](exercises/day-2/strings-iterators.md)
-
-
-# Day 3: Morning
+- [Welcome](welcome-day-2-afternoon.md)
+- [Standard Library Types](std-types.md)
+  - [Standard Library](std-types/std.md)
+  - [Language Docs](std-types/docs.md)
+  - [Option](std-types/option.md)
+  - [Result](std-types/result.md)
+  - [String](std-types/string.md)
+  - [Vec](std-types/vec.md)
+  - [HashMap](std-types/hashmap.md)
+  - [Exercise: Counter](std-types/exercise.md)
+    - [Solution](std-types/solution.md)
+- [Standard Library Traits](std-traits.md)
+  - [Comparisons](std-traits/comparisons.md)
+  - [Operators](std-traits/operators.md)
+  - [From and Into](std-traits/from-and-into.md)
+  - [Casting](std-traits/casting.md)
+  - [Read and Write](std-traits/read-and-write.md)
+  - [`Default`, struct update syntax](std-traits/default.md)
+  - [Closures](std-traits/closures.md)
+  - [Exercise: ROT13](std-traits/exercise.md)
+    - [Solution](std-traits/solution.md)
 
 ----
 
+# Day 3: Morning
+
 - [Welcome](welcome-day-3.md)
-- [Generics](generics.md)
-  - [Generic Data Types](generics/data-types.md)
-  - [Generic Methods](generics/methods.md)
-  - [Monomorphization](generics/monomorphization.md)
-- [Traits](traits.md)
-  - [Trait Objects](traits/trait-objects.md)
-  - [Deriving Traits](traits/deriving-traits.md)
-  - [Default Methods](traits/default-methods.md)
-  - [Trait Bounds](traits/trait-bounds.md)
-  - [impl Trait](traits/impl-trait.md)
-- [Important Traits](traits/important-traits.md)
-  - [Iterator](traits/iterator.md)
-  - [FromIterator](traits/from-iterator.md)
-  - [From and Into](traits/from-into.md)
-  - [Read and Write](traits/read-write.md)
-  - [Drop](traits/drop.md)
-  - [Default](traits/default.md)
-  - [Operators: Add, Mul, ...](traits/operators.md)
-  - [Closures: Fn, FnMut, FnOnce](traits/closures.md)
-- [Exercises](exercises/day-3/morning.md)
-  - [A Simple GUI Library](exercises/day-3/simple-gui.md)
-  - [Points and Polygons](exercises/day-3/points-polygons.md)
+- [Memory Management](memory-management.md)
+  - [Review of Program Memory](memory-management/review.md)
+  - [Approaches to Memory Management](memory-management/approaches.md)
+  - [Ownership](memory-management/ownership.md)
+  - [Move semantics](memory-management/move.md)
+  - [Clone](memory-management/clone.md)
+  - [Copy Types](memory-management/copy-types.md)
+  - [Drop](memory-management/drop.md)
+  - [Exercise: Builder Type](memory-management/exercise.md)
+    - [Solution](memory-management/solution.md)
+- [Smart Pointers](smart-pointers.md)
+  - [Box<T>](smart-pointers/box.md)
+  - [Rc](smart-pointers/rc.md)
+  - [Exercise: Binary Tree](smart-pointers/exercise.md)
+    - [Solution](smart-pointers/solution.md)
 
 # Day 3: Afternoon
 
+- [Welcome](welcome-day-3-afternoon.md)
+- [Borrowing](borrowing.md)
+  - [Borrowing a Value](borrowing/shared.md)
+  - [Borrow Checking](borrowing/borrowck.md)
+  - [Interior Mutability](borrowing/interior-mutability.md)
+  - [Exercise: Health Statistics](borrowing/exercise.md)
+    - [Solution](borrowing/solution.md)
+- [Slices and Lifetimes](slices-and-lifetimes.md)
+  - [Slices: `&[T]`](slices-and-lifetimes/slices.md)
+  - [String References](slices-and-lifetimes/str.md)
+  - [Lifetime Annotations](slices-and-lifetimes/lifetime-annotations.md)
+  - [Lifetime Elision](slices-and-lifetimes/lifetime-elision.md)
+  - [Struct Lifetimes](slices-and-lifetimes/struct-lifetimes.md)
+  - [Exercise: Protobuf Parsing](slices-and-lifetimes/exercise.md)
+    - [Solution](slices-and-lifetimes/solution.md)
+
+---
+
+# Day 4: Morning
+
+- [Welcome](welcome-day-4.md)
+- [Iterators](iterators.md)
+  - [Iterators](iterators/iterators.md)
+  - [IntoIterator](iterators/intoiterator.md)
+  - [FromIterator](iterators/fromiterator.md)
+  - [Exercise: Iterator Method Chaining](iterators/exercise.md)
+    - [Solution](iterators/solution.md)
+- [Modules](modules.md)
+  - [Modules](modules/modules.md)
+  - [Filesystem Hierarchy](modules/filesystem.md)
+  - [Visibility](modules/visibility.md)
+  - [use, super, self](modules/paths.md)
+  - [Exercise: Modules for the GUI Library](modules/exercise.md)
+    - [Solution](modules/solution.md)
+- [Testing](testing.md)
+  - [Test Modules](testing/unit-tests.md)
+  - [Other Types of Tests](testing/other.md)
+  - [Useful Crates](testing/useful-crates.md)
+  - [Compiler lints and Clippy](testing/lints.md)
+  - [Exercise: Luhn Algorithm](testing/exercise.md)
+    - [Solution](testing/solution.md)
+
+# Day 4: Afternoon
+
+- [Welcome](welcome-day-4-afternoon.md)
 - [Error Handling](error-handling.md)
   - [Panics](error-handling/panics.md)
-    - [Catching Stack Unwinding](error-handling/panic-unwind.md)
-  - [Structured Error Handling](error-handling/result.md)
-  - [Propagating Errors with ?](error-handling/try-operator.md)
-    - [Converting Error Types](error-handling/converting-error-types.md)
-      - [Example](error-handling/converting-error-types-example.md)
-    - [Deriving Error Enums](error-handling/deriving-error-enums.md)
-    - [Dynamic Error Types](error-handling/dynamic-errors.md)
-    - [Adding Context to Errors](error-handling/error-contexts.md)
-- [Testing](testing.md)
-  - [Unit Tests](testing/unit-tests.md)
-  - [Test Modules](testing/test-modules.md)
-  - [Documentation Tests](testing/doc-tests.md)
-  - [Integration Tests](testing/integration-tests.md)
-  - [Useful crates](testing/useful-crates.md)
-- [Unsafe Rust](unsafe.md)
-  - [Dereferencing Raw Pointers](unsafe/raw-pointers.md)
-  - [Mutable Static Variables](unsafe/mutable-static-variables.md)
-  - [Unions](unsafe/unions.md)
-  - [Calling Unsafe Functions](unsafe/calling-unsafe-functions.md)
-    - [Writing Unsafe Functions](unsafe/writing-unsafe-functions.md)
-    - [Extern Functions](unsafe/extern-functions.md)
-  - [Implementing Unsafe Traits](unsafe/unsafe-traits.md)
-- [Exercises](exercises/day-3/afternoon.md)
-  - [Safe FFI Wrapper](exercises/day-3/safe-ffi-wrapper.md)
-
+  - [Try operator](error-handling/try.md)
+  - [Try Conversions](error-handling/try-conversions.md)
+  - [Error Trait](error-handling/error.md)
+  - [thiserror and anyhow](error-handling/thiserror-and-anyhow.md)
+  - [Exercise: Rewriting with Result](error-handling/exercise.md)
+    - [Solution](error-handling/solution.md)
+- [Unsafe Rust](unsafe-rust.md)
+  - [Unsafe](unsafe-rust/unsafe.md)
+  - [Dereferencing Raw Pointers](unsafe-rust/dereferencing.md)
+  - [Mutable Static Variables](unsafe-rust/mutable-static.md)
+  - [Unions](unsafe-rust/unions.md)
+  - [Unsafe Functions](unsafe-rust/unsafe-functions.md)
+  - [Unsafe Traits](unsafe-rust/unsafe-traits.md)
+  - [Exercise: FFI Wrapper](unsafe-rust/exercise.md)
+    - [Solution](unsafe-rust/solution.md)
 
 # Android
 
@@ -277,6 +291,7 @@
   - [Other Projects](bare-metal/microcontrollers/other-projects.md)
 - [Exercises](exercises/bare-metal/morning.md)
   - [Compass](exercises/bare-metal/compass.md)
+  - [Solutions](exercises/bare-metal/solutions-morning.md)
 
 # Bare Metal: Afternoon
 
@@ -305,6 +320,7 @@
   - [vmbase](bare-metal/android/vmbase.md)
 - [Exercises](exercises/bare-metal/afternoon.md)
   - [RTC Driver](exercises/bare-metal/rtc.md)
+  - [Solutions](exercises/bare-metal/solutions-afternoon.md)
 
 
 # Concurrency: Morning
@@ -328,6 +344,7 @@
 - [Exercises](exercises/concurrency/morning.md)
   - [Dining Philosophers](exercises/concurrency/dining-philosophers.md)
   - [Multi-threaded Link Checker](exercises/concurrency/link-checker.md)
+  - [Solutions](exercises/concurrency/solutions-morning.md)
 
 # Concurrency: Afternoon
 
@@ -349,6 +366,7 @@
 - [Exercises](exercises/concurrency/afternoon.md)
   - [Dining Philosophers](exercises/concurrency/dining-philosophers-async.md)
   - [Broadcast Chat Application](exercises/concurrency/chat-app.md)
+  - [Solutions](exercises/concurrency/solutions-afternoon.md)
 
 
 # Final Words
@@ -359,20 +377,3 @@
 - [Glossary](glossary.md)
 - [Other Resources](other-resources.md)
 - [Credits](credits.md)
-
-
-# Solutions
-
-----
-
-- [Solutions](exercises/solutions.md)
-  - [Day 1 Morning](exercises/day-1/solutions-morning.md)
-  - [Day 1 Afternoon](exercises/day-1/solutions-afternoon.md)
-  - [Day 2 Morning](exercises/day-2/solutions-morning.md)
-  - [Day 2 Afternoon](exercises/day-2/solutions-afternoon.md)
-  - [Day 3 Morning](exercises/day-3/solutions-morning.md)
-  - [Day 3 Afternoon](exercises/day-3/solutions-afternoon.md)
-  - [Bare Metal Rust Morning](exercises/bare-metal/solutions-morning.md)
-  - [Bare Metal Rust Afternoon](exercises/bare-metal/solutions-afternoon.md)
-  - [Concurrency Morning](exercises/concurrency/solutions-morning.md)
-  - [Concurrency Afternoon](exercises/concurrency/solutions-afternoon.md)
diff --git a/src/android.md b/src/android.md
index 8ffef976..8d5679ab 100644
--- a/src/android.md
+++ b/src/android.md
@@ -1,3 +1,6 @@
+---
+course: none
+---
 # Welcome to Rust in Android
 
 Rust is supported for system software on Android. This means that
diff --git a/src/bare-metal/useful-crates/zerocopy-example/src/main.rs b/src/bare-metal/useful-crates/zerocopy-example/src/main.rs
index 06841b6f..58c676b4 100644
--- a/src/bare-metal/useful-crates/zerocopy-example/src/main.rs
+++ b/src/bare-metal/useful-crates/zerocopy-example/src/main.rs
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#![allow(dead_code)]
+
 // ANCHOR: main
 use zerocopy::AsBytes;
 
diff --git a/src/basic-syntax.md b/src/basic-syntax.md
deleted file mode 100644
index 96a36110..00000000
--- a/src/basic-syntax.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Basic Syntax
-
-Much of the Rust syntax will be familiar to you from C, C++ or Java:
-
-* Blocks and scopes are delimited by curly braces.
-* Line comments are started with `//`, block comments are delimited by `/* ...
-  */`.
-* Keywords like `if` and `while` work the same.
-* Variable assignment is done with `=`, comparison is done with `==`.
diff --git a/src/basic-syntax/functions-interlude.md b/src/basic-syntax/functions-interlude.md
deleted file mode 100644
index caa17065..00000000
--- a/src/basic-syntax/functions-interlude.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Function Overloading
-
-Overloading is not supported:
-
-* Each function has a single implementation:
-  * Always takes a fixed number of parameters.
-  * Always takes a single set of parameter types.
-* Default values are not supported:
-  * All call sites have the same number of arguments.
-  * Macros are sometimes used as an alternative.
-
-However, function parameters can be generic:
-
-```rust,editable
-fn pick_one<T>(a: T, b: T) -> T {
-    if std::process::id() % 2 == 0 { a } else { b }
-}
-
-fn main() {
-    println!("coin toss: {}", pick_one("heads", "tails"));
-    println!("cash prize: {}", pick_one(500, 1000));
-}
-```
-
-<details>
-
-* When using generics, the standard library's `Into<T>` can provide a kind of limited
-  polymorphism on argument types. We will see more details in a later section.
-
-</details>
-
diff --git a/src/basic-syntax/functions.md b/src/basic-syntax/functions.md
deleted file mode 100644
index 603c9fb5..00000000
--- a/src/basic-syntax/functions.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Functions
-
-A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview question:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    print_fizzbuzz_to(20);
-}
-
-fn is_divisible(n: u32, divisor: u32) -> bool {
-    if divisor == 0 {
-        return false;
-    }
-    n % divisor == 0
-}
-
-fn fizzbuzz(n: u32) -> String {
-    let fizz = if is_divisible(n, 3) { "fizz" } else { "" };
-    let buzz = if is_divisible(n, 5) { "buzz" } else { "" };
-    if fizz.is_empty() && buzz.is_empty() {
-        return format!("{n}");
-    }
-    format!("{fizz}{buzz}")
-}
-
-fn print_fizzbuzz_to(n: u32) {
-    for i in 1..=n {
-        println!("{}", fizzbuzz(i));
-    }
-}
-```
-
-<details>
-
-* We refer in `main` to a function written below. Neither forward declarations nor headers are necessary. 
-* Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.
-* The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the expression.
-* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted.
-* The range expression in the `for` loop in `print_fizzbuzz_to()` contains `=n`, which causes it to include the upper bound.
-
-</details>
diff --git a/src/basic-syntax/methods.md b/src/basic-syntax/methods.md
deleted file mode 100644
index 67a6a3d9..00000000
--- a/src/basic-syntax/methods.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# Methods
-
-Methods are functions associated with a type. The `self` argument of a method is
-an instance of the type it is associated with:
-
-```rust,editable
-struct Rectangle {
-    width: u32,
-    height: u32,
-}
-
-impl Rectangle {
-    fn area(&self) -> u32 {
-        self.width * self.height
-    }
-
-    fn inc_width(&mut self, delta: u32) {
-        self.width += delta;
-    }
-}
-
-fn main() {
-    let mut rect = Rectangle { width: 10, height: 5 };
-    println!("old area: {}", rect.area());
-    rect.inc_width(5);
-    println!("new area: {}", rect.area());
-}
-```
-
-* We will look much more at methods in today's exercise and in tomorrow's class.
-
-<details>
-
-- Add a static method called `Rectangle::new` and call this from `main`:
-
-    ```rust,editable,compile_fail
-    fn new(width: u32, height: u32) -> Rectangle {
-        Rectangle { width, height }
-    }
-    ```
-
-- While _technically_, Rust does not have custom constructors, static methods are commonly used to initialize structs (but don't have to).
-  The actual constructor, `Rectangle { width, height }`, could be called directly. See the [Rustnomicon](https://doc.rust-lang.org/nomicon/constructors.html).
-
-- Add a `Rectangle::square(width: u32)` constructor to illustrate that such static methods can take arbitrary parameters.
-
-</details>
diff --git a/src/basic-syntax/references-dangling.md b/src/basic-syntax/references-dangling.md
deleted file mode 100644
index a6115c1b..00000000
--- a/src/basic-syntax/references-dangling.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# Dangling References
-
-Rust will statically forbid dangling references:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable,compile_fail
-fn main() {
-    let ref_x: &i32;
-    {
-        let x: i32 = 10;
-        ref_x = &x;
-    }
-    println!("ref_x: {ref_x}");
-}
-```
-
-* A reference is said to "borrow" the value it refers to.
-* Rust is tracking the lifetimes of all references to ensure they live long
-  enough.
-* We will talk more about borrowing when we get to ownership.
diff --git a/src/basic-syntax/references.md b/src/basic-syntax/references.md
deleted file mode 100644
index 727dedec..00000000
--- a/src/basic-syntax/references.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# References
-
-Like C++, Rust has references:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let mut x: i32 = 10;
-    let ref_x: &mut i32 = &mut x;
-    *ref_x = 20;
-    println!("x: {x}");
-}
-```
-
-Some notes:
-
-* We must dereference `ref_x` when assigning to it, similar to C and C++ pointers.
-* Rust will auto-dereference in some cases, in particular when invoking
-  methods (try `ref_x.count_ones()`).
-* References that are declared as `mut` can be bound to different values over their lifetime.
-
-<details>
-
-Key points:
-
-* Be sure to note the difference between `let mut ref_x: &i32` and `let ref_x:
-  &mut i32`. The first one represents a mutable reference which can be bound to
-  different values, while the second represents a reference to a mutable value.
-
-</details>
diff --git a/src/basic-syntax/rustdoc.md b/src/basic-syntax/rustdoc.md
deleted file mode 100644
index ca6be198..00000000
--- a/src/basic-syntax/rustdoc.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Rustdoc
-
-All language items in Rust can be documented using special `///` syntax.
-
-```rust,editable
-/// Determine whether the first argument is divisible by the second argument.
-///
-/// If the second argument is zero, the result is false.
-///
-/// # Example
-/// ```
-/// assert!(is_divisible_by(42, 2));
-/// ```
-fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
-    if rhs == 0 {
-        return false;  // Corner case, early return
-    }
-    lhs % rhs == 0     // The last expression in a block is the return value
-}
-```
-
-The contents are treated as Markdown. All published Rust library crates are
-automatically documented at [`docs.rs`](https://docs.rs) using the
-[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is
-idiomatic to document all public items in an API using this pattern.
-Code snippets can document usage and will be used as unit tests.
-
-<details>
-
-* Show students the generated docs for the `rand` crate at
-  [`docs.rs/rand`](https://docs.rs/rand).
-
-* This course does not include rustdoc on slides, just to save space, but in
-  real code they should be present.
-
-* Inner doc comments are discussed later (in the page on modules) and need not
-  be addressed here.
-
-* Rustdoc comments can contain code snippets that we can run and test using `cargo test`.
-  We will discuss these tests in the [Testing section](../testing/doc-tests.html).
-
-</details>
diff --git a/src/basic-syntax/scopes-shadowing.md b/src/basic-syntax/scopes-shadowing.md
deleted file mode 100644
index ba9c7e3a..00000000
--- a/src/basic-syntax/scopes-shadowing.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# Scopes and Shadowing
-
-You can shadow variables, both those from outer scopes and variables from the
-same scope:
-
-```rust,editable
-fn main() {
-    let a = 10;
-    println!("before: {a}");
-
-    {
-        let a = "hello";
-        println!("inner scope: {a}");
-
-        let a = true;
-        println!("shadowed in inner scope: {a}");
-    }
-
-    println!("after: {a}");
-}
-```
-
-<details>
-
-* Definition: Shadowing is different from mutation, because after shadowing both variable's memory locations exist at the same time. Both are available under the same name, depending where you use it in the code. 
-* A shadowing variable can have a different type. 
-* Shadowing looks obscure at first, but is convenient for holding on to values after `.unwrap()`.
-* The following code demonstrates why the compiler can't simply reuse memory locations when shadowing an immutable variable in a scope, even if the type does not change.
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let a = 1;
-    let b = &a;
-    let a = a + 1;
-    println!("{a} {b}");
-}
-```
-
-</details>
diff --git a/src/basic-syntax/variables.md b/src/basic-syntax/variables.md
deleted file mode 100644
index f2fd2f7e..00000000
--- a/src/basic-syntax/variables.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# Variables
-
-Rust provides type safety via static typing. Variable bindings are immutable by
-default:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let x: i32 = 10;
-    println!("x: {x}");
-    // x = 20;
-    // println!("x: {x}");
-}
-```
-
-<details>
-
-* Due to type inference the `i32` is optional. We will gradually show the types less and less as the course progresses.
-
-</details>
diff --git a/src/borrowing.md b/src/borrowing.md
new file mode 100644
index 00000000..0987bf4b
--- /dev/null
+++ b/src/borrowing.md
@@ -0,0 +1,3 @@
+# Borrowing
+
+{{%segment outline}}
diff --git a/src/borrowing/Cargo.toml b/src/borrowing/Cargo.toml
new file mode 100644
index 00000000..4d791ebb
--- /dev/null
+++ b/src/borrowing/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "borrowing"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "borrowing"
+path = "../../third_party/rust-on-exercism/health-statistics.rs"
diff --git a/src/borrowing/borrowck.md b/src/borrowing/borrowck.md
new file mode 100644
index 00000000..a8508927
--- /dev/null
+++ b/src/borrowing/borrowck.md
@@ -0,0 +1,37 @@
+---
+minutes: 10
+---
+
+# Borrow Checking
+
+Rust's _borrow checker_ puts constraints on the ways you can borrow values. For a given value, at any time:
+
+* You can have one or more shared references to the value, _or_
+* You can have exactly one exclusive reference to the value.
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable,compile_fail
+fn main() {
+    let mut a: i32 = 10;
+    let b: &i32 = &a;
+
+    {
+        let c: &mut i32 = &mut a;
+        *c = 20;
+    }
+
+    println!("a: {a}");
+    println!("b: {b}");
+}
+```
+
+<details>
+
+* Note that the requirement is that conflicting references not _exist_ at the same point. It does not matter where the reference is dereferenced.
+* The above code does not compile because `a` is borrowed as mutable (through `c`) and as immutable (through `b`) at the same time.
+* Move the `println!` statement for `b` before the scope that introduces `c` to make the code compile.
+* After that change, the compiler realizes that `b` is only ever used before the new mutable borrow of `a` through `c`. This is a feature of the borrow checker called "non-lexical lifetimes".
+* The exclusive reference constraint is quite strong. Rust uses it to ensure that data races do not occur. Rust also _relies_ on this constraint to optimize codes. For example, a value behind a shared reference can be safely cached in a register for the lifetime of that reference.
+* The borrow checker is designed to accommodate many common patterns, such as taking exclusive references to different fields in a struct at the same time. But, there are some situations where it doesn't quite "get it" and this often results in "fighting with the borrow checker."
+
+</details>
diff --git a/src/borrowing/exercise.md b/src/borrowing/exercise.md
new file mode 100644
index 00000000..eacf4715
--- /dev/null
+++ b/src/borrowing/exercise.md
@@ -0,0 +1,26 @@
+---
+minutes: 30
+---
+
+# Exercise: Health Statistics
+
+{{#include ../../third_party/rust-on-exercism/health-statistics.md}}
+
+Copy the code below to <https://play.rust-lang.org/> and fill in the missing
+methods:
+
+```rust
+// TODO: remove this when you're done with your implementation.
+#![allow(unused_variables, dead_code)]
+
+{{#include ../../third_party/rust-on-exercism/health-statistics.rs:setup}}
+
+{{#include ../../third_party/rust-on-exercism/health-statistics.rs:User_visit_doctor}}
+        todo!("Update a user's statistics based on measurements from a visit to the doctor")
+    }
+}
+
+{{#include ../../third_party/rust-on-exercism/health-statistics.rs:main}}
+
+{{#include ../../third_party/rust-on-exercism/health-statistics.rs:tests}}
+```
diff --git a/src/std/cell.md b/src/borrowing/interior-mutability.md
similarity index 83%
rename from src/std/cell.md
rename to src/borrowing/interior-mutability.md
index 39bb3a47..8b734e39 100644
--- a/src/std/cell.md
+++ b/src/borrowing/interior-mutability.md
@@ -1,4 +1,17 @@
-# `Cell` and `RefCell`
+---
+minutes: 10
+---
+
+<!-- NOTES:
+Introduce the concept, with an example based on Mutex showing an `&self` method doing mutation; reference Cell/RefCell without detail.
+-->
+# Interior Mutability
+
+Rust provides a few safe means of modifying a value given only a shared
+reference to that value. All of these replace copmile-time checks with runtime
+checks.
+
+## `Cell` and `RefCell`
 
 [`Cell`](https://doc.rust-lang.org/std/cell/struct.Cell.html) and
 [`RefCell`](https://doc.rust-lang.org/std/cell/struct.RefCell.html) implement
diff --git a/src/ownership/borrowing.md b/src/borrowing/shared.md
similarity index 83%
rename from src/ownership/borrowing.md
rename to src/borrowing/shared.md
index c88c154d..87fb5e2f 100644
--- a/src/ownership/borrowing.md
+++ b/src/borrowing/shared.md
@@ -1,7 +1,11 @@
-# Borrowing
+---
+minutes: 10
+---
 
-Instead of transferring ownership when calling a function, you can let a
-function _borrow_ the value:
+# Borrowing a Value
+
+As we saw before, instead of transferring ownership when calling a function,
+you can let a function _borrow_ the value:
 
 <!-- mdbook-xgettext: skip -->
 ```rust,editable
@@ -25,7 +29,13 @@ fn main() {
 
 <details>
 
+This slide is a review of the material on references from day 1, expanding
+slightly to include function arguments and return values.
+
+# More to Explore
+
 Notes on stack returns:
+
 * Demonstrate that the return from `add` is cheap because the compiler can eliminate the copy operation. Change the above code to print stack addresses and run it on the [Playground] or look at the assembly in [Godbolt](https://rust.godbolt.org/). In the "DEBUG" optimization level, the addresses should change, while they stay the same when changing to the "RELEASE" setting:
 
   <!-- mdbook-xgettext: skip -->
diff --git a/src/borrowing/solution.md b/src/borrowing/solution.md
new file mode 100644
index 00000000..208f24d3
--- /dev/null
+++ b/src/borrowing/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include ../../third_party/rust-on-exercism/health-statistics.rs:solution}}
+```
diff --git a/src/control-flow-basics.md b/src/control-flow-basics.md
new file mode 100644
index 00000000..48b2341e
--- /dev/null
+++ b/src/control-flow-basics.md
@@ -0,0 +1,3 @@
+# Control Flow Basics
+
+{{%segment outline}}
diff --git a/src/control-flow-basics/Cargo.toml b/src/control-flow-basics/Cargo.toml
new file mode 100644
index 00000000..8ea0c0bd
--- /dev/null
+++ b/src/control-flow-basics/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "control-flow-basics"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "collatz"
+path = "exercise.rs"
diff --git a/src/control-flow-basics/blocks-and-scopes.md b/src/control-flow-basics/blocks-and-scopes.md
new file mode 100644
index 00000000..0cbb8ca8
--- /dev/null
+++ b/src/control-flow-basics/blocks-and-scopes.md
@@ -0,0 +1,58 @@
+---
+minutes: 10
+---
+
+# Blocks and Scopes
+
+## Blocks
+
+A block in Rust contains a sequence of expressions.
+Each block has a value and a type,
+which are those of the last expression of the block:
+
+```rust,editable
+fn main() {
+    let z = 13;
+    let x = {
+        let y = 10;
+        println!("y: {y}");
+        z - y
+    };
+    println!("x: {x}");
+}
+```
+
+If the last expression ends with `;`, then the resulting value and type is `()`.
+
+## Scopes and Shadowing
+
+A variable's scope is limited to the enclosing block.
+
+You can shadow variables, both those from outer scopes and variables from the
+same scope:
+
+```rust,editable
+fn main() {
+    let a = 10;
+    println!("before: {a}");
+    {
+        let a = "hello";
+        println!("inner scope: {a}");
+
+        let a = true;
+        println!("shadowed in inner scope: {a}");
+    }
+
+    println!("after: {a}");
+}
+```
+
+<details>
+
+* You can show how the value of the block changes by changing the last line in the block. For instance, adding/removing a semicolon or using a `return`.
+* Show that a variable's scope is limited by adding a b` in the inner block in the last example, and then trying to access it outside that block.
+* Shadowing is different from mutation, because after shadowing both variable's memory locations exist at the same time. Both are available under the same name, depending where you use it in the code.
+* A shadowing variable can have a different type.
+* Shadowing looks obscure at first, but is convenient for holding on to values after `.unwrap()`.
+
+</details>
diff --git a/src/control-flow-basics/break-continue.md b/src/control-flow-basics/break-continue.md
new file mode 100644
index 00000000..da77f5aa
--- /dev/null
+++ b/src/control-flow-basics/break-continue.md
@@ -0,0 +1,59 @@
+---
+minutes: 5
+---
+
+# `break` and `continue`
+
+If you want to exit any kind of loop early, use
+[`break`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#break-expressions).
+For `loop`, this can take an optional expression that becomes the value of the `loop` expression.
+
+If you want to immediately start
+the next iteration use [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions).
+
+```rust,editable
+fn main() {
+    let (mut a, mut b) = (100, 52);
+    let result = loop {
+        if a == b {
+            break a;
+        }
+        if a < b {
+            b -= a;
+        } else {
+            a -= b;
+        }
+    };
+    println!("{result}");
+}
+```
+
+Both `continue` and `break` can optionally take a label argument which is used
+to break out of nested loops:
+
+```rust,editable
+fn main() {
+    'outer: for x in 1..5 {
+        println!("x: {x}");
+        let mut i = 0;
+        while i < x {
+            println!("x: {x}, i: {i}");
+            i += 1;
+            if i == 3 {
+                break 'outer;
+            }
+        }
+    }
+}
+```
+
+In this case we break the outer loop after 3 iterations of the inner loop.
+
+<details>
+
+* Note that `loop` is the only looping construct which returns a non-trivial
+  value. This is because it's guaranteed to be entered at least once (unlike
+  `while` and `for` loops).
+
+</details>
+
diff --git a/src/control-flow-basics/conditionals.md b/src/control-flow-basics/conditionals.md
new file mode 100644
index 00000000..7492f175
--- /dev/null
+++ b/src/control-flow-basics/conditionals.md
@@ -0,0 +1,58 @@
+---
+minutes: 5
+---
+
+# Conditionals
+
+Much of the Rust syntax will be familiar to you from C, C++ or Java:
+
+* Blocks are delimited by curly braces.
+* Line comments are started with `//`, block comments are delimited by `/* ...
+  */`.
+* Keywords like `if` and `while` work the same.
+* Variable assignment is done with `=`, comparison is done with `==`.
+
+## `if` expressions
+
+You use [`if`
+expressions](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-expressions)
+exactly like `if` statements in other languages:
+
+```rust,editable
+fn main() {
+    let x = 10;
+    if x < 20 {
+        println!("small");
+    } else if x < 100 {
+        println!("biggish");
+    } else {
+        println!("huge");
+    }
+}
+```
+
+In addition, you can use `if` as an expression. The last expression of each
+block becomes the value of the `if` expression:
+
+
+```rust,editable
+fn main() {
+    let x = 10;
+    let size = if x < 20 {
+        "small"
+    } else {
+        "large"
+    };
+    println!("number size: {}", size);
+}
+```
+
+<details>
+
+Because `if` is an expression and must have a particular type, both of its branch blocks must have the same type. Show what happens if you add `;` after `"small"` in the second example.
+
+When `if` is used in an expression, the expression must have a `;` to separate
+it from the next statement. Remove the `;` before `println!` to see the compiler
+error.
+
+</details>
diff --git a/src/control-flow-basics/exercise.md b/src/control-flow-basics/exercise.md
new file mode 100644
index 00000000..aba86b06
--- /dev/null
+++ b/src/control-flow-basics/exercise.md
@@ -0,0 +1,35 @@
+---
+minutes: 30
+---
+
+# Exercise: Collatz Sequence
+
+The [Collatz Sequence](https://en.wikipedia.org/wiki/Collatz_conjecture) is
+defined as follows, for an arbitrary n<sub>1</sub> greater than zero:
+
+- If _n<sub>i</sub>_ is 1, then the sequence terminates at _n<sub>i</sub>_.
+- If _n<sub>i</sub>_ is even, then _n<sub>i+1</sub> = n<sub>i</sub> / 2_.
+- If _n<sub>i</sub>_ is odd, then _n<sub>i+1</sub> = 3 * n<sub>i</sub> + 1_.
+
+For example, beginning with _n<sub>1</sub>_ = 3:
+ * 3 is odd, so  _n<sub>2</sub>_ = 3 * 3 + 1 = 10;
+ * 10 is even, so  _n<sub>3</sub>_ = 10 / 2 = 5;
+ * 5 is odd, so  _n<sub>4</sub>_ = 3 * 15 + 1 = 16;
+ * 16 is even, so  _n<sub>5</sub>_ = 16 / 2  = 8;
+ * 8 is even, so  _n<sub>6</sub>_ = 8 / 2  = 4;
+ * 4 is even, so  _n<sub>7</sub>_ = 4 / 2  = 2;
+ * 2 is even, so  _n<sub>8</sub>_ = 1; and
+ * the sequence terminates.
+
+Write a function to calculate the length of the collatz sequence for a given
+initial `n`.
+
+```rust,should_panic
+{{#include exercise.rs:collatz_length}}
+  todo!("Implement this")
+}
+
+{{#include exercise.rs:main}}
+  todo!("Implement this")
+}
+```
diff --git a/src/control-flow-basics/exercise.rs b/src/control-flow-basics/exercise.rs
new file mode 100644
index 00000000..2ebc2e1e
--- /dev/null
+++ b/src/control-flow-basics/exercise.rs
@@ -0,0 +1,39 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+// ANCHOR: collatz_length
+/// Determine the length of the collatz sequence beginning at `n`.
+fn collatz_length(mut n: i32) -> u32 {
+    // ANCHOR_END: collatz_length
+    let mut len = 1;
+    while n > 1 {
+        n = if n % 2 == 0 { n / 2 } else { 3 * n + 1 };
+        len += 1;
+    }
+    len
+}
+
+// ANCHOR: tests
+#[test]
+fn test_collatz_length() {
+    assert_eq!(collatz_length(11), 15);
+}
+// ANCHOR_END: tests
+
+// ANCHOR: main
+fn main() {
+    // ANCHOR_END: main
+    println!("Length: {}", collatz_length(11));
+}
diff --git a/src/control-flow-basics/functions.md b/src/control-flow-basics/functions.md
new file mode 100644
index 00000000..1c0f8176
--- /dev/null
+++ b/src/control-flow-basics/functions.md
@@ -0,0 +1,32 @@
+---
+minutes: 3
+---
+
+# Functions
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable
+fn gcd(a: u32, b: u32) -> u32 {
+    if b > 0 {
+        gcd(b, a % b)
+    } else {
+        a
+    }
+}
+
+fn main() {
+    println!("gcd: {}", gcd(143, 52));
+}
+```
+
+<details>
+
+* Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.
+* The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the expression.
+  The `return` keyword can be used for early return, but the "bare value" form is idiomatic at the end of a function (refactor `gcd` to use a `return`).
+* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted.
+* Overloading is not supported -- each function has a single implementation.
+  * Always takes a fixed number of parameters. Default arguments are not supported. Macros can be used to support variadic functions.
+  * Always takes a single set of parameter types. These types can be generic, which will be covered later.
+
+</details>
diff --git a/src/control-flow-basics/loops.md b/src/control-flow-basics/loops.md
new file mode 100644
index 00000000..40cb572e
--- /dev/null
+++ b/src/control-flow-basics/loops.md
@@ -0,0 +1,61 @@
+---
+minutes: 5
+---
+
+# Loops
+
+There are three looping keywords in Rust: `while`, `loop`, and `for`:
+
+## `while`
+
+The [`while` keyword](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
+works much like in other languages, executing the loop body as long as the
+condition is true.
+
+```rust,editable
+fn main() {
+    let mut x = 200;
+    while x >= 10 {
+        x = x / 2;
+    }
+    println!("Final x: {x}");
+}
+```
+
+## `for`
+
+The [`for` loop](https://doc.rust-lang.org/std/keyword.for.html) iterates over
+ranges of values:
+
+```rust,editable
+fn main() {
+    for x in 1..5 {
+        println!("x: {x}");
+    }
+}
+```
+
+## `loop`
+
+The [`loop` statement](https://doc.rust-lang.org/std/keyword.loop.html) just
+loops forever, until a `break`.
+
+```rust,editable
+fn main() {
+    let mut i = 0;
+    loop {
+        i += 1;
+        println!("{i}");
+        if i > 100 {
+            break;
+        }
+    }
+}
+```
+
+<details>
+
+* We will discuss iteration later; for now, just stick to range expressions.
+* Note that the `for` loop only iterates to `4`. Show the `1..=5` syntax for an inclusive range.
+
+</details>
diff --git a/src/control-flow-basics/macros.md b/src/control-flow-basics/macros.md
new file mode 100644
index 00000000..fc9624e0
--- /dev/null
+++ b/src/control-flow-basics/macros.md
@@ -0,0 +1,45 @@
+---
+minutes: 2
+---
+
+# Macros
+
+Macros are expanded into Rust code during compilation, and can take a variable
+number of arguments. They are distinguished by a `!` at the end. The Rust
+standard library includes an assortment of useful macros.
+
+* `println!(format, ..)` prints a line to standard output, applying formatting described in [`std::fmt`](https://doc.rust-lang.org/std/fmt/index.html).
+* `format!(format, ..)` works just like `println!` but returns the result as a string.
+* `dbg!(expression)` logs the value of the expression and returns it.
+* `todo!()` marks a bit of code as not-yet-implemented. If executed, it will panic.
+* `unreachable!()` marks a bit of code as unreachable. If executed, it will panic.
+
+```rust,editable
+fn factorial(n: u32) -> u32 {
+    let mut product = 1;
+    for i in 1..=n {
+        product *= dbg!(i);
+    }
+    product
+}
+
+fn fizzbuzz(n: u32) -> u32 {
+    todo!()
+}
+
+fn main() {
+    let n = 13;
+    println!("{n}! = {}", factorial(4));
+}
+```
+
+<details>
+
+The takeaway from this section is that these common conveniences exist, and how
+to use them. Why they are defined as macros, and what they expand to, is not
+especially critical.
+
+The course does not cover defining macros, but a later section will describe
+use of derive macros.
+
+</details>
diff --git a/src/control-flow-basics/solution.md b/src/control-flow-basics/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/control-flow-basics/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/control-flow.md b/src/control-flow.md
deleted file mode 100644
index 12cdc96a..00000000
--- a/src/control-flow.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# Control Flow
-
-As we have seen, `if` is an expression in Rust. It is used to conditionally
-evaluate one of two blocks, but the blocks can have a value which then becomes
-the value of the `if` expression. Other control flow expressions work similarly
-in Rust.
diff --git a/src/control-flow/blocks.md b/src/control-flow/blocks.md
deleted file mode 100644
index c9a19d0c..00000000
--- a/src/control-flow/blocks.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Blocks
-
-A block in Rust contains a sequence of expressions.
-Each block has a value and a type,
-which are those of the last expression of the block:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let x = {
-        let y = 10;
-        println!("y: {y}");
-        let z = {
-            let w = {
-                3 + 4
-            };
-            println!("w: {w}");
-            y * w
-        };
-        println!("z: {z}");
-        z - y
-    };
-    println!("x: {x}");
-}
-```
-
-If the last expression ends with `;`, then the resulting value and type is `()`.
-
-The same rule is used for functions: the value of the function body is the
-return value:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn double(x: i32) -> i32 {
-    x + x
-}
-
-fn main() {
-    println!("double: {}", double(7));
-}
-```
-
-<details>
-
-Key Points:
-* The point of this slide is to show that blocks have a type and value in Rust. 
-* You can show how the value of the block changes by changing the last line in the block. For instance, adding/removing a semicolon or using a `return`.
-   
-</details>
diff --git a/src/control-flow/break-continue.md b/src/control-flow/break-continue.md
deleted file mode 100644
index 1b562dc3..00000000
--- a/src/control-flow/break-continue.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# `break` and `continue`
-
-- If you want to exit a loop early, use [`break`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#break-expressions),
-- If you want to immediately start
-the next iteration use [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions).
-
-Both `continue` and `break` can optionally take a label argument which is used
-to break out of nested loops:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let v = vec![10, 20, 30];
-    let mut iter = v.into_iter();
-    'outer: while let Some(x) = iter.next() {
-        println!("x: {x}");
-        let mut i = 0;
-        while i < x {
-            println!("x: {x}, i: {i}");
-            i += 1;
-            if i == 3 {
-                break 'outer;
-            }
-        }
-    }
-}
-```
-
-In this case we break the outer loop after 3 iterations of the inner loop.
diff --git a/src/control-flow/for-expressions.md b/src/control-flow/for-expressions.md
deleted file mode 100644
index 61a42a2f..00000000
--- a/src/control-flow/for-expressions.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# `for` loops
-
-The [`for` loop](https://doc.rust-lang.org/std/keyword.for.html) is closely
-related to the [`while let` loop](while-let-expressions.md). It will
-automatically call `into_iter()` on the expression and then iterate over it:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let v = vec![10, 20, 30];
-
-    for x in v {
-        println!("x: {x}");
-    }
-    
-    for i in (0..10).step_by(2) {
-        println!("i: {i}");
-    }
-}
-```
-
-You can use `break` and `continue` here as usual.
-
-<details>
-    
-* Index iteration is not a special syntax in Rust for just that case.
-* `(0..10)` is a range that implements an `Iterator` trait. 
-* `step_by` is a method that returns another `Iterator` that skips every other element. 
-* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be mutable and the for loop to `for x in v.iter_mut()`.
-
-</details>
diff --git a/src/control-flow/if-expressions.md b/src/control-flow/if-expressions.md
deleted file mode 100644
index 3a45e4ce..00000000
--- a/src/control-flow/if-expressions.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# `if` expressions
-
-You use [`if`
-expressions](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-expressions)
-exactly like `if` statements in other languages:
-
-```rust,editable
-fn main() {
-    let mut x = 10;
-    if x % 2 == 0 {
-        x = x / 2;
-    } else {
-        x = 3 * x + 1;
-    }
-}
-```
-
-In addition, you can use `if` as an expression. The last expression of each
-block becomes the value of the `if` expression:
-
-
-```rust,editable
-fn main() {
-    let mut x = 10;
-    x = if x % 2 == 0 {
-        x / 2
-    } else {
-        3 * x + 1
-    };
-}
-```
-
-<details>
-
-Because `if` is an expression and must have a particular type, both of its branch blocks must have the same type. Consider showing what happens if you add `;` after `x / 2` in the second example.
-    
-</details>
diff --git a/src/control-flow/if-let-expressions.md b/src/control-flow/if-let-expressions.md
deleted file mode 100644
index a03a6207..00000000
--- a/src/control-flow/if-let-expressions.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# `if let` expressions
-
-The [`if let`
-expression](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions)
-lets you execute different code depending on whether a value matches a pattern:
-
-```rust,editable
-fn main() {
-    let arg = std::env::args().next();
-    if let Some(value) = arg {
-        println!("Program name: {value}");
-    } else {
-        println!("Missing name?");
-    }
-}
-```
-
-See [pattern matching](../pattern-matching.md) for more details on patterns in
-Rust.
-
-<details>
-
-* Unlike `match`, `if let` does not have to cover all branches. This can make it more concise than `match`.
-* A common usage is handling `Some` values when working with `Option`.
-* Unlike `match`, `if let` does not support guard clauses for pattern matching.
-* Since 1.65, a similar [let-else](https://doc.rust-lang.org/rust-by-example/flow_control/let_else.html) construct allows to do a destructuring assignment, or if it fails, execute a block which is required to abort normal control flow (with `panic`/`return`/`break`/`continue`):
-
-   <!-- mdbook-xgettext: skip -->
-   ```rust,editable
-   fn main() {
-       println!("{:?}", second_word_to_upper("foo bar"));
-   }
-    
-   fn second_word_to_upper(s: &str) -> Option<String> {
-       let mut it = s.split(' ');
-       let (Some(_), Some(item)) = (it.next(), it.next()) else {
-           return None;
-       };
-       Some(item.to_uppercase())
-   }
-
-</details>
diff --git a/src/control-flow/loop-expressions.md b/src/control-flow/loop-expressions.md
deleted file mode 100644
index 3a92b1dd..00000000
--- a/src/control-flow/loop-expressions.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# `loop` expressions
-
-Finally, there is a [`loop` keyword](https://doc.rust-lang.org/reference/expressions/loop-expr.html#infinite-loops)
-which creates an endless loop.
-
-Here you must either `break` or `return` to stop the loop:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let mut x = 10;
-    loop {
-        x = if x % 2 == 0 {
-            x / 2
-        } else {
-            3 * x + 1
-        };
-        if x == 1 {
-            break;
-        }
-    }
-    println!("x: {x}");
-}
-```
-
-<details>
-    
-* Break the `loop` with a value (e.g. `break 8`) and print it out.
-* Note that `loop` is the only looping construct which returns a non-trivial
-  value. This is because it's guaranteed to be entered at least once (unlike
-  `while` and `for` loops).
-
-</details>
diff --git a/src/control-flow/match-expressions.md b/src/control-flow/match-expressions.md
deleted file mode 100644
index b410ca7e..00000000
--- a/src/control-flow/match-expressions.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# `match` expressions
-
-The [`match` keyword](https://doc.rust-lang.org/reference/expressions/match-expr.html)
-is used to match a value against one or more patterns. In that sense, it works
-like a series of `if let` expressions:
-
-```rust,editable
-fn main() {
-    match std::env::args().next().as_deref() {
-        Some("cat") => println!("Will do cat things"),
-        Some("ls")  => println!("Will ls some files"),
-        Some("mv")  => println!("Let's move some files"),
-        Some("rm")  => println!("Uh, dangerous!"),
-        None        => println!("Hmm, no program name?"),
-        _           => println!("Unknown program name!"),
-    }
-}
-```
-
-Like `if let`, each match arm must have the same type. The type is the last
-expression of the block, if any. In the example above, the type is `()`.
-
-See [pattern matching](../pattern-matching.md) for more details on patterns in
-Rust.
-
-<details>
-
-* Save the match expression to a variable and print it out.
-* Remove `.as_deref()` and explain the error.
-    * `std::env::args().next()` returns an `Option<String>`, but we cannot match against `String`.
-    * `as_deref()` transforms an `Option<T>` to `Option<&T::Target>`. In our case, this turns `Option<String>` into `Option<&str>`.
-    * We can now use pattern matching to match against the `&str` inside `Option`.
-</details>
diff --git a/src/control-flow/novel.md b/src/control-flow/novel.md
deleted file mode 100644
index 9205e76b..00000000
--- a/src/control-flow/novel.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Novel Control Flow
-
-Rust has a few control flow constructs which differ from other languages. They
-are used for pattern matching:
-
-- `if let` expressions
-- `while let` expressions
-- `match` expressions
diff --git a/src/control-flow/while-expressions.md b/src/control-flow/while-expressions.md
deleted file mode 100644
index fc3f267f..00000000
--- a/src/control-flow/while-expressions.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# `while` loops
-
-The [`while` keyword](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
-works very similar to other languages:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let mut x = 10;
-    while x != 1 {
-        x = if x % 2 == 0 {
-            x / 2
-        } else {
-            3 * x + 1
-        };
-    }
-    println!("x: {x}");
-}
-```
-
diff --git a/src/control-flow/while-let-expressions.md b/src/control-flow/while-let-expressions.md
deleted file mode 100644
index 98b17687..00000000
--- a/src/control-flow/while-let-expressions.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# `while let` loops
-
-Like with `if let`, there is a [`while let`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-pattern-loops)
-variant which repeatedly tests a value against a pattern:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let v = vec![10, 20, 30];
-    let mut iter = v.into_iter();
-
-    while let Some(x) = iter.next() {
-        println!("x: {x}");
-    }
-}
-```
-
-Here the iterator returned by `v.into_iter()` will return a `Option<i32>` on every
-call to `next()`. It returns `Some(x)` until it is done, after which it will
-return `None`. The `while let` lets us keep iterating through all items.
-
-See [pattern matching](../pattern-matching.md) for more details on patterns in
-Rust.
-
-<details>
-
-* Point out that the `while let` loop will keep going as long as the value matches the pattern.
-* You could rewrite the `while let` loop as an infinite loop with an if statement that breaks when there is no value to unwrap for `iter.next()`. The `while let` provides syntactic sugar for the above scenario.
-    
-</details>
diff --git a/src/enums.md b/src/enums.md
deleted file mode 100644
index ed59fdd4..00000000
--- a/src/enums.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Enums
-
-The `enum` keyword allows the creation of a type which has a few
-different variants:
-
-```rust,editable
-fn generate_random_number() -> i32 {
-    // Implementation based on https://xkcd.com/221/
-    4  // Chosen by fair dice roll. Guaranteed to be random.
-}
-
-#[derive(Debug)]
-enum CoinFlip {
-    Heads,
-    Tails,
-}
-
-fn flip_coin() -> CoinFlip {
-    let random_number = generate_random_number();
-    if random_number % 2 == 0 {
-        return CoinFlip::Heads;
-    } else {
-        return CoinFlip::Tails;
-    }
-}
-
-fn main() {
-    println!("You got: {:?}", flip_coin());
-}
-```
-
-<details>
-    
-Key Points:
-
-* Enumerations allow you to collect a set of values under one type
-* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tails`. You might note the namespace when using variants.
-* This might be a good time to compare Structs and Enums:
-  * In both, you can have a simple version without fields (unit struct) or one with different types of fields (variant payloads). 
-  * In both, associated functions are defined within an `impl` block.
-  * You could even implement the different variants of an enum with separate structs but then they wouldn’t be the same type as they would if they were all defined in an enum. 
-</details>
diff --git a/src/enums/variant-payloads.md b/src/enums/variant-payloads.md
deleted file mode 100644
index 3c135656..00000000
--- a/src/enums/variant-payloads.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Variant Payloads
-
-You can define richer enums where the variants carry data. You can then use the
-`match` statement to extract the data from each variant:
-
-```rust,editable
-{{#include ../../third_party/rust-by-example/webevent.rs}}
-```
-
-<details>
-
-* The values in the enum variants can only be accessed after being pattern matched. The pattern binds references to the fields in the "match arm" after the `=>`.
-  * The expression is matched against the patterns from top to bottom. There is no fall-through like in C or C++.
-  * The match expression has a value. The value is the last expression in the match arm which was executed.
-  * Starting from the top we look for what pattern matches the value then run the code following the arrow. Once we find a match, we stop. 
-* Demonstrate what happens when the search is inexhaustive. Note the advantage the Rust compiler provides by confirming when all cases are handled. 
-* `match` inspects a hidden discriminant field in the `enum`.
-* It is possible to retrieve the discriminant by calling `std::mem::discriminant()`
-  * This is useful, for example, if implementing `PartialEq` for structs where comparing field values doesn't affect equality.
-* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::Click(Click)` with a top level `struct Click { ... }`. The inlined version cannot implement traits, for example.  
-  
-</details>
diff --git a/src/error-handling.md b/src/error-handling.md
index ed93e0b4..2fa61598 100644
--- a/src/error-handling.md
+++ b/src/error-handling.md
@@ -1,7 +1,3 @@
 # Error Handling
 
-Error handling in Rust is done using explicit control flow:
-
-* Functions that can have errors list this in their return type,
-* There are no exceptions.
-
+{{%segment outline}}
diff --git a/src/error-handling/Cargo.toml b/src/error-handling/Cargo.toml
new file mode 100644
index 00000000..398fe3c5
--- /dev/null
+++ b/src/error-handling/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "error-handling"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+thiserror = "*"
+anyhow = "*"
+
+[[bin]]
+name = "parser"
+path = "exercise.rs"
diff --git a/src/error-handling/converting-error-types.md b/src/error-handling/converting-error-types.md
deleted file mode 100644
index 5970a9dc..00000000
--- a/src/error-handling/converting-error-types.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Converting Error Types
-
-The effective expansion of `?` is a little more complicated than previously indicated:
-
-```rust,ignore
-expression?
-```
-
-works the same as
-
-```rust,ignore
-match expression {
-    Ok(value) => value,
-    Err(err)  => return Err(From::from(err)),
-}
-```
-
-The `From::from` call here means we attempt to convert the error type to the
-type returned by the function.
diff --git a/src/error-handling/deriving-error-enums.md b/src/error-handling/deriving-error-enums.md
deleted file mode 100644
index 1b18ae0f..00000000
--- a/src/error-handling/deriving-error-enums.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Deriving Error Enums
-
-The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create an
-error enum like we did on the previous page:
-
-```rust,editable,compile_fail
-use std::{fs, io};
-use std::io::Read;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-enum ReadUsernameError {
-    #[error("Could not read: {0}")]
-    IoError(#[from] io::Error),
-    #[error("Found no username in {0}")]
-    EmptyUsername(String),
-}
-
-fn read_username(path: &str) -> Result<String, ReadUsernameError> {
-    let mut username = String::new();
-    fs::File::open(path)?.read_to_string(&mut username)?;
-    if username.is_empty() {
-        return Err(ReadUsernameError::EmptyUsername(String::from(path)));
-    }
-    Ok(username)
-}
-
-fn main() {
-    //fs::write("config.dat", "").unwrap();
-    match read_username("config.dat") {
-        Ok(username) => println!("Username: {username}"),
-        Err(err)     => println!("Error: {err}"),
-    }
-}
-```
-
-<details>
-
-`thiserror`'s derive macro automatically implements `std::error::Error`, and optionally `Display`
-(if the `#[error(...)]` attributes are provided) and `From` (if the `#[from]` attribute is added).
-It also works for structs.
-
-It doesn't affect your public API, which makes it good for libraries.
-
-</details>
diff --git a/src/error-handling/dynamic-errors.md b/src/error-handling/dynamic-errors.md
deleted file mode 100644
index dd5b0ae0..00000000
--- a/src/error-handling/dynamic-errors.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Dynamic Error Types
-
-Sometimes we want to allow any type of error to be returned without writing our own enum covering
-all the different possibilities. `std::error::Error` makes this easy.
-
-```rust,editable,compile_fail
-use std::fs;
-use std::io::Read;
-use thiserror::Error;
-use std::error::Error;
-
-#[derive(Clone, Debug, Eq, Error, PartialEq)]
-#[error("Found no username in {0}")]
-struct EmptyUsernameError(String);
-
-fn read_username(path: &str) -> Result<String, Box<dyn Error>> {
-    let mut username = String::new();
-    fs::File::open(path)?.read_to_string(&mut username)?;
-    if username.is_empty() {
-        return Err(EmptyUsernameError(String::from(path)).into());
-    }
-    Ok(username)
-}
-
-fn main() {
-    //fs::write("config.dat", "").unwrap();
-    match read_username("config.dat") {
-        Ok(username) => println!("Username: {username}"),
-        Err(err)     => println!("Error: {err}"),
-    }
-}
-```
-
-<details>
-
-This saves on code, but gives up the ability to cleanly handle different error cases differently in
-the program. As such it's generally not a good idea to use `Box<dyn Error>` in the public API of a
-library, but it can be a good option in a program where you just want to display the error message
-somewhere.
-
-</details>
diff --git a/src/error-handling/error.md b/src/error-handling/error.md
new file mode 100644
index 00000000..3c490a9f
--- /dev/null
+++ b/src/error-handling/error.md
@@ -0,0 +1,42 @@
+---
+minutes: 5
+---
+
+# Dynamic Error Types
+
+Sometimes we want to allow any type of error to be returned without writing our
+own enum covering all the different possibilities. The `std::error::Error`
+trait makes it easy to create a trait object that can contain any error.
+
+```rust,editable
+use std::error::Error;
+use std::fs;
+use std::io::Read;
+
+fn read_count(path: &str) -> Result<i32, Box<dyn Error>> {
+    let mut count_str = String::new();
+    fs::File::open(path)?.read_to_string(&mut count_str)?;
+    let count: i32 = count_str.parse()?;
+    Ok(count)
+}
+
+fn main() {
+    fs::write("count.dat", "1i3").unwrap();
+    match read_count("count.dat") {
+        Ok(count) => println!("Count: {count}"),
+        Err(err) => println!("Error: {err}"),
+    }
+}
+```
+
+<details>
+
+The `read_count` function can return `std::io::Error` (from file operations) or
+`std::num::ParseIntError` (from `String::parse`).
+
+Boxing errors saves on code, but gives up the ability to cleanly handle different error cases differently in
+the program. As such it's generally not a good idea to use `Box<dyn Error>` in the public API of a
+library, but it can be a good option in a program where you just want to display the error message
+somewhere.
+
+</details>
diff --git a/src/error-handling/exercise.md b/src/error-handling/exercise.md
new file mode 100644
index 00000000..4a486083
--- /dev/null
+++ b/src/error-handling/exercise.md
@@ -0,0 +1,20 @@
+---
+minutes: 20
+---
+
+# Exercise: Rewriting with Result
+
+The following implements a very simple parser for an expression language.
+However, it handles errors by panicking. Rewrite it to instead use idiomatic
+error handling and propagate errors to a return from `main`. Feel free to use
+`thiserror` and `anyhow`.
+
+HINT: start by fixing error handling in the `parse` function. Once that is
+working correctly, update `Tokenizer` to implement
+`Iterator<Item=Result<Token, TokenizerError>>` and handle that in the parser.
+
+```rust,editable
+{{#include exercise.rs:types}}
+
+{{#include exercise.rs:panics}}
+```
diff --git a/src/error-handling/exercise.rs b/src/error-handling/exercise.rs
new file mode 100644
index 00000000..17f2b22b
--- /dev/null
+++ b/src/error-handling/exercise.rs
@@ -0,0 +1,211 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+use thiserror::Error;
+// ANCHOR: types
+use std::iter::Peekable;
+use std::str::Chars;
+
+/// An arithmetic operator.
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum Op {
+    Add,
+    Sub,
+}
+
+/// A token in the expression language.
+#[derive(Debug, PartialEq)]
+enum Token {
+    Number(String),
+    Identifier(String),
+    Operator(Op),
+}
+
+/// An expression in the expression language.
+#[derive(Debug, PartialEq)]
+enum Expression {
+    /// A reference to a variable.
+    Var(String),
+    /// A literal number.
+    Number(u32),
+    /// A binary operation.
+    Operation(Box<Expression>, Op, Box<Expression>),
+}
+// ANCHOR_END: types
+
+fn tokenize(input: &str) -> Tokenizer {
+    return Tokenizer(input.chars().peekable());
+}
+
+#[derive(Debug, Error)]
+enum TokenizerError {
+    #[error("Unexpected character '{0}' in input")]
+    UnexpectedCharacter(char),
+}
+
+struct Tokenizer<'a>(Peekable<Chars<'a>>);
+
+impl<'a> Iterator for Tokenizer<'a> {
+    type Item = Result<Token, TokenizerError>;
+
+    fn next(&mut self) -> Option<Result<Token, TokenizerError>> {
+        let Some(c) = self.0.next() else {
+            return None;
+        };
+        match c {
+            '0'..='9' => {
+                let mut num = String::from(c);
+                while let Some(c @ '0'..='9') = self.0.peek() {
+                    num.push(*c);
+                    self.0.next();
+                }
+                Some(Ok(Token::Number(num)))
+            }
+            'a'..='z' => {
+                let mut ident = String::from(c);
+                while let Some(c @ 'a'..='z' | c @ '_' | c @ '0'..='9') = self.0.peek() {
+                    ident.push(*c);
+                    self.0.next();
+                }
+                Some(Ok(Token::Identifier(ident)))
+            }
+            '+' => Some(Ok(Token::Operator(Op::Add))),
+            '-' => Some(Ok(Token::Operator(Op::Sub))),
+            _ => Some(Err(TokenizerError::UnexpectedCharacter(c))),
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+enum ParserError {
+    #[error("Tokenizer error: {0}")]
+    TokenizerError(#[from] TokenizerError),
+    #[error("Unexpected end of input")]
+    UnexpectedEOF,
+    #[error("Unexpected token {0:?}")]
+    UnexpectedToken(Token),
+    #[error("Invalid number")]
+    InvalidNumber(#[from] std::num::ParseIntError),
+}
+
+fn parse(input: &str) -> Result<Expression, ParserError> {
+    let mut tokens = tokenize(input);
+
+    fn parse_expr<'a>(tokens: &mut Tokenizer<'a>) -> Result<Expression, ParserError> {
+        let Some(tok) = tokens.next().transpose()? else {
+            return Err(ParserError::UnexpectedEOF);
+        };
+        let expr = match tok {
+            Token::Number(num) => {
+                let v = num.parse()?;
+                Expression::Number(v)
+            }
+            Token::Identifier(ident) => Expression::Var(ident),
+            Token::Operator(_) => return Err(ParserError::UnexpectedToken(tok)),
+        };
+        // Look ahead to parse a binary operation if present.
+        Ok(match tokens.next() {
+            None => expr,
+            Some(Ok(Token::Operator(op))) => {
+                Expression::Operation(Box::new(expr), op, Box::new(parse_expr(tokens)?))
+            }
+            Some(Err(e)) => return Err(e.into()),
+            Some(Ok(tok)) => return Err(ParserError::UnexpectedToken(tok)),
+        })
+    }
+
+    parse_expr(&mut tokens)
+}
+
+fn main() -> anyhow::Result<()> {
+    let expr = parse("10+foo+20-30")?;
+    println!("{expr:?}");
+    Ok(())
+}
+// ANCHOR_END: solution
+
+/*
+// ANCHOR: panics
+fn tokenize(input: &str) -> Tokenizer {
+    return Tokenizer(input.chars().peekable());
+}
+
+struct Tokenizer<'a>(Peekable<Chars<'a>>);
+
+impl<'a> Iterator for Tokenizer<'a> {
+    type Item = Token;
+
+    fn next(&mut self) -> Option<Token> {
+        let Some(c) = self.0.next() else {
+            return None;
+        };
+        match c {
+            '0'..='9' => {
+                let mut num = String::from(c);
+                while let Some(c @ '0'..='9') = self.0.peek() {
+                    num.push(*c);
+                    self.0.next();
+                }
+                Some(Token::Number(num))
+            }
+            'a'..='z' => {
+                let mut ident = String::from(c);
+                while let Some(c @ 'a'..='z' | c @ '_' | c @ '0'..='9') = self.0.peek() {
+                    ident.push(*c);
+                    self.0.next();
+                }
+                Some(Token::Identifier(ident))
+            }
+            '+' => Some(Token::Operator(Op::Add)),
+            '-' => Some(Token::Operator(Op::Sub)),
+            _ => panic!("Unexpected character {c}"),
+        }
+    }
+}
+
+fn parse(input: &str) -> Expression {
+    let mut tokens = tokenize(input);
+
+    fn parse_expr<'a>(tokens: &mut Tokenizer<'a>) -> Expression {
+        let Some(tok) = tokens.next() else {
+            panic!("Unexpected end of input");
+        };
+        let expr = match tok {
+            Token::Number(num) => {
+                let v = num.parse().expect("Invalid 32-bit integer'");
+                Expression::Number(v)
+            }
+            Token::Identifier(ident) => Expression::Var(ident),
+            Token::Operator(_) => panic!("Unexpected token {tok:?}"),
+        };
+        // Look ahead to parse a binary operation if present.
+        match tokens.next() {
+            None => expr,
+            Some(Token::Operator(op)) => {
+                Expression::Operation(Box::new(expr), op, Box::new(parse_expr(tokens)))
+            }
+            Some(tok) => panic!("Unexpected token {tok:?}"),
+        }
+    }
+
+    parse_expr(&mut tokens)
+}
+
+fn main() {
+    let expr = parse("10+foo+20-30");
+    println!("{expr:?}");
+}
+// ANCHOR_END: panics
+*/
diff --git a/src/error-handling/panic-unwind.md b/src/error-handling/panic-unwind.md
deleted file mode 100644
index 65d57feb..00000000
--- a/src/error-handling/panic-unwind.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Catching the Stack Unwinding
-
-By default, a panic will cause the stack to unwind. The unwinding can be caught:
-
-```rust,editable
-use std::panic;
-
-fn main() {
-    let result = panic::catch_unwind(|| {
-        "No problem here!"
-    });
-    println!("{result:?}");
-
-    let result = panic::catch_unwind(|| {
-        panic!("oh no!");
-    });
-    println!("{result:?}");
-}
-```
-
-- This can be useful in servers which should keep running even if a single
-  request crashes.
-- This does not work if `panic = 'abort'` is set in your `Cargo.toml`.
diff --git a/src/error-handling/panics.md b/src/error-handling/panics.md
index df91c63f..ee398f90 100644
--- a/src/error-handling/panics.md
+++ b/src/error-handling/panics.md
@@ -1,5 +1,11 @@
+---
+minutes: 3
+---
+
 # Panics
 
+Rust handles fatal errors with a "panic".
+
 Rust will trigger a panic if a fatal error happens at runtime:
 
 ```rust,editable,should_panic
@@ -11,4 +17,35 @@ fn main() {
 
 * Panics are for unrecoverable and unexpected errors.
   * Panics are symptoms of bugs in the program.
+  * Runtime failures like failed bounds checks can panic
+  * Assertions (such as `assert!`) panic on failure
+  * Purpose-specific panics can use the `panic!` macro.
+* A panic will "unwind" the stack, dropping values just as if the functions had returned.
 * Use non-panicking APIs (such as `Vec::get`) if crashing is not acceptable.
+
+<details>
+
+By default, a panic will cause the stack to unwind. The unwinding can be caught:
+
+```rust,editable
+use std::panic;
+
+fn main() {
+    let result = panic::catch_unwind(|| {
+        "No problem here!"
+    });
+    println!("{result:?}");
+
+    let result = panic::catch_unwind(|| {
+        panic!("oh no!");
+    });
+    println!("{result:?}");
+}
+```
+
+- Catching is unusual; do not attempt to implement exceptions with `catch_unwind`!
+- This can be useful in servers which should keep running even if a single
+  request crashes.
+- This does not work if `panic = 'abort'` is set in your `Cargo.toml`.
+
+</details>
diff --git a/src/error-handling/result.md b/src/error-handling/result.md
deleted file mode 100644
index 88d16365..00000000
--- a/src/error-handling/result.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# Structured Error Handling with `Result`
-
-We have already seen the `Result` enum. This is used pervasively when errors are
-expected as part of normal operation:
-
-```rust,editable
-use std::fs;
-use std::io::Read;
-
-fn main() {
-    let file = fs::File::open("diary.txt");
-    match file {
-        Ok(mut file) => {
-            let mut contents = String::new();
-            file.read_to_string(&mut contents);
-            println!("Dear diary: {contents}");
-        },
-        Err(err) => {
-            println!("The diary could not be opened: {err}");
-        }
-    }
-}
-```
-
-<details>
-
-  * As with `Option`, the successful value sits inside of `Result`, forcing the developer to
-    explicitly extract it. This encourages error checking. In the case where an error should never happen,
-    `unwrap()` or `expect()` can be called, and this is a signal of the developer intent too.  
-  * `Result` documentation is a recommended read. Not during the course, but it is worth mentioning. 
-    It contains a lot of convenience methods and functions that help functional-style programming. 
-    
-</details>
diff --git a/src/error-handling/solution.md b/src/error-handling/solution.md
new file mode 100644
index 00000000..81412e7b
--- /dev/null
+++ b/src/error-handling/solution.md
@@ -0,0 +1,6 @@
+# Solution
+
+<!-- compile_fail because `mdbook test` does not allow use of `thiserror` -->
+```rust,editable,compile_fail
+{{#include exercise.rs:solution}}
+```
diff --git a/src/error-handling/error-contexts.md b/src/error-handling/thiserror-and-anyhow.md
similarity index 63%
rename from src/error-handling/error-contexts.md
rename to src/error-handling/thiserror-and-anyhow.md
index 50fb5948..c2a2f30c 100644
--- a/src/error-handling/error-contexts.md
+++ b/src/error-handling/thiserror-and-anyhow.md
@@ -1,14 +1,23 @@
-# Adding Context to Errors
+---
+minutes: 5
+---
 
-The widely used [anyhow](https://docs.rs/anyhow/) crate can help you add
-contextual information to your errors and allows you to have fewer
-custom error types:
+# `thiserror`  and `anyhow`
+
+The [`thiserror`](https://docs.rs/thiserror/)  and [`anyhow`](https://docs.rs/anyhow/)
+crates are widley used to simplify error handling. `thiserror` helps
+create custom error types that implement `From<T>`. `anyhow` helps with error
+handling in functions, including adding contextual information to your errors.
 
 ```rust,editable,compile_fail
 use std::{fs, io};
 use std::io::Read;
 use anyhow::{Context, Result, bail};
 
+#[derive(Clone, Debug, Eq, Error, PartialEq)]
+#[error("Found no username in {0}")]
+struct EmptyUsernameError(String);
+
 fn read_username(path: &str) -> Result<String> {
     let mut username = String::with_capacity(100);
     fs::File::open(path)
@@ -16,7 +25,7 @@ fn read_username(path: &str) -> Result<String> {
         .read_to_string(&mut username)
         .context("Failed to read")?;
     if username.is_empty() {
-        bail!("Found no username in {path}");
+        bail!(EmptyUsernameError(path));
     }
     Ok(username)
 }
@@ -32,6 +41,8 @@ fn main() {
 
 <details>
 
+* The `Error` derive macro is provided by `thiserror`, and has lots of useful
+  attributes like `#[error]` to help define a useful error type.
 * `anyhow::Result<V>` is a type alias for `Result<V, anyhow::Error>`.
 * `anyhow::Error` is essentially a wrapper around `Box<dyn Error>`. As such it's again generally not
   a good choice for the public API of a library, but is widely used in applications.
diff --git a/src/error-handling/converting-error-types-example.md b/src/error-handling/try-conversions.md
similarity index 57%
rename from src/error-handling/converting-error-types-example.md
rename to src/error-handling/try-conversions.md
index 1e83b470..f3426d8c 100644
--- a/src/error-handling/converting-error-types-example.md
+++ b/src/error-handling/try-conversions.md
@@ -1,4 +1,29 @@
-# Converting Error Types
+---
+minutes: 5
+---
+
+# Try Conversions
+
+The effective expansion of `?` is a little more complicated than previously indicated:
+
+```rust,ignore
+expression?
+```
+
+works the same as
+
+```rust,ignore
+match expression {
+    Ok(value) => value,
+    Err(err)  => return Err(From::from(err)),
+}
+```
+
+The `From::from` call here means we attempt to convert the error type to the
+type returned by the function. This makes it easy to encapsulate errors into
+higher-level errors.
+
+## Example
 
 ```rust,editable
 use std::error::Error;
@@ -47,10 +72,15 @@ fn main() {
 
 <details>
 
-Key points:
+The return type of the function has to be compatible with the nested functions it calls. For instance,
+a function returning a `Result<T, Err>` can only apply the `?` operator on a function returning a
+`Result<AnyT, Err>`. It cannot apply the `?` operator on a function returning an `Option<AnyT>` or `Result<T, OtherErr>`
+unless `OtherErr` implements `From<Err>`. Reciprocally, a function returning an `Option<T>` can only apply the `?` operator
+on a function returning an `Option<AnyT>`.
+
+You can convert incompatible types into one another with the different `Option` and `Result` methods
+such as `Option::ok_or`, `Result::ok`, `Result::err`.
 
-* The `username` variable can be either `Ok(string)` or `Err(error)`.
-* Use the `fs::write` call to test out the different scenarios: no file, empty file, file with username.
 
 It is good practice for all error types that don't need to be `no_std` to implement `std::error::Error`, which requires `Debug` and `Display`. The `Error` crate for `core` is only available in [nightly](https://github.com/rust-lang/rust/issues/103765), so not fully `no_std` compatible yet.
 
@@ -58,4 +88,6 @@ It's generally helpful for them to implement `Clone` and `Eq` too where possible
 life easier for tests and consumers of your library. In this case we can't easily do so, because
 `io::Error` doesn't implement them.
 
+A common alternative to a `From` implementation is `Result::map_err`, especially when the conversion only happens in one place.
+
 </details>
diff --git a/src/error-handling/try-operator.md b/src/error-handling/try.md
similarity index 57%
rename from src/error-handling/try-operator.md
rename to src/error-handling/try.md
index b7e91bbc..93744af4 100644
--- a/src/error-handling/try-operator.md
+++ b/src/error-handling/try.md
@@ -1,7 +1,13 @@
-# Propagating Errors with `?`
+---
+minutes: 5
+---
 
-The try-operator `?` is used to return errors to the caller. It lets you turn
-the common
+# Try Operator
+
+Runtime errors like connection-refused or file-not-found are handled with the
+`Result` type, but matching this type on every call can be cumbersome.  The
+try-operator `?` is used to return errors to the caller. It lets you turn the
+common
 
 ```rust,ignore
 match some_expression {
@@ -45,16 +51,12 @@ fn main() {
 
 <details>
 
+Simplify the `read_username` function to use `?`.
+
 Key points:
 
 * The `username` variable can be either `Ok(string)` or `Err(error)`.
 * Use the `fs::write` call to test out the different scenarios: no file, empty file, file with username.
-* The return type of the function has to be compatible with the nested functions it calls. For instance,
-a function returning a `Result<T, Err>` can only apply the `?` operator on a function returning a 
-`Result<AnyT, Err>`. It cannot apply the `?` operator on a function returning an `Option<AnyT>` or `Result<T, OtherErr>`
-unless `OtherErr` implements `From<Err>`. Reciprocally, a function returning an `Option<T>` can only apply the `?` operator 
-on a function returning an `Option<AnyT>`.
-    * You can convert incompatible types into one another with the different `Option` and `Result` methods 
-    such as `Option::ok_or`, `Result::ok`, `Result::err`.
+* Note that `main` can return a `Result<(), E>` as long as it implements `std::process:Termination`. In practice, this means that `E` implements `Debug`. The executable will print the `Err` variant and return a nonzero exit status on error.
 
 </details>
diff --git a/src/exercises/Cargo.toml b/src/exercises/Cargo.toml
index 97be1304..dc244a4d 100644
--- a/src/exercises/Cargo.toml
+++ b/src/exercises/Cargo.toml
@@ -4,38 +4,6 @@ version = "0.1.0"
 edition = "2021"
 publish = false
 
-[[bin]]
-name = "for-loops"
-path = "day-1/for-loops.rs"
-
-[[bin]]
-name = "luhn"
-path = "day-1/luhn.rs"
-
-[[bin]]
-name = "book-library"
-path = "day-2/book-library.rs"
-
-[[bin]]
-name = "health-statistics"
-path = "../../third_party/rust-on-exercism/health-statistics.rs"
-
-[[bin]]
-name = "strings-iterators"
-path = "day-2/strings-iterators.rs"
-
-[[bin]]
-name = "simple-gui"
-path = "day-3/simple-gui.rs"
-
-[[bin]]
-name = "points-polygons"
-path = "day-3/points-polygons.rs"
-
-[[bin]]
-name = "safe-ffi-wrapper"
-path = "day-3/safe-ffi-wrapper.rs"
-
 [[bin]]
 name = "dining-philosophers"
 path = "concurrency/dining-philosophers.rs"
diff --git a/src/exercises/concurrency/dining-philosophers.rs b/src/exercises/concurrency/dining-philosophers.rs
index 98eecfc8..d3bc47ed 100644
--- a/src/exercises/concurrency/dining-philosophers.rs
+++ b/src/exercises/concurrency/dining-philosophers.rs
@@ -41,8 +41,8 @@ impl Philosopher {
     fn eat(&self) {
         // ANCHOR_END: Philosopher-eat
         println!("{} is trying to eat", &self.name);
-        let left = self.left_fork.lock().unwrap();
-        let right = self.right_fork.lock().unwrap();
+        let _left = self.left_fork.lock().unwrap();
+        let _right = self.right_fork.lock().unwrap();
 
         // ANCHOR: Philosopher-eat-end
         println!("{} is eating...", &self.name);
diff --git a/src/exercises/concurrency/link-checker.rs b/src/exercises/concurrency/link-checker.rs
index e4691a3e..0b88f85c 100644
--- a/src/exercises/concurrency/link-checker.rs
+++ b/src/exercises/concurrency/link-checker.rs
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 // ANCHOR: solution
-use std::{sync::Arc, sync::Mutex, sync::mpsc, thread};
+use std::{sync::mpsc, sync::Arc, sync::Mutex, thread};
 
 // ANCHOR: setup
 use reqwest::{blocking::Client, Url};
@@ -138,7 +138,10 @@ fn control_crawl(
     result_receiver: mpsc::Receiver<CrawlResult>,
 ) -> Vec<Url> {
     let mut crawl_state = CrawlState::new(&start_url);
-    let start_command = CrawlCommand { url: start_url, extract_links: true };
+    let start_command = CrawlCommand {
+        url: start_url,
+        extract_links: true,
+    };
     command_sender.send(start_command).unwrap();
     let mut pending_urls = 1;
 
diff --git a/src/exercises/day-1/afternoon.md b/src/exercises/day-1/afternoon.md
deleted file mode 100644
index 31e2f66e..00000000
--- a/src/exercises/day-1/afternoon.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Day 1: Afternoon Exercises
-
-We will look at two things:
-
-* The Luhn algorithm,
-
-* An exercise on pattern matching.
-
-<details>
-
-After looking at the exercises, you can look at the [solutions] provided.
-
-[solutions]: solutions-afternoon.md
-
-</details>
diff --git a/src/exercises/day-1/for-loops.md b/src/exercises/day-1/for-loops.md
deleted file mode 100644
index 994f611e..00000000
--- a/src/exercises/day-1/for-loops.md
+++ /dev/null
@@ -1,94 +0,0 @@
-# Arrays and `for` Loops
-
-We saw that an array can be declared like this:
-
-```rust
-let array = [10, 20, 30];
-```
-
-You can print such an array by asking for its debug representation with `{:?}`:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let array = [10, 20, 30];
-    println!("array: {array:?}");
-}
-```
-
-Rust lets you iterate over things like arrays and ranges using the `for`
-keyword:
-
-```rust,editable
-fn main() {
-    let array = [10, 20, 30];
-    print!("Iterating over array:");
-    for n in &array {
-        print!(" {n}");
-    }
-    println!();
-
-    print!("Iterating over range:");
-    for i in 0..3 {
-        print!(" {}", array[i]);
-    }
-    println!();
-}
-```
-
-Use the above to write a function `pretty_print` which pretty-print a matrix and
-a function `transpose` which will transpose a matrix (turn rows into columns):
-
-<!-- mdbook-xgettext: skip -->
-```bob
-           ⎛⎡1 2 3⎤⎞      ⎡1 4 7⎤
-"transpose"⎜⎢4 5 6⎥⎟  "=="⎢2 5 8⎥
-           ⎝⎣7 8 9⎦⎠      ⎣3 6 9⎦
-```
-
-Hard-code both functions to operate on 3 × 3 matrices.
-
-Copy the code below to <https://play.rust-lang.org/> and implement the
-functions:
-
-```rust,should_panic
-// TODO: remove this when you're done with your implementation.
-#![allow(unused_variables, dead_code)]
-
-{{#include for-loops.rs:transpose}}
-    unimplemented!()
-}
-
-{{#include for-loops.rs:pretty_print}}
-    unimplemented!()
-}
-
-{{#include for-loops.rs:main}}
-```
-
-## Bonus Question
-
-Could you use `&[i32]` slices instead of hard-coded 3 × 3 matrices for your
-argument and return types? Something like `&[&[i32]]` for a two-dimensional
-slice-of-slices. Why or why not?
-
-
-See the [`ndarray` crate](https://docs.rs/ndarray/) for a production quality
-implementation.
-
-<details>
-
-The solution and the answer to the bonus section are available in the 
-[Solution](solutions-morning.md#arrays-and-for-loops) section.
-
-The use of the reference `&array` within `for n in &array` is a subtle
-preview of issues of ownership that will come later in the afternoon.
-
-Without the `&`...
-* The loop would have been one that consumes the array.  This is a
-  change [introduced in the 2021
-  Edition](https://doc.rust-lang.org/edition-guide/rust-2021/IntoIterator-for-arrays.html).
-* An implicit array copy would have occurred.  Since `i32` is a copy type, then
-  `[i32; 3]` is also a copy type.
-
-</details>
diff --git a/src/exercises/day-1/implicit-conversions.md b/src/exercises/day-1/implicit-conversions.md
deleted file mode 100644
index 9c69dd77..00000000
--- a/src/exercises/day-1/implicit-conversions.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Implicit Conversions
-
-Rust will not automatically apply _implicit conversions_ between types ([unlike
-C++][3]). You can see this in a program like this:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable,compile_fail
-fn multiply(x: i16, y: i16) -> i16 {
-    x * y
-}
-
-fn main() {
-    let x: i8 = 15;
-    let y: i16 = 1000;
-
-    println!("{x} * {y} = {}", multiply(x, y));
-}
-```
-
-The Rust integer types all implement the [`From<T>`][1] and [`Into<T>`][2]
-traits to let us convert between them. The `From<T>` trait has a single `from()`
-method and similarly, the `Into<T>` trait has a single `into()` method.
-Implementing these traits is how a type expresses that it can be converted into
-another type.
-
-The standard library has an implementation of `From<i8> for i16`, which means
-that we can convert a variable `x` of type `i8` to an `i16` by calling 
-`i16::from(x)`. Or, simpler, with `x.into()`, because `From<i8> for i16`
-implementation automatically create an implementation of `Into<i16> for i8`.
-
-The same applies for your own `From` implementations for your own types, so it is
-sufficient to only implement `From` to get a respective `Into` implementation automatically.
-
-1. Execute the above program and look at the compiler error.
-
-2. Update the code above to use `into()` to do the conversion.
-
-3. Change the types of `x` and `y` to other things (such as `f32`, `bool`,
-   `i128`) to see which types you can convert to which other types. Try
-   converting small types to big types and the other way around. Check the
-   [standard library documentation][1] to see if `From<T>` is implemented for
-   the pairs you check.
-
-[1]: https://doc.rust-lang.org/std/convert/trait.From.html
-[2]: https://doc.rust-lang.org/std/convert/trait.Into.html
-[3]: https://en.cppreference.com/w/cpp/language/implicit_conversion
diff --git a/src/exercises/day-1/luhn.rs b/src/exercises/day-1/luhn.rs
deleted file mode 100644
index d7e34adb..00000000
--- a/src/exercises/day-1/luhn.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// ANCHOR: solution
-// ANCHOR: luhn
-pub fn luhn(cc_number: &str) -> bool {
-    // ANCHOR_END: luhn
-    let mut sum = 0;
-    let mut double = false;
-    let mut digit_seen = 0;
-
-    for c in cc_number.chars().filter(|&f| f != ' ').rev() {
-        if let Some(digit) = c.to_digit(10) {
-            if double {
-                let double_digit = digit * 2;
-                sum += if double_digit > 9 {
-                    double_digit - 9
-                } else {
-                    double_digit
-                };
-            } else {
-                sum += digit;
-            }
-            double = !double;
-            digit_seen += 1;
-        } else {
-            return false;
-        }
-    }
-
-    if digit_seen < 2 {
-        return false;
-    }
-
-    sum % 10 == 0
-}
-
-fn main() {
-    let cc_number = "1234 5678 1234 5670";
-    println!(
-        "Is {cc_number} a valid credit card number? {}",
-        if luhn(cc_number) { "yes" } else { "no" }
-    );
-}
-
-// ANCHOR: unit-tests
-#[test]
-fn test_non_digit_cc_number() {
-    assert!(!luhn("foo"));
-    assert!(!luhn("foo 0 0"));
-}
-
-#[test]
-fn test_empty_cc_number() {
-    assert!(!luhn(""));
-    assert!(!luhn(" "));
-    assert!(!luhn("  "));
-    assert!(!luhn("    "));
-}
-
-#[test]
-fn test_single_digit_cc_number() {
-    assert!(!luhn("0"));
-}
-
-#[test]
-fn test_two_digit_cc_number() {
-    assert!(luhn(" 0 0 "));
-}
-
-#[test]
-fn test_valid_cc_number() {
-    assert!(luhn("4263 9826 4026 9299"));
-    assert!(luhn("4539 3195 0343 6467"));
-    assert!(luhn("7992 7398 713"));
-}
-
-#[test]
-fn test_invalid_cc_number() {
-    assert!(!luhn("4223 9826 4026 9299"));
-    assert!(!luhn("4539 3195 0343 6476"));
-    assert!(!luhn("8273 1232 7352 0569"));
-}
-// ANCHOR_END: unit-tests
diff --git a/src/exercises/day-1/morning.md b/src/exercises/day-1/morning.md
deleted file mode 100644
index bbda973d..00000000
--- a/src/exercises/day-1/morning.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Day 1: Morning Exercises
-
-In these exercises, we will explore two parts of Rust:
-
-* Implicit conversions between types.
-
-* Arrays and `for` loops.
-
-<details>
-
-A few things to consider while solving the exercises:
-
-* Use a local Rust installation, if possible. This way you can get
-  auto-completion in your editor. See the page about [Using Cargo] for details
-  on installing Rust.
-
-* Alternatively, use the Rust Playground.
-
-The code snippets are not editable on purpose: the inline code snippets lose
-their state if you navigate away from the page.
-
-After looking at the exercises, you can look at the [solutions] provided.
-
-[solutions]: solutions-morning.md
-
-[Using Cargo]: ../../cargo.md
-
-</details>
diff --git a/src/exercises/day-1/solutions-afternoon.md b/src/exercises/day-1/solutions-afternoon.md
deleted file mode 100644
index d72ac747..00000000
--- a/src/exercises/day-1/solutions-afternoon.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Day 1 Afternoon Exercises
-
-## Luhn Algorithm
-
-([back to exercise](luhn.md))
-
-```rust
-{{#include luhn.rs:solution}}
-```
-
-## Pattern matching
-
-```rust
-{{#include pattern-matching.rs:solution}}
-```
diff --git a/src/exercises/day-1/solutions-morning.md b/src/exercises/day-1/solutions-morning.md
deleted file mode 100644
index cbc94fb6..00000000
--- a/src/exercises/day-1/solutions-morning.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# Day 1 Morning Exercises
-
-## Arrays and `for` Loops
-
-([back to exercise](for-loops.md))
-
-```rust
-{{#include for-loops.rs:solution}}
-```
-### Bonus question
-
-It requires more advanced concepts. It might seem that we could use a slice-of-slices (`&[&[i32]]`) as the input type to transpose and thus make our function handle any size of matrix. However, this quickly breaks down: the return type cannot be `&[&[i32]]` since it needs to own the data you return.
-
-You can attempt to use something like `Vec<Vec<i32>>`, but this doesn't work out-of-the-box either: it's hard to convert from `Vec<Vec<i32>>` to `&[&[i32]]` so now you cannot easily use `pretty_print` either.
-
-Once we get to traits and generics, we'll be able to use the [`std::convert::AsRef`][1] trait to abstract over anything that can be referenced as a slice.
-
-```rust
-use std::convert::AsRef;
-use std::fmt::Debug;
-
-fn pretty_print<T, Line, Matrix>(matrix: Matrix)
-where
-    T: Debug,
-    // A line references a slice of items
-    Line: AsRef<[T]>,
-    // A matrix references a slice of lines
-    Matrix: AsRef<[Line]>
-{
-    for row in matrix.as_ref() {
-        println!("{:?}", row.as_ref());
-    }
-}
-
-fn main() {
-    // &[&[i32]]
-    pretty_print(&[&[1, 2, 3], &[4, 5, 6], &[7, 8, 9]]);
-    // [[&str; 2]; 2]
-    pretty_print([["a", "b"], ["c", "d"]]);
-    // Vec<Vec<i32>>
-    pretty_print(vec![vec![1, 2], vec![3, 4]]);
-}
-```
-
-In addition, the type itself would not enforce that the child slices are of the same length, so such variable could contain an invalid matrix.
-
-[1]: https://doc.rust-lang.org/std/convert/trait.AsRef.html
diff --git a/src/exercises/day-2/afternoon.md b/src/exercises/day-2/afternoon.md
deleted file mode 100644
index 4142dfe4..00000000
--- a/src/exercises/day-2/afternoon.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Day 2: Afternoon Exercises
-
-The exercises for this afternoon will focus on strings and iterators.
-
-<details>
-
-After looking at the exercises, you can look at the [solutions] provided.
-
-[solutions]: solutions-afternoon.md
-
-</details>
diff --git a/src/exercises/day-2/book-library.md b/src/exercises/day-2/book-library.md
deleted file mode 100644
index 6009bfed..00000000
--- a/src/exercises/day-2/book-library.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Storing Books
-
-We will learn much more about structs and the `Vec<T>` type tomorrow. For now,
-you just need to know part of its API:
-
-```rust,editable
-fn main() {
-    let mut vec = vec![10, 20];
-    vec.push(30);
-    let midpoint = vec.len() / 2;
-    println!("middle value: {}", vec[midpoint]);
-    for item in &vec {
-        println!("item: {item}");
-    }
-}
-```
-
-Use this to model a library's book collection. Copy the code below to
-<https://play.rust-lang.org/> and update the types to make it compile:
-
-```rust,should_panic
-{{#include book-library.rs:setup}}
-{{#include book-library.rs:Library_new}}
-        todo!("Initialize and return a `Library` value")
-    }
-
-{{#include book-library.rs:Library_len}}
-        todo!("Return the length of `self.books`")
-    }
-
-{{#include book-library.rs:Library_is_empty}}
-        todo!("Return `true` if `self.books` is empty")
-    }
-
-{{#include book-library.rs:Library_add_book}}
-        todo!("Add a new book to `self.books`")
-    }
-
-{{#include book-library.rs:Library_print_books}}
-        todo!("Iterate over `self.books` and print each book's title and year")
-    }
-
-{{#include book-library.rs:Library_oldest_book}}
-        todo!("Return a reference to the oldest book (if any)")
-    }
-}
-
-{{#include book-library.rs:main}}
-```
diff --git a/src/exercises/day-2/book-library.rs b/src/exercises/day-2/book-library.rs
deleted file mode 100644
index 16cf04b5..00000000
--- a/src/exercises/day-2/book-library.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// ANCHOR: solution
-// ANCHOR: setup
-struct Library {
-    books: Vec<Book>,
-}
-
-struct Book {
-    title: String,
-    year: u16,
-}
-
-impl Book {
-    // This is a constructor, used below.
-    fn new(title: &str, year: u16) -> Book {
-        Book {
-            title: String::from(title),
-            year,
-        }
-    }
-}
-
-// Implement the methods below. Notice how the `self` parameter
-// changes type to indicate the method's required level of ownership
-// over the object:
-//
-// - `&self` for shared read-only access,
-// - `&mut self` for unique and mutable access,
-// - `self` for unique access by value.
-impl Library {
-    // ANCHOR_END: setup
-
-    // ANCHOR: Library_new
-    fn new() -> Library {
-        // ANCHOR_END: Library_new
-        Library { books: Vec::new() }
-    }
-
-    // ANCHOR: Library_len
-    fn len(&self) -> usize {
-        // ANCHOR_END: Library_len
-        self.books.len()
-    }
-
-    // ANCHOR: Library_is_empty
-    fn is_empty(&self) -> bool {
-        // ANCHOR_END: Library_is_empty
-        self.books.is_empty()
-    }
-
-    // ANCHOR: Library_add_book
-    fn add_book(&mut self, book: Book) {
-        // ANCHOR_END: Library_add_book
-        self.books.push(book)
-    }
-
-    // ANCHOR: Library_print_books
-    fn print_books(&self) {
-        // ANCHOR_END: Library_print_books
-        for book in &self.books {
-            println!("{}, published in {}", book.title, book.year);
-        }
-    }
-
-    // ANCHOR: Library_oldest_book
-    fn oldest_book(&self) -> Option<&Book> {
-        // ANCHOR_END: Library_oldest_book
-        // Using a closure and a built-in method:
-        // self.books.iter().min_by_key(|book| book.year)
-
-        // Longer hand-written solution:
-        let mut oldest: Option<&Book> = None;
-        for book in self.books.iter() {
-            if oldest.is_none() || book.year < oldest.unwrap().year {
-                oldest = Some(book);
-            }
-        }
-
-        oldest
-    }
-}
-
-// ANCHOR: main
-fn main() {
-    let mut library = Library::new();
-
-    println!(
-        "The library is empty: library.is_empty() -> {}",
-        library.is_empty()
-    );
-
-    library.add_book(Book::new("Lord of the Rings", 1954));
-    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
-
-    println!(
-        "The library is no longer empty: library.is_empty() -> {}",
-        library.is_empty()
-    );
-
-    library.print_books();
-
-    match library.oldest_book() {
-        Some(book) => println!("The oldest book is {}", book.title),
-        None => println!("The library is empty!"),
-    }
-
-    println!("The library has {} books", library.len());
-    library.print_books();
-}
-// ANCHOR_END: main
-
-#[test]
-fn test_library_len() {
-    let mut library = Library::new();
-    assert_eq!(library.len(), 0);
-    assert!(library.is_empty());
-
-    library.add_book(Book::new("Lord of the Rings", 1954));
-    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
-    assert_eq!(library.len(), 2);
-    assert!(!library.is_empty());
-}
-
-#[test]
-fn test_library_is_empty() {
-    let mut library = Library::new();
-    assert!(library.is_empty());
-
-    library.add_book(Book::new("Lord of the Rings", 1954));
-    assert!(!library.is_empty());
-}
-
-#[test]
-fn test_library_print_books() {
-    let mut library = Library::new();
-    library.add_book(Book::new("Lord of the Rings", 1954));
-    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
-    // We could try and capture stdout, but let us just call the
-    // method to start with.
-    library.print_books();
-}
-
-#[test]
-fn test_library_oldest_book() {
-    let mut library = Library::new();
-    assert!(library.oldest_book().is_none());
-
-    library.add_book(Book::new("Lord of the Rings", 1954));
-    assert_eq!(
-        library.oldest_book().map(|b| b.title.as_str()),
-        Some("Lord of the Rings")
-    );
-
-    library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
-    assert_eq!(
-        library.oldest_book().map(|b| b.title.as_str()),
-        Some("Alice's Adventures in Wonderland")
-    );
-}
diff --git a/src/exercises/day-2/health-statistics.md b/src/exercises/day-2/health-statistics.md
deleted file mode 100644
index a19b5d92..00000000
--- a/src/exercises/day-2/health-statistics.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Health Statistics
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.md}}
-
-Copy the code below to <https://play.rust-lang.org/> and fill in the missing
-methods:
-
-```rust,should_panic
-// TODO: remove this when you're done with your implementation.
-#![allow(unused_variables, dead_code)]
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:setup}}
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_new}}
-        todo!("Create a new User instance")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_name}}
-        todo!("Return the user's name")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_age}}
-        todo!("Return the user's age")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_height}}
-        todo!("Return the user's height")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_doctor_visits}}
-        todo!("Return the number of time the user has visited the doctor")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_set_age}}
-        todo!("Set the user's age")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_set_height}}
-        todo!("Set the user's height")
-    }
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:User_visit_doctor}}
-        todo!("Update a user's statistics based on measurements from a visit to the doctor")
-    }
-}
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:main}}
-
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:tests}}
-```
diff --git a/src/exercises/day-2/iterators-and-ownership.md b/src/exercises/day-2/iterators-and-ownership.md
deleted file mode 100644
index 8dda0575..00000000
--- a/src/exercises/day-2/iterators-and-ownership.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# Iterators and Ownership
-
-The ownership model of Rust affects many APIs. An example of this is the
-[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) and
-[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)
-traits.
-
-## `Iterator`
-
-Traits are like interfaces: they describe behavior (methods) for a type. The
-`Iterator` trait simply says that you can call `next` until you get `None` back:
-
-```rust
-pub trait Iterator {
-    type Item;
-    fn next(&mut self) -> Option<Self::Item>;
-}
-```
-
-You use this trait like this:
-
-```rust,editable
-fn main() {
-    let v: Vec<i8> = vec![10, 20, 30];
-    let mut iter = v.iter();
-
-    println!("v[0]: {:?}", iter.next());
-    println!("v[1]: {:?}", iter.next());
-    println!("v[2]: {:?}", iter.next());
-    println!("No more items: {:?}", iter.next());
-}
-```
-
-What is the type returned by the iterator? Test your answer here:
-
-```rust,editable,compile_fail
-fn main() {
-    let v: Vec<i8> = vec![10, 20, 30];
-    let mut iter = v.iter();
-
-    let v0: Option<..> = iter.next();
-    println!("v0: {v0:?}");
-}
-```
-
-Why is this type used?
-
-## `IntoIterator`
-
-The `Iterator` trait tells you how to _iterate_ once you have created an
-iterator. The related trait `IntoIterator` tells you how to create the iterator:
-
-```rust
-pub trait IntoIterator {
-    type Item;
-    type IntoIter: Iterator<Item = Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter;
-}
-```
-
-The syntax here means that every implementation of `IntoIterator` must
-declare two types:
-
-* `Item`: the type we iterate over, such as `i8`,
-* `IntoIter`: the `Iterator` type returned by the `into_iter` method.
-
-Note that `IntoIter` and `Item` are linked: the iterator must have the same
-`Item` type, which means that it returns `Option<Item>`
-
-Like before, what  is the type returned by the iterator?
-
-```rust,editable,compile_fail
-fn main() {
-    let v: Vec<String> = vec![String::from("foo"), String::from("bar")];
-    let mut iter = v.into_iter();
-
-    let v0: Option<..> = iter.next();
-    println!("v0: {v0:?}");
-}
-```
-
-## `for` Loops
-
-Now that we know both `Iterator` and `IntoIterator`, we can build `for` loops.
-They call `into_iter()` on an expression and iterates over the resulting
-iterator:
-
-```rust,editable
-fn main() {
-    let v: Vec<String> = vec![String::from("foo"), String::from("bar")];
-
-    for word in &v {
-        println!("word: {word}");
-    }
-
-    for word in v {
-        println!("word: {word}");
-    }
-}
-```
-
-What is the type of `word` in each loop?
-
-Experiment with the code above and then consult the documentation for [`impl
-IntoIterator for
-&Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-%26'a+Vec%3CT,+A%3E)
-and [`impl IntoIterator for
-Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-Vec%3CT,+A%3E)
-to check your answers.
diff --git a/src/exercises/day-2/morning.md b/src/exercises/day-2/morning.md
deleted file mode 100644
index e31cce6a..00000000
--- a/src/exercises/day-2/morning.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Day 2: Morning Exercises
-
-We will look at implementing methods in two contexts:
-
-* Storing books and querying the collection
-
-* Keeping track of health statistics for patients
-
-<details>
-
-After looking at the exercises, you can look at the [solutions] provided.
-
-[solutions]: solutions-morning.md
-
-</details>
diff --git a/src/exercises/day-2/solutions-afternoon.md b/src/exercises/day-2/solutions-afternoon.md
deleted file mode 100644
index c4e79655..00000000
--- a/src/exercises/day-2/solutions-afternoon.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Day 2 Afternoon Exercises
-
-## Strings and Iterators
-
-([back to exercise](strings-iterators.md))
-
-```rust
-{{#include strings-iterators.rs:solution}}
-```
diff --git a/src/exercises/day-2/solutions-morning.md b/src/exercises/day-2/solutions-morning.md
deleted file mode 100644
index d928b423..00000000
--- a/src/exercises/day-2/solutions-morning.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Day 2 Morning Exercises
-
-## Designing a Library
-
-([back to exercise](book-library.md))
-
-```rust
-{{#include book-library.rs:solution}}
-```
-
-## Health Statistics
-
-([back to exercise](health-statistics.md))
-
-```rust
-{{#include ../../../third_party/rust-on-exercism/health-statistics.rs:solution}}
-```
diff --git a/src/exercises/day-2/strings-iterators.md b/src/exercises/day-2/strings-iterators.md
deleted file mode 100644
index fd92acdf..00000000
--- a/src/exercises/day-2/strings-iterators.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Strings and Iterators
-
-In this exercise, you are implementing a routing component of a web server. The
-server is configured with a number of _path prefixes_ which are matched against
-_request paths_. The path prefixes can contain a wildcard character which
-matches a full segment. See the unit tests below.
-
-Copy the following code to <https://play.rust-lang.org/> and make the tests
-pass. Try avoiding allocating a `Vec` for your intermediate results:
-
-
-```rust
-// TODO: remove this when you're done with your implementation.
-#![allow(unused_variables, dead_code)]
-
-{{#include strings-iterators.rs:prefix_matches}}
-    unimplemented!()
-}
-
-{{#include strings-iterators.rs:unit-tests}}
-```
diff --git a/src/exercises/day-2/strings-iterators.rs b/src/exercises/day-2/strings-iterators.rs
deleted file mode 100644
index fda344b2..00000000
--- a/src/exercises/day-2/strings-iterators.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// ANCHOR: solution
-// ANCHOR: prefix_matches
-pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {
-    // ANCHOR_END: prefix_matches
-
-    let mut request_segments = request_path.split('/');
-
-    for prefix_segment in prefix.split('/') {
-        let Some(request_segment) = request_segments.next() else {
-            return false;
-        };
-        if request_segment != prefix_segment && prefix_segment != "*" {
-            return false;
-        }
-    }
-    true
-
-    // Alternatively, Iterator::zip() lets us iterate simultaneously over prefix
-    // and request segments. The zip() iterator is finished as soon as one of
-    // the source iterators is finished, but we need to iterate over all request
-    // segments. A neat trick that makes zip() work is to use map() and chain()
-    // to produce an iterator that returns Some(str) for each pattern segments,
-    // and then returns None indefinitely.
-}
-
-// ANCHOR: unit-tests
-#[test]
-fn test_matches_without_wildcard() {
-    assert!(prefix_matches("/v1/publishers", "/v1/publishers"));
-    assert!(prefix_matches("/v1/publishers", "/v1/publishers/abc-123"));
-    assert!(prefix_matches("/v1/publishers", "/v1/publishers/abc/books"));
-
-    assert!(!prefix_matches("/v1/publishers", "/v1"));
-    assert!(!prefix_matches("/v1/publishers", "/v1/publishersBooks"));
-    assert!(!prefix_matches("/v1/publishers", "/v1/parent/publishers"));
-}
-
-#[test]
-fn test_matches_with_wildcard() {
-    assert!(prefix_matches(
-        "/v1/publishers/*/books",
-        "/v1/publishers/foo/books"
-    ));
-    assert!(prefix_matches(
-        "/v1/publishers/*/books",
-        "/v1/publishers/bar/books"
-    ));
-    assert!(prefix_matches(
-        "/v1/publishers/*/books",
-        "/v1/publishers/foo/books/book1"
-    ));
-
-    assert!(!prefix_matches("/v1/publishers/*/books", "/v1/publishers"));
-    assert!(!prefix_matches(
-        "/v1/publishers/*/books",
-        "/v1/publishers/foo/booksByAuthor"
-    ));
-}
-// ANCHOR_END: unit-tests
-
-fn main() {}
diff --git a/src/exercises/day-3/afternoon.md b/src/exercises/day-3/afternoon.md
deleted file mode 100644
index 0cb40340..00000000
--- a/src/exercises/day-3/afternoon.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Day 3: Afternoon Exercises
-
-Let us build a safe wrapper for reading directory content!
-
-For this exercise, we suggest using a local dev environment instead
-of the Playground. This will allow you to run your binary on your own machine.
-
-To get started, follow the [running locally] instructions.
-
-[running locally]: ../../cargo/running-locally.md
-
-<details>
-
-After looking at the exercise, you can look at the [solution] provided.
-
-[solution]: solutions-afternoon.md
-
-</details>
diff --git a/src/exercises/day-3/morning.md b/src/exercises/day-3/morning.md
deleted file mode 100644
index 974ec153..00000000
--- a/src/exercises/day-3/morning.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Day 3: Morning Exercises
-
-We will design a classical GUI library using traits and trait objects.
-
-We will also look at enum dispatch with an exercise involving points and polygons.
-
-<details>
-
-After looking at the exercises, you can look at the [solutions] provided.
-
-[solutions]: solutions-morning.md
-
-</details>
diff --git a/src/exercises/day-3/points-polygons.md b/src/exercises/day-3/points-polygons.md
deleted file mode 100644
index 73bfe9e5..00000000
--- a/src/exercises/day-3/points-polygons.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# Polygon Struct
-
-We will create a `Polygon` struct which contain some points. Copy the code below
-to <https://play.rust-lang.org/> and fill in the missing methods to make the
-tests pass:
-
-```rust
-// TODO: remove this when you're done with your implementation.
-#![allow(unused_variables, dead_code)]
-
-{{#include points-polygons.rs:Point}}
-    // add fields
-}
-
-{{#include points-polygons.rs:Point-impl}}
-    // add methods
-}
-
-{{#include points-polygons.rs:Polygon}}
-    // add fields
-}
-
-{{#include points-polygons.rs:Polygon-impl}}
-    // add methods
-}
-
-{{#include points-polygons.rs:Circle}}
-    // add fields
-}
-
-{{#include points-polygons.rs:Circle-impl}}
-    // add methods
-}
-
-{{#include points-polygons.rs:Shape}}
-
-{{#include points-polygons.rs:unit-tests}}
-
-#[allow(dead_code)]
-fn main() {}
-```
-
-<details>
-
-Since the method signatures are missing from the problem statements, the key part
-of the exercise is to specify those correctly. You don't have to modify the tests.
-
-Other interesting parts of the exercise:
-    
-* Derive a `Copy` trait for some structs, as in tests the methods sometimes don't borrow their arguments.
-* Discover that `Add` trait must be implemented for two objects to be addable via "+". Note that we do not discuss generics until Day 3.
-
-</details>
diff --git a/src/exercises/day-3/points-polygons.rs b/src/exercises/day-3/points-polygons.rs
deleted file mode 100644
index 789408de..00000000
--- a/src/exercises/day-3/points-polygons.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// ANCHOR: solution
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-// ANCHOR: Point
-pub struct Point {
-    // ANCHOR_END: Point
-    x: i32,
-    y: i32,
-}
-
-// ANCHOR: Point-impl
-impl Point {
-    // ANCHOR_END: Point-impl
-    pub fn new(x: i32, y: i32) -> Point {
-        Point { x, y }
-    }
-
-    pub fn magnitude(self) -> f64 {
-        f64::from(self.x.pow(2) + self.y.pow(2)).sqrt()
-    }
-
-    pub fn dist(self, other: Point) -> f64 {
-        (self - other).magnitude()
-    }
-}
-
-impl std::ops::Add for Point {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self::Output {
-        Self {
-            x: self.x + other.x,
-            y: self.y + other.y,
-        }
-    }
-}
-
-impl std::ops::Sub for Point {
-    type Output = Self;
-
-    fn sub(self, other: Self) -> Self::Output {
-        Self {
-            x: self.x - other.x,
-            y: self.y - other.y,
-        }
-    }
-}
-
-// ANCHOR: Polygon
-pub struct Polygon {
-    // ANCHOR_END: Polygon
-    points: Vec<Point>,
-}
-
-// ANCHOR: Polygon-impl
-impl Polygon {
-    // ANCHOR_END: Polygon-impl
-    pub fn new() -> Polygon {
-        Polygon { points: Vec::new() }
-    }
-
-    pub fn add_point(&mut self, point: Point) {
-        self.points.push(point);
-    }
-
-    pub fn left_most_point(&self) -> Option<Point> {
-        self.points.iter().min_by_key(|p| p.x).copied()
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = &Point> {
-        self.points.iter()
-    }
-
-    pub fn length(&self) -> f64 {
-        if self.points.is_empty() {
-            return 0.0;
-        }
-
-        let mut result = 0.0;
-        let mut last_point = self.points[0];
-        for point in &self.points[1..] {
-            result += last_point.dist(*point);
-            last_point = *point;
-        }
-        result += last_point.dist(self.points[0]);
-        result
-        // Alternatively, Iterator::zip() lets us iterate over the points as pairs
-        // but we need to pair each point with the next one, and the last point
-        // with the first point. The zip() iterator is finished as soon as one of 
-        // the source iterators is finished, a neat trick is to combine Iterator::cycle
-        // with Iterator::skip to create the second iterator for the zip and using map 
-        // and sum to calculate the total length.
-    }
-}
-
-// ANCHOR: Circle
-pub struct Circle {
-    // ANCHOR_END: Circle
-    center: Point,
-    radius: i32,
-}
-
-// ANCHOR: Circle-impl
-impl Circle {
-    // ANCHOR_END: Circle-impl
-    pub fn new(center: Point, radius: i32) -> Circle {
-        Circle { center, radius }
-    }
-
-    pub fn circumference(&self) -> f64 {
-        2.0 * std::f64::consts::PI * f64::from(self.radius)
-    }
-
-    pub fn dist(&self, other: &Self) -> f64 {
-        self.center.dist(other.center)
-    }
-}
-
-// ANCHOR: Shape
-pub enum Shape {
-    Polygon(Polygon),
-    Circle(Circle),
-}
-// ANCHOR_END: Shape
-
-impl From<Polygon> for Shape {
-    fn from(poly: Polygon) -> Self {
-        Shape::Polygon(poly)
-    }
-}
-
-impl From<Circle> for Shape {
-    fn from(circle: Circle) -> Self {
-        Shape::Circle(circle)
-    }
-}
-
-impl Shape {
-    pub fn perimeter(&self) -> f64 {
-        match self {
-            Shape::Polygon(poly) => poly.length(),
-            Shape::Circle(circle) => circle.circumference(),
-        }
-    }
-}
-
-// ANCHOR: unit-tests
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn round_two_digits(x: f64) -> f64 {
-        (x * 100.0).round() / 100.0
-    }
-
-    #[test]
-    fn test_point_magnitude() {
-        let p1 = Point::new(12, 13);
-        assert_eq!(round_two_digits(p1.magnitude()), 17.69);
-    }
-
-    #[test]
-    fn test_point_dist() {
-        let p1 = Point::new(10, 10);
-        let p2 = Point::new(14, 13);
-        assert_eq!(round_two_digits(p1.dist(p2)), 5.00);
-    }
-
-    #[test]
-    fn test_point_add() {
-        let p1 = Point::new(16, 16);
-        let p2 = p1 + Point::new(-4, 3);
-        assert_eq!(p2, Point::new(12, 19));
-    }
-
-    #[test]
-    fn test_polygon_left_most_point() {
-        let p1 = Point::new(12, 13);
-        let p2 = Point::new(16, 16);
-
-        let mut poly = Polygon::new();
-        poly.add_point(p1);
-        poly.add_point(p2);
-        assert_eq!(poly.left_most_point(), Some(p1));
-    }
-
-    #[test]
-    fn test_polygon_iter() {
-        let p1 = Point::new(12, 13);
-        let p2 = Point::new(16, 16);
-
-        let mut poly = Polygon::new();
-        poly.add_point(p1);
-        poly.add_point(p2);
-
-        let points = poly.iter().cloned().collect::<Vec<_>>();
-        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);
-    }
-
-    #[test]
-    fn test_shape_perimeters() {
-        let mut poly = Polygon::new();
-        poly.add_point(Point::new(12, 13));
-        poly.add_point(Point::new(17, 11));
-        poly.add_point(Point::new(16, 16));
-        let shapes = vec![
-            Shape::from(poly),
-            Shape::from(Circle::new(Point::new(10, 20), 5)),
-        ];
-        let perimeters = shapes
-            .iter()
-            .map(Shape::perimeter)
-            .map(round_two_digits)
-            .collect::<Vec<_>>();
-        assert_eq!(perimeters, vec![15.48, 31.42]);
-    }
-}
-// ANCHOR_END: unit-tests
-
-fn main() {}
diff --git a/src/exercises/day-3/solutions-afternoon.md b/src/exercises/day-3/solutions-afternoon.md
deleted file mode 100644
index 7ded2ed5..00000000
--- a/src/exercises/day-3/solutions-afternoon.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Day 3 Afternoon Exercises
-
-## Safe FFI Wrapper
-
-([back to exercise](safe-ffi-wrapper.md))
-
-```rust
-{{#include safe-ffi-wrapper.rs:solution}}
-```
diff --git a/src/exercises/day-3/solutions-morning.md b/src/exercises/day-3/solutions-morning.md
deleted file mode 100644
index f233c4fe..00000000
--- a/src/exercises/day-3/solutions-morning.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Day 3 Morning Exercise
-
-## Drawing A Simple GUI
-
-([back to exercise](simple-gui.md))
-
-```rust
-{{#include simple-gui.rs:solution}}
-```
-
-## Points and Polygons
-
-([back to exercise](points-polygons.md))
-
-```rust
-{{#include points-polygons.rs:solution}}
-```
diff --git a/src/exercises/solutions.md b/src/exercises/solutions.md
deleted file mode 100644
index d4a35351..00000000
--- a/src/exercises/solutions.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Solutions
-
-You will find solutions to the exercises on the following pages.
-
-Feel free to ask questions about the solutions [on
-GitHub](https://github.com/google/comprehensive-rust/discussions). Let us know
-if you have a different or better solution than what is presented here.
diff --git a/src/generics.md b/src/generics.md
index ed787eb5..4235a380 100644
--- a/src/generics.md
+++ b/src/generics.md
@@ -1,5 +1,3 @@
 # Generics
 
-Rust support generics, which lets you abstract algorithms or data structures
-(such as sorting or a binary tree)
-over the types used or stored.
+{{%segment outline}}
diff --git a/src/generics/Cargo.toml b/src/generics/Cargo.toml
new file mode 100644
index 00000000..13d31e6d
--- /dev/null
+++ b/src/generics/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "generics"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "generics"
+path = "exercise.rs"
+
diff --git a/src/generics/data-types.md b/src/generics/data-types.md
deleted file mode 100644
index 4fa706a0..00000000
--- a/src/generics/data-types.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Generic Data Types
-
-You can use generics to abstract over the concrete field type:
-
-```rust,editable
-#[derive(Debug)]
-struct Point<T> {
-    x: T,
-    y: T,
-}
-
-fn main() {
-    let integer = Point { x: 5, y: 10 };
-    let float = Point { x: 1.0, y: 4.0 };
-    println!("{integer:?} and {float:?}");
-}
-```
-
-<details>
-
-* Try declaring a new variable `let p = Point { x: 5, y: 10.0 };`.
-
-* Fix the code to allow points that have elements of different types.
-
-</details>
\ No newline at end of file
diff --git a/src/generics/exercise.md b/src/generics/exercise.md
new file mode 100644
index 00000000..a2985eeb
--- /dev/null
+++ b/src/generics/exercise.md
@@ -0,0 +1,16 @@
+---
+minutes: 10
+---
+
+# Exercise: Generic `min`
+
+In this short exercise, you will implement a generic `min` function that
+determines the minimum of two values, using a `LessThan` trait.
+
+```rust,compile_fail
+{{#include exercise.rs:LessThan}}
+
+// TODO: implement the `min` function used in `main`.
+
+{{#include exercise.rs:main}}
+```
diff --git a/src/generics/exercise.rs b/src/generics/exercise.rs
new file mode 100644
index 00000000..b6db17a1
--- /dev/null
+++ b/src/generics/exercise.rs
@@ -0,0 +1,67 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+// ANCHOR: LessThan
+trait LessThan {
+    /// Return true if self is less than other.
+    fn less_than(&self, other: &Self) -> bool;
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+struct Citation {
+    author: &'static str,
+    year: u32,
+}
+
+impl LessThan for Citation {
+    fn less_than(&self, other: &Self) -> bool {
+        if self.author < other.author {
+            true
+        } else if self.author > other.author {
+            false
+        } else {
+            self.year < other.year
+        }
+    }
+}
+// ANCHOR_END: LessThan
+
+fn min<T: LessThan>(l: T, r: T) -> T {
+    if l.less_than(&r) {
+        l
+    } else {
+        r
+    }
+}
+
+// ANCHOR: main
+fn main() {
+    let cit1 = Citation {
+        author: "Shapiro",
+        year: 2011,
+    };
+    let cit2 = Citation {
+        author: "Baumann",
+        year: 2010,
+    };
+    let cit3 = Citation {
+        author: "Baumann",
+        year: 2019,
+    };
+    debug_assert_eq!(min(cit1, cit2), cit2);
+    debug_assert_eq!(min(cit2, cit3), cit2);
+    debug_assert_eq!(min(cit1, cit3), cit3);
+}
+// ANCHOR_END: main
diff --git a/src/generics/generic-data.md b/src/generics/generic-data.md
new file mode 100644
index 00000000..7ecb1e27
--- /dev/null
+++ b/src/generics/generic-data.md
@@ -0,0 +1,43 @@
+---
+minutes: 15
+---
+
+# Generic Data Types
+
+You can use generics to abstract over the concrete field type:
+
+```rust,editable
+#[derive(Debug)]
+struct Point<T> {
+    x: T,
+    y: T,
+}
+
+impl<T> Point<T> {
+    fn coords(&self) -> (&T, &T) {
+        (&self.x, &self.y)
+    }
+
+    // fn set_x(&mut self, x: T)
+}
+
+fn main() {
+    let integer = Point { x: 5, y: 10 };
+    let float = Point { x: 1.0, y: 4.0 };
+    println!("{integer:?} and {float:?}");
+    println!("coords: {:?}", integer.coords());
+}
+```
+
+<details>
+
+* *Q:* Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that redundant?
+    * This is because it is a generic implementation section for generic type. They are independently generic.
+    * It means these methods are defined for any `T`.
+    * It is possible to write `impl Point<u32> { .. }`.
+      * `Point` is still generic and you can use `Point<f64>`, but methods in this block will only be available for `Point<u32>`.
+
+* Try declaring a new variable `let p = Point { x: 5, y: 10.0 };`.
+  Update the code to allow points that have elements of different types, by using two type variables, e.g., `T` and `U`.
+
+</details>
diff --git a/src/generics/generic-functions.md b/src/generics/generic-functions.md
new file mode 100644
index 00000000..1979e764
--- /dev/null
+++ b/src/generics/generic-functions.md
@@ -0,0 +1,41 @@
+---
+minutes: 5
+---
+
+# Generic Functions
+
+Rust supports generics, which lets you abstract algorithms or data structures
+(such as sorting or a binary tree)
+over the types used or stored.
+
+```rust,editable
+/// Pick `even` or `odd` depending on the value of `n`.
+fn pick<T>(n: i32, even: T, odd: T) -> T {
+    if n % 2 == 0 {
+        even
+    } else {
+        odd
+    }
+}
+
+fn main() {
+    println!("picked a number: {:?}", pick(97, 222, 333));
+    println!("picked a tuple: {:?}", pick(28, ("dog", 1), ("cat", 2)));
+}
+```
+
+<details>
+
+* Rust infers a type for T based on the types of the arguments and return value.
+
+* This is similar to C++ templates, but Rust partially compiles the generic
+  function immediately, so that function must be valid for all types matching
+  the constraints. For example, try modifying `pick` to return `even + odd` if
+  `n == 0`. Even if only the `pick` instantiation with integers is used, Rust
+  still considers it invalid. C++ would let you do this.
+
+* Generic code is turned into non-generic code based on the call sites.
+  This is a zero-cost abstraction: you get exactly the same result as if you had
+  hand-coded the data structures without the abstraction.
+
+</details>
diff --git a/src/traits/impl-trait.md b/src/generics/impl-trait.md
similarity index 57%
rename from src/traits/impl-trait.md
rename to src/generics/impl-trait.md
index c48348dc..b3d855dc 100644
--- a/src/traits/impl-trait.md
+++ b/src/generics/impl-trait.md
@@ -1,25 +1,36 @@
+---
+minutes: 5
+---
+
 # `impl Trait`
 
 Similar to trait bounds, an `impl Trait` syntax can be used in function
 arguments and return values:
 
 ```rust,editable
-use std::fmt::Display;
+// Syntactic sugar for:
+//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {
+fn add_42_millions(x: impl Into<i32>) -> i32 {
+    x.into() + 42_000_000
+}
 
-fn get_x(name: impl Display) -> impl Display {
-    format!("Hello {name}")
+fn pair_of(x: u32) -> impl std::fmt::Debug {
+    (x + 1, x - 1)
 }
 
 fn main() {
-    let x = get_x("foo");
-    println!("{x}");
+    let many = add_42_millions(42_i8);
+    println!("{many}");
+    let many_more = add_42_millions(10_000_000);
+    println!("{many_more}");
+    let debuggable = pair_of(27);
+    println!("debuggable: {debuggable:?}");
 }
 ```
 
-* `impl Trait` allows you to work with types which you cannot name.
-
 <details>
 
+`impl Trait` allows you to work with types which you cannot name.
 The meaning of `impl Trait` is a bit different in the different positions.
 
 * For a parameter, `impl Trait` is like an anonymous generic parameter with a trait bound.
@@ -34,11 +45,7 @@ The meaning of `impl Trait` is a bit different in the different positions.
   satisfying `B`, and the caller may need to choose one, such as with `let x:
   Vec<_> = foo.collect()` or with the turbofish, `foo.collect::<Vec<_>>()`.
 
-This example is great, because it uses `impl Display` twice. It helps to explain that
-nothing here enforces that it is _the same_ `impl Display` type. If we used a single 
-`T: Display`, it would enforce the constraint that input `T` and return `T` type are the same type.
-It would not work for this particular function, as the type we expect as input is likely not
-what `format!` returns. If we wanted to do the same via `: Display` syntax, we'd need two
-independent generic parameters.
+What is the type of `debuggable`? Try `let debuggable: () = ..` to see what the
+error message shows.
 
 </details>
diff --git a/src/generics/methods.md b/src/generics/methods.md
deleted file mode 100644
index 66bc4058..00000000
--- a/src/generics/methods.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Generic Methods
-
-You can declare a generic type on your `impl` block:
-
-```rust,editable
-#[derive(Debug)]
-struct Point<T>(T, T);
-
-impl<T> Point<T> {
-    fn x(&self) -> &T {
-        &self.0  // + 10
-    }
-
-    // fn set_x(&mut self, x: T)
-}
-
-fn main() {
-    let p = Point(5, 10);
-    println!("p.x = {}", p.x());
-}
-```
-
-<details>
-
-* *Q:* Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that redundant?
-    * This is because it is a generic implementation section for generic type. They are independently generic.
-    * It means these methods are defined for any `T`.
-    * It is possible to write `impl Point<u32> { .. }`. 
-      * `Point` is still generic and you can use `Point<f64>`, but methods in this block will only be available for `Point<u32>`.
-
-</details>
diff --git a/src/generics/monomorphization.md b/src/generics/monomorphization.md
deleted file mode 100644
index 28d106c4..00000000
--- a/src/generics/monomorphization.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# Monomorphization
-
-Generic code is turned into non-generic code based on the call sites:
-
-```rust,editable
-fn main() {
-    let integer = Some(5);
-    let float = Some(5.0);
-}
-```
-
-behaves as if you wrote
-
-```rust,editable
-enum Option_i32 {
-    Some(i32),
-    None,
-}
-
-enum Option_f64 {
-    Some(f64),
-    None,
-}
-
-fn main() {
-    let integer = Option_i32::Some(5);
-    let float = Option_f64::Some(5.0);
-}
-```
-
-This is a zero-cost abstraction: you get exactly the same result as if you had
-hand-coded the data structures without the abstraction.
diff --git a/src/generics/solution.md b/src/generics/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/generics/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/generics/trait-bounds.md b/src/generics/trait-bounds.md
new file mode 100644
index 00000000..33fd8357
--- /dev/null
+++ b/src/generics/trait-bounds.md
@@ -0,0 +1,50 @@
+---
+minutes: 10
+---
+
+# Trait Bounds
+
+When working with generics, you often want to require the types to implement
+some trait, so that you can call this trait's methods.
+
+You can do this with `T: Trait` or `impl Trait`:
+
+```rust,editable
+fn duplicate<T: Clone>(a: T) -> (T, T) {
+    (a.clone(), a.clone())
+}
+
+// struct NotClonable;
+
+fn main() {
+    let foo = String::from("foo");
+    let pair = duplicate(foo);
+    println!("{pair:?}");
+}
+```
+
+<details>
+
+* Try making a `NonClonable` and passing it to `duplicate`.
+
+* When multiple traits are necessary, use `+` to join them.
+
+* Show a `where` clause, students will encounter it when reading code.
+
+  ```rust,ignore
+  fn duplicate<T>(a: T) -> (T, T)
+  where
+      T: Clone,
+  {
+      (a.clone(), a.clone())
+  }
+    ```
+
+  * It declutters the function signature if you have many parameters.
+  * It has additional features making it more powerful.
+      * If someone asks, the extra feature is that the type on the left of ":" can be arbitrary, like `Option<T>`.
+
+* Note that Rust does not (yet) support specialization. For example, given the
+  original `duplicate`, it is invalid to add a specialized `duplicate(a: u32)`.
+
+</details>
diff --git a/src/hello-world.md b/src/hello-world.md
index b0ade14f..0af4e369 100644
--- a/src/hello-world.md
+++ b/src/hello-world.md
@@ -1,43 +1,3 @@
-# Hello World!
+# Hello, World
 
-Let us jump into the simplest possible Rust program, a classic Hello World
-program:
-
-```rust,editable
-fn main() {
-    println!("Hello 🌍!");
-}
-```
-
-What you see:
-
-* Functions are introduced with `fn`.
-* Blocks are delimited by curly braces like in C and C++.
-* The `main` function is the entry point of the program.
-* Rust has hygienic macros, `println!` is an example of this.
-* Rust strings are UTF-8 encoded and can contain any Unicode character.
-
-<details>
-
-This slide tries to make the students comfortable with Rust code. They will see
-a ton of it over the next three days so we start small with something familiar.
-
-Key points:
-
-* Rust is very much like other languages in the C/C++/Java tradition. It is
-  imperative and it doesn't try to reinvent things unless
-  absolutely necessary.
-
-* Rust is modern with full support for things like Unicode.
-
-* Rust uses macros for situations where you want to have a variable number of
-  arguments (no function [overloading](basic-syntax/functions-interlude.md)).
-
-* Macros being 'hygienic' means they don't accidentally capture identifiers from
-  the scope they are used in. Rust macros are actually only
-  [partially hygienic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html).
-
-* Rust is multi-paradigm. For example, it has powerful [object-oriented programming features](https://doc.rust-lang.org/book/ch17-00-oop.html),
-  and, while it is not a functional language, it includes a range of [functional concepts](https://doc.rust-lang.org/book/ch13-00-functional-features.html).
-
-</details>
+{{%segment outline}}
diff --git a/src/hello-world/benefits.md b/src/hello-world/benefits.md
new file mode 100644
index 00000000..8220d092
--- /dev/null
+++ b/src/hello-world/benefits.md
@@ -0,0 +1,52 @@
+---
+minutes: 3
+---
+
+# Benefits of Rust
+
+Some unique selling points of Rust:
+
+- _Compile time memory safety_ - whole classes of memory bugs are prevented at compile time
+  - No uninitialized variables.
+  - No double-frees.
+  - No use-after-free.
+  - No `NULL` pointers.
+  - No forgotten locked mutexes.
+  - No data races between threads.
+  - No iterator invalidation.
+
+- _No undefined runtime behavior_ - what a Rust statement does is never left
+  unspecified
+  - Array access is bounds checked.
+  - Integer overflow is defined (panic or wrap-around).
+
+- _Modern language features_ - as expressive and ergonomic as higher-level
+  languages
+  - Enums and pattern matching.
+  - Generics.
+  - No overhead FFI.
+  - Zero-cost abstractions.
+  - Great compiler errors.
+  - Built-in dependency manager.
+  - Built-in support for testing.
+  - Excellent Language Server Protocol support.
+
+<details>
+
+Do not spend much time here. All of these points will be covered in more depth
+later.
+
+Make sure to ask the class which languages they have experience with. Depending
+on the answer you can highlight different features of Rust:
+
+* Experience with C or C++: Rust eliminates a whole class of _runtime errors_
+  via the borrow checker. You get performance like in C and C++, but you don't
+  have the memory unsafety issues. In addition, you get a modern language with
+  constructs like pattern matching and built-in dependency management.
+
+* Experience with Java, Go, Python, JavaScript...: You get the same memory safety
+  as in those languages, plus a similar high-level language feeling. In addition
+  you get fast and predictable performance like C and C++ (no garbage collector)
+  as well as access to low-level hardware (should you need it)
+
+</details>
diff --git a/src/hello-world/hello-world.md b/src/hello-world/hello-world.md
new file mode 100644
index 00000000..1b0a3682
--- /dev/null
+++ b/src/hello-world/hello-world.md
@@ -0,0 +1,47 @@
+---
+minutes: 5
+---
+
+# Hello, World
+
+Let us jump into the simplest possible Rust program, a classic Hello World
+program:
+
+```rust,editable
+fn main() {
+    println!("Hello 🌍!");
+}
+```
+
+What you see:
+
+* Functions are introduced with `fn`.
+* Blocks are delimited by curly braces like in C and C++.
+* The `main` function is the entry point of the program.
+* Rust has hygienic macros, `println!` is an example of this.
+* Rust strings are UTF-8 encoded and can contain any Unicode character.
+
+<details>
+
+This slide tries to make the students comfortable with Rust code. They will see
+a ton of it over the next three days so we start small with something familiar.
+
+Key points:
+
+* Rust is very much like other languages in the C/C++/Java tradition. It is
+  imperative and it doesn't try to reinvent things unless
+  absolutely necessary.
+
+* Rust is modern with full support for things like Unicode.
+
+* Rust uses macros for situations where you want to have a variable number of
+  arguments (no function [overloading](basic-syntax/functions-interlude.md)).
+
+* Macros being 'hygienic' means they don't accidentally capture identifiers from
+  the scope they are used in. Rust macros are actually only
+  [partially hygienic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html).
+
+* Rust is multi-paradigm. For example, it has powerful [object-oriented programming features](https://doc.rust-lang.org/book/ch17-00-oop.html),
+  and, while it is not a functional language, it includes a range of [functional concepts](https://doc.rust-lang.org/book/ch13-00-functional-features.html).
+
+</details>
diff --git a/src/hello-world/playground.md b/src/hello-world/playground.md
new file mode 100644
index 00000000..92d5375a
--- /dev/null
+++ b/src/hello-world/playground.md
@@ -0,0 +1,29 @@
+---
+minutes: 2
+---
+
+# Playground
+
+The [Rust Playground](https://play.rust-lang.org/) provides an easy way to run
+short Rust programs, and is the basis for the examples and exercises in this
+course.  Try running the "hello-world" program it starts with. It comes with a
+few handy features:
+
+- Under "Tools", use the `rustfmt` option to format your code in the "standard"
+  way.
+
+- Rust has two main "profiles" for generating code: Debug (extra runtime
+  checks, less optimization) and Release (fewer runtime checks, lots of
+  optimization). These are accessible under "Debug" at the top.
+
+- If you're interested, use "ASM" under "..." to see the generated assembly
+  code.
+
+<details>
+
+As students head into the break, encourage them to open up the playground and
+experiment a little. Encourage them to keep the tab open and try things out
+during the rest of the course. This is particularly helpful for advanced
+students who want to know more about Rust's optimzations or generated assembly.
+
+</details>
diff --git a/src/hello-world/small-example.md b/src/hello-world/small-example.md
deleted file mode 100644
index c4322767..00000000
--- a/src/hello-world/small-example.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Small Example
-
-Here is a small example program in Rust:
-
-```rust,editable
-fn main() {              // Program entry point
-    let mut x: i32 = 6;  // Mutable variable binding
-    print!("{x}");       // Macro for printing, like printf
-    while x != 1 {       // No parenthesis around expression
-        if x % 2 == 0 {  // Math like in other languages
-            x = x / 2;
-        } else {
-            x = 3 * x + 1;
-        }
-        print!(" -> {x}");
-    }
-    println!();
-}
-```
-
-<details>
-
-The code implements the Collatz conjecture: it is believed that the loop will
-always end, but this is not yet proved. Edit the code and play with different
-inputs.
-
-Key points:
-
-* Explain that all variables are statically typed. Try removing `i32` to trigger
-  type inference. Try with `i8` instead and trigger a runtime integer overflow.
-
-* Change `let mut x` to `let x`, discuss the compiler error.
-
-* Show how `print!` gives a compilation error if the arguments don't match the
-  format string.
-
-* Show how you need to use `{}` as a placeholder if you want to print an
-  expression which is more complex than just a single variable.
-
-* Show the students the standard library, show them how to search for `std::fmt`
-  which has the rules of the formatting mini-language. It's important that the
-  students become familiar with searching in the standard library.
-    
-    * In a shell `rustup doc std::fmt` will open a browser on the local std::fmt documentation
-
-</details>
diff --git a/src/welcome-day-1/what-is-rust.md b/src/hello-world/what-is-rust.md
similarity index 97%
rename from src/welcome-day-1/what-is-rust.md
rename to src/hello-world/what-is-rust.md
index 3e821720..e6d3e45a 100644
--- a/src/welcome-day-1/what-is-rust.md
+++ b/src/hello-world/what-is-rust.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # What is Rust?
 
 Rust is a new programming language which had its [1.0 release in 2015][1]:
diff --git a/src/index.md b/src/index.md
index eeca9325..bcff48cb 100644
--- a/src/index.md
+++ b/src/index.md
@@ -19,7 +19,7 @@ about Rust and hope to:
 * Enable you to modify existing programs and write new programs in Rust.
 * Show you common Rust idioms.
 
-We call the first three course days Rust Fundamentals.
+We call the first four course days Rust Fundamentals.
 
 Building on this, you're invited to dive into one or more specialized topics:
 
diff --git a/src/iterators.md b/src/iterators.md
new file mode 100644
index 00000000..ed3b3828
--- /dev/null
+++ b/src/iterators.md
@@ -0,0 +1,3 @@
+# Iterators
+
+{{%segment outline}}
diff --git a/src/iterators/Cargo.toml b/src/iterators/Cargo.toml
new file mode 100644
index 00000000..c1bd9371
--- /dev/null
+++ b/src/iterators/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "iterators"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "offset-differences"
+path = "exercise.rs"
diff --git a/src/iterators/exercise.md b/src/iterators/exercise.md
new file mode 100644
index 00000000..4881c8a9
--- /dev/null
+++ b/src/iterators/exercise.md
@@ -0,0 +1,22 @@
+---
+minutes: 30
+---
+
+# Exercise: Iterator Method Chaining
+
+In this exercise, you will need to find and use some of the provided methods in
+the [`Iterator`][1] trait to implement a complex calculation.
+
+Copy the following code to <https://play.rust-lang.org/> and make the tests
+pass. Use an iterator expression and `collect` the result to construct the
+return value.
+
+
+```rust
+{{#include exercise.rs:offset_differences}}
+    unimplemented!()
+}
+
+{{#include exercise.rs:unit-tests}}
+```
+[1]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
diff --git a/src/iterators/exercise.rs b/src/iterators/exercise.rs
new file mode 100644
index 00000000..66c19b6d
--- /dev/null
+++ b/src/iterators/exercise.rs
@@ -0,0 +1,66 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![allow(dead_code)]
+
+// ANCHOR: solution
+// ANCHOR: offset_differences
+/// Calculate the differences between elements of `values` offset by `offset`, wrapping
+/// around from the end of `values` to the beginning.
+///
+/// Element `n` of the result is `values[(n+offset)%len] - values[n]`.
+fn offset_differences<N>(offset: usize, values: Vec<N>) -> Vec<N>
+where
+    N: Copy + std::ops::Sub<Output = N>,
+{
+    // ANCHOR_END: offset_differences
+    let a = (&values).into_iter();
+    let b = (&values).into_iter().cycle().skip(offset);
+    a.zip(b).map(|(a, b)| *b - *a).take(values.len()).collect()
+}
+
+// ANCHOR: unit-tests
+#[test]
+fn test_offset_one() {
+    assert_eq!(offset_differences(1, vec![1, 3, 5, 7]), vec![2, 2, 2, -6]);
+    assert_eq!(offset_differences(1, vec![1, 3, 5]), vec![2, 2, -4]);
+    assert_eq!(offset_differences(1, vec![1, 3]), vec![2, -2]);
+}
+
+#[test]
+fn test_larger_offsets() {
+    assert_eq!(offset_differences(2, vec![1, 3, 5, 7]), vec![4, 4, -4, -4]);
+    assert_eq!(offset_differences(3, vec![1, 3, 5, 7]), vec![6, -2, -2, -2]);
+    assert_eq!(offset_differences(4, vec![1, 3, 5, 7]), vec![0, 0, 0, 0]);
+    assert_eq!(offset_differences(5, vec![1, 3, 5, 7]), vec![2, 2, 2, -6]);
+}
+
+#[test]
+fn test_custom_type() {
+    assert_eq!(
+        offset_differences(1, vec![1.0, 11.0, 5.0, 0.0]),
+        vec![10.0, -6.0, -5.0, 1.0]
+    );
+}
+
+#[test]
+fn test_degenerate_cases() {
+    assert_eq!(offset_differences(1, vec![0]), vec![0]);
+    assert_eq!(offset_differences(1, vec![1]), vec![0]);
+    let empty: Vec<i32> = vec![];
+    assert_eq!(offset_differences(1, empty), vec![]);
+}
+// ANCHOR_END: unit-tests
+
+fn main() {}
diff --git a/src/iterators/fromiterator.md b/src/iterators/fromiterator.md
new file mode 100644
index 00000000..e50984eb
--- /dev/null
+++ b/src/iterators/fromiterator.md
@@ -0,0 +1,46 @@
+---
+minutes: 5
+---
+
+# FromIterator
+
+[`FromIterator`][1] lets you build a collection from an [`Iterator`][2].
+
+```rust,editable
+fn main() {
+    let primes = vec![2, 3, 5, 7];
+    let prime_squares = primes
+        .into_iter()
+        .map(|prime| prime * prime)
+        .collect::<Vec<_>>();
+    println!("prime_squares: {prime_squares:?}");
+}
+```
+
+<details>
+
+`Iterator` implements
+
+```rust,ignore
+fn collect<B>(self) -> B
+where
+    B: FromIterator<Self::Item>,
+    Self: Sized
+```
+
+There are two ways to specify `B` for this method:
+
+ * With the "turbofish": `some_iterator.collect::<COLLECTION_TYPE>()`, as
+   shown. The `_` shorthand used here lets Rust infer the type of the `Vec`
+   elements. 
+ * With type inference: `let prime_squares: Vec<_> =
+   some_iterator.collect()`. Rewrite the example to use this form.
+
+There are basic implementations of `FromIterator` for `Vec`, `HashMap`, etc.
+There are also more specialized implementations which let you do cool things
+like convert an `Iterator<Item = Result<V, E>>` into a `Result<Vec<V>, E>`.
+
+</details>
+
+[1]: https://doc.rust-lang.org/std/iter/trait.FromIterator.html
+[2]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
diff --git a/src/iterators/intoiterator.md b/src/iterators/intoiterator.md
new file mode 100644
index 00000000..c96a084c
--- /dev/null
+++ b/src/iterators/intoiterator.md
@@ -0,0 +1,84 @@
+---
+minutes: 5
+---
+
+# `IntoIterator`
+
+The `Iterator` trait tells you how to _iterate_ once you have created an
+iterator. The related trait
+[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)
+defines how to create an iterator for a type. It is used automatically by the
+`for` loop.
+
+```rust,editable
+struct Grid {
+    x_coords: Vec<u32>,
+    y_coords: Vec<u32>,
+}
+
+impl IntoIterator for Grid {
+    type Item = (u32, u32);
+    type IntoIter = GridIter;
+    fn into_iter(self) -> GridIter {
+        GridIter { grid: self, i: 0, j: 0 }
+    }
+}
+
+struct GridIter {
+    grid: Grid,
+    i: usize,
+    j: usize,
+}
+
+impl Iterator for GridIter {
+    type Item = (u32, u32);
+
+    fn next(&mut self) -> Option<(u32, u32)> {
+        self.i += 1;
+        if self.i >= self.grid.x_coords.len() {
+            self.i = 0;
+            self.j += 1;
+            if self.j >= self.grid.y_coords.len() {
+                return None;
+            }
+        }
+        Some((self.grid.x_coords[self.i], self.grid.y_coords[self.j]))
+    }
+}
+
+fn main() {
+    let grid = Grid {
+        x_coords: vec![3, 5, 7, 9],
+        y_coords: vec![10, 20, 30, 40],
+    };
+    for (x, y) in grid {
+        println!("point = {x}, {y}");
+    }
+}
+```
+
+<details>
+
+Click through to the docs for `IntoIterator`. Every implementation of
+`IntoIterator` must declare two types:
+
+* `Item`: the type to iterate over, such as `i8`,
+* `IntoIter`: the `Iterator` type returned by the `into_iter` method.
+
+Note that `IntoIter` and `Item` are linked: the iterator must have the same
+`Item` type, which means that it returns `Option<Item>`
+
+The example iterates over all combinations of x and y coordinates.
+
+Try iterating over the grid twice in `main`. Why does this fail? Note that
+`IntoIterator::into_iter` takes ownership of `self`.
+
+Fix this issue by implementing `IntoIterator` for `&Grid` and storing a
+reference to the `Grid` in `GridIter`.
+
+The same problem can occur for standard library types: `for e in some_vector`
+will take ownership of `some_vector` and iterate over owned elements from that
+vector. Use `for e in &some_vector` instead, to iterate over references to
+elements of `some_vector`.
+
+</details>
diff --git a/src/traits/iterator.md b/src/iterators/iterators.md
similarity index 77%
rename from src/traits/iterator.md
rename to src/iterators/iterators.md
index b730c354..aa018681 100644
--- a/src/traits/iterator.md
+++ b/src/iterators/iterators.md
@@ -1,6 +1,15 @@
+---
+minutes: 5
+---
+
+<!-- NOTES:
+The Iterator trait and basic usage
+-->
 # Iterators
 
-You can implement the [`Iterator`][1] trait on your own types:
+The [`Iterator`][1] trait supports iterating over values in a collection. It
+requires a `next` method and provides lots of methods. Many standard library types
+implement `Iterator`, and you can implement it yourself, too:
 
 ```rust,editable
 struct Fibonacci {
@@ -29,11 +38,11 @@ fn main() {
 
 <details>
 
-* The `Iterator` trait implements many common functional programming operations over collections 
+* The `Iterator` trait implements many common functional programming operations over collections
   (e.g. `map`, `filter`, `reduce`, etc). This is the trait where you can find all the documentation
   about them. In Rust these functions should produce the code as efficient as equivalent imperative
   implementations.
-    
+
 * `IntoIterator` is the trait that makes for loops work. It is implemented by collection types such as
   `Vec<T>` and references to them such as `&Vec<T>` and `&[T]`. Ranges also implement it. This is why
   you can iterate over a vector with `for i in some_vec { .. }` but
diff --git a/src/iterators/solution.md b/src/iterators/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/iterators/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/memory-management.md b/src/memory-management.md
index a1a8e999..e6130d09 100644
--- a/src/memory-management.md
+++ b/src/memory-management.md
@@ -1,15 +1,3 @@
 # Memory Management
 
-Traditionally, languages have fallen into two broad categories:
-
-* Full control via manual memory management: C, C++, Pascal, ...
-* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ...
-
-Rust offers a new mix:
-
-> Full control *and* safety via compile time enforcement of correct memory
-> management.
-
-It does this with an explicit ownership concept.
-
-First, let's refresh how memory management works.
+{{%segment outline}}
diff --git a/src/memory-management/Cargo.toml b/src/memory-management/Cargo.toml
new file mode 100644
index 00000000..d3d6e0c8
--- /dev/null
+++ b/src/memory-management/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "memory-management"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "package-builder"
+path = "exercise.rs"
diff --git a/src/memory-management/approaches.md b/src/memory-management/approaches.md
new file mode 100644
index 00000000..c4cf06c6
--- /dev/null
+++ b/src/memory-management/approaches.md
@@ -0,0 +1,51 @@
+---
+minutes: 10
+---
+
+# Approaches to Memory Management
+
+Traditionally, languages have fallen into two broad categories:
+
+* Full control via manual memory management: C, C++, Pascal, ...
+  * Programmer decides when to allocate or free heap memory.
+  * Programmer must determine whether a pointer still points to valid memory.
+  * Studies show, programmers make mistakes.
+* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ...
+  * A runtime system ensures that memory is not freed until it can no longer be referenced.
+  * Typically implemented with reference counting, garbage collection, or RAII.
+
+Rust offers a new mix:
+
+> Full control *and* safety via compile time enforcement of correct memory
+> management.
+
+It does this with an explicit ownership concept.
+
+<details>
+
+This slide is intended to help students coming from other languages to put Rust
+in context.
+
+* C must manage heap manually with `malloc` and `free`. Common
+  errors include forgetting to call `free`, calling it multiple times for the
+  same pointer, or dereferencing a pointer after the memory it points to has
+  been freed.
+
+* C++ has tools like smart pointers (`unique_ptr`, `shared_ptr`)
+  that take advantage of language guarantees about calling destructors to
+  ensure memory is freed when a function returns. It is still quite easy to
+  mis-use these tools and create similar bugs to C.
+
+* Java, Go, and Python rely on the garbage collector to identify memory that
+  is no longer reachable and discard it. This guarantees that any pointer can
+  be dereferenced, eliminating use-after-free and other classes of bugs. But,
+  GC has a runtime cost and is difficult to tune properly.
+
+Rust's ownership and borrowing model can, in many cases, get the performance of
+C, with alloc and free operations precisely where they are required -- zero
+cost. It also provides tools similar to C++'s smart pointers. When required,
+other options such as reference counting are available, and there are even
+third-party crates available to support runtime garbage collection (not covered
+in this class).
+
+</details>
diff --git a/src/memory-management/clone.md b/src/memory-management/clone.md
new file mode 100644
index 00000000..f2fbb6ac
--- /dev/null
+++ b/src/memory-management/clone.md
@@ -0,0 +1,32 @@
+---
+minutes: 2
+---
+
+# Clone
+
+Sometimes you _want_ to make a copy of a value. The `Clone` trait accomplishes this.
+
+```rust,editable
+#[derive(Default)]
+struct Backends {
+    hostnames: Vec<String>,
+    weights: Vec<f64>,
+}
+
+impl Backends {
+    fn set_hostnames(&mut self, hostnames: &Vec<String>) {
+        self.hostnames = hostnames.clone();
+        self.weights = hostnames.iter().map(|_| 1.0).collect();
+    }
+}
+```
+
+<details>
+
+The idea of `Clone` is to make it easy to spot where heap allocations are
+occurring. Look for `.clone()` and a few others like `Vec::new` or `Box::new`.
+
+It's common to "clone your way out" of problems with the borrow checker, and
+return later to try to optimize those clones away.
+
+</details>
diff --git a/src/ownership/copy-clone.md b/src/memory-management/copy-types.md
similarity index 82%
rename from src/ownership/copy-clone.md
rename to src/memory-management/copy-types.md
index 4a8ccb54..ec119cfb 100644
--- a/src/ownership/copy-clone.md
+++ b/src/memory-management/copy-types.md
@@ -1,4 +1,11 @@
-# Copying and Cloning
+---
+minutes: 5
+---
+
+<!-- NOTES:
+Present Copy as added functionality on top of the default move semantics: with Copy, the old value does not become invalid; Can derive Copy for a type if it implements Clone
+-->
+# Copy Types
 
 While move semantics are the default, certain types are copied by default:
 
@@ -7,7 +14,7 @@ While move semantics are the default, certain types are copied by default:
 fn main() {
     let x = 42;
     let y = x;
-    println!("x: {x}");
+    println!("x: {x}"); // would not be accessible if not Copy
     println!("y: {y}");
 }
 ```
@@ -47,7 +54,4 @@ In the above example, try the following:
 * Remove `Copy` from the `derive` attribute. The compiler error is now in the `println!` for  `p1`.
 * Show that it works if you clone `p1` instead.
 
-If students ask about `derive`, it is sufficient to say that this is a way to generate code in Rust
-at compile time. In this case the default implementations of `Copy` and `Clone` traits are generated.
-    
 </details>
diff --git a/src/traits/drop.md b/src/memory-management/drop.md
similarity index 98%
rename from src/traits/drop.md
rename to src/memory-management/drop.md
index 7e1e4617..986fdddc 100644
--- a/src/traits/drop.md
+++ b/src/memory-management/drop.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # The `Drop` Trait
 
 Values which implement [`Drop`][1] can specify code to run when they go out of scope:
diff --git a/src/memory-management/exercise.md b/src/memory-management/exercise.md
new file mode 100644
index 00000000..1f130b74
--- /dev/null
+++ b/src/memory-management/exercise.md
@@ -0,0 +1,42 @@
+---
+minutes: 20
+---
+
+# Exercise: Builder Type
+
+In this example, we will implement a complex data type that owns all of its
+data. We will use the "builder pattern" to support building a new value
+piece-by-piece, using convenience functions.
+
+Fill in the missing pieces.
+
+```rust,should_panic,editable
+{{#include exercise.rs:Package}}
+{{#include exercise.rs:as_dependency}}
+        todo!("1")
+    }
+}
+
+{{#include exercise.rs:PackageBuilder}}
+{{#include exercise.rs:new}}
+        todo!("2")
+    }
+
+{{#include exercise.rs:version}}
+
+{{#include exercise.rs:authors}}
+        todo!("3")
+    }
+
+{{#include exercise.rs:dependency}}
+        todo!("4")
+    }
+
+{{#include exercise.rs:language}}
+        todo!("5")
+    }
+
+{{#include exercise.rs:build}}
+
+{{#include exercise.rs:main}}
+```
diff --git a/src/memory-management/exercise.rs b/src/memory-management/exercise.rs
new file mode 100644
index 00000000..60b3f674
--- /dev/null
+++ b/src/memory-management/exercise.rs
@@ -0,0 +1,128 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![allow(dead_code)]
+
+// ANCHOR: solution
+// ANCHOR: Package
+#[derive(Debug)]
+enum Language {
+    Rust,
+    Java,
+    Perl,
+}
+
+#[derive(Clone, Debug)]
+struct Dependency {
+    name: String,
+    version_expression: String,
+}
+
+/// A representation of a software package.
+#[derive(Debug)]
+struct Package {
+    name: String,
+    version: String,
+    authors: Vec<String>,
+    dependencies: Vec<Dependency>,
+    language: Option<Language>,
+}
+
+impl Package {
+    // ANCHOR_END: Package
+    // ANCHOR: as_dependency
+    fn as_dependency(&self) -> Dependency {
+        // ANCHOR_END: as_dependency
+        Dependency {
+            name: self.name.clone(),
+            version_expression: self.version.clone(),
+        }
+    }
+}
+
+// ANCHOR: PackageBuilder
+/// A builder for a Package. Use `build()` to create the `Package` itself.
+struct PackageBuilder(Package);
+
+impl PackageBuilder {
+    // ANCHOR_END: PackageBuilder
+    // ANCHOR: new
+    fn new(name: impl Into<String>) -> Self {
+        // ANCHOR_END: new
+        Self(Package {
+            name: name.into(),
+            version: "0.1".into(),
+            authors: vec![],
+            dependencies: vec![],
+            language: None,
+        })
+    }
+
+    // ANCHOR: version
+    /// Set the package version.
+    fn version(mut self, version: impl Into<String>) -> Self {
+        self.0.version = version.into();
+        self
+    }
+    // ANCHOR_END: version
+
+    // ANCHOR: authors
+    /// Set the package authors.
+    fn authors(mut self, authors: Vec<String>) -> Self {
+        // ANCHOR_END: authors
+        self.0.authors = authors;
+        self
+    }
+
+    // ANCHOR: dependency
+    /// Add an additional dependency.
+    fn dependency(mut self, dependency: Dependency) -> Self {
+        // ANCHOR_END: dependency
+        self.0.dependencies.push(dependency);
+        self
+    }
+
+    // ANCHOR: language
+    /// Set the language. If not set, language defaults to None.
+    fn language(mut self, language: Language) -> Self {
+        // ANCHOR_END: language
+        self.0.language = Some(language);
+        self
+    }
+
+    // ANCHOR: build
+    fn build(self) -> Package {
+        self.0
+    }
+}
+// ANCHOR_END: build
+
+// ANCHOR: main
+fn main() {
+    let base64 = PackageBuilder::new("base64").version("0.13").build();
+    println!("base64: {base64:?}");
+    let log = PackageBuilder::new("base64")
+        .version("0.4")
+        .language(Language::Rust)
+        .build();
+    println!("log: {log:?}");
+    let serde = PackageBuilder::new("hawk")
+        .authors(vec!["djmitche".into()])
+        .version(String::from("4.0"))
+        .dependency(base64.as_dependency())
+        .dependency(log.as_dependency())
+        .build();
+    println!("serde: {serde:?}");
+}
+// ANCHOR_END: main
diff --git a/src/memory-management/garbage-collection.md b/src/memory-management/garbage-collection.md
deleted file mode 100644
index 8902d550..00000000
--- a/src/memory-management/garbage-collection.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Automatic Memory Management
-
-An alternative to manual and scope-based memory management is automatic memory
-management:
-
-* The programmer never allocates or deallocates memory explicitly.
-* A garbage collector finds unused memory and deallocates it for the programmer.
-
-## Java Example
-
-The `person` object is not deallocated after `sayHello` returns:
-
-```java
-void sayHello(Person person) {
-  System.out.println("Hello " + person.getName());
-}
-```
diff --git a/src/memory-management/manual.md b/src/memory-management/manual.md
deleted file mode 100644
index 0e7f88e6..00000000
--- a/src/memory-management/manual.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Manual Memory Management
-
-You allocate and deallocate heap memory yourself.
-
-If not done with care, this can lead to crashes, bugs, security vulnerabilities, and memory leaks.
-
-## C Example
-
-You must call `free` on every pointer you allocate with `malloc`:
-
-```c
-void foo(size_t n) {
-    int* int_array = malloc(n * sizeof(int));
-    //
-    // ... lots of code
-    //
-    free(int_array);
-}
-```
-
-Memory is leaked if the function returns early between `malloc` and `free`: the
-pointer is lost and we cannot deallocate the memory.
-Worse, freeing the pointer twice, or accessing a freed pointer can lead to exploitable security vulnerabilities.
diff --git a/src/memory-management/move.md b/src/memory-management/move.md
new file mode 100644
index 00000000..b1499851
--- /dev/null
+++ b/src/memory-management/move.md
@@ -0,0 +1,166 @@
+---
+minutes: 10
+---
+
+# Move Semantics
+
+An assignment will transfer _ownership_ between variables:
+
+```rust,editable
+fn main() {
+    let s1: String = String::from("Hello!");
+    let s2: String = s1;
+    println!("s2: {s2}");
+    // println!("s1: {s1}");
+}
+```
+
+* The assignment of `s1` to `s2` transfers ownership.
+* When `s1` goes out of scope, nothing happens: it does not own anything.
+* When `s2` goes out of scope, the string data is freed.
+
+Before move to `s2`:
+
+```bob
+ Stack                             Heap
+.- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.
+:                           :     :                           :
+:    s1                     :     :                           :
+:   +-----------+-------+   :     :   +----+----+----+----+   :
+:   | ptr       |   o---+---+-----+-->| R  | u  | s  | t  |   :
+:   | len       |     4 |   :     :   +----+----+----+----+   :
+:   | capacity  |     4 |   :     :                           :
+:   +-----------+-------+   :     :                           :
+:                           :     `- - - - - - - - - - - - - -'
+:                           :
+`- - - - - - - - - - - - - -'
+```
+
+After move to `s2`:
+
+```bob
+ Stack                             Heap
+.- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.
+:                           :     :                           :
+:    s1 "(inaccessible)"    :     :                           :
+:   +-----------+-------+   :     :   +----+----+----+----+   :
+:   | ptr       |   o---+---+--+--+-->| R  | u  | s  | t  |   :
+:   | len       |     4 |   :  |  :   +----+----+----+----+   :
+:   | capacity  |     4 |   :  |  :                           :
+:   +-----------+-------+   :  |  :                           :
+:                           :  |  `- - - - - - - - - - - - - -'
+:    s2                     :  |
+:   +-----------+-------+   :  |
+:   | ptr       |   o---+---+--'
+:   | len       |     4 |   :
+:   | capacity  |     4 |   :
+:   +-----------+-------+   :
+:                           :
+`- - - - - - - - - - - - - -'
+```
+
+When you pass a value to a function, the value is assigned to the function
+parameter. This transfers ownership:
+
+```rust,editable
+fn say_hello(name: String) {
+    println!("Hello {name}")
+}
+
+fn main() {
+    let name = String::from("Alice");
+    say_hello(name);
+    // say_hello(name);
+}
+```
+
+<details>
+
+* Mention that this is the opposite of the defaults in C++, which copies by value unless you use `std::move` (and the move constructor is defined!).
+
+* It is only the ownership that moves. Whether any machine code is generated to manipulate the data itself is a matter of optimization, and such copies are aggressively optimized away.
+
+* Simple values (such as integers) can be marked `Copy` (see later slides).
+
+* In Rust, clones are explicit (by using `clone`).
+
+In the `say_hello` example:
+
+* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` cannot be used anymore within `main`.
+* The heap memory allocated for `name` will be freed at the end of the `say_hello` function.
+* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` accepts a reference as a parameter.
+* Alternatively, `main` can pass a clone of `name` in the first call (`name.clone()`).
+* Rust makes it harder than C++ to inadvertently create copies by making move semantics the default, and by forcing programmers to make clones explicit.
+
+# More to Explore
+
+## Defensive Copies in Modern C++
+
+Modern C++ solves this differently:
+
+```c++
+std::string s1 = "Cpp";
+std::string s2 = s1;  // Duplicate the data in s1.
+```
+
+* The heap data from `s1` is duplicated and `s2` gets its own independent copy.
+* When `s1` and `s2` go out of scope, they each free their own memory.
+
+Before copy-assignment:
+
+
+```bob
+ Stack                             Heap
+.- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.
+:                           :     :                       :
+:    s1                     :     :                       :
+:   +-----------+-------+   :     :   +----+----+----+    :
+:   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :
+:   | len       |     3 |   :     :   +----+----+----+    :
+:   | capacity  |     3 |   :     :                       :
+:   +-----------+-------+   :     :                       :
+:                           :     `- - - - - - - - - - - -'
+`- - - - - - - - - - - - - -'
+```
+
+After copy-assignment:
+
+```bob
+ Stack                             Heap
+.- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.
+:                           :     :                       :
+:    s1                     :     :                       :
+:   +-----------+-------+   :     :   +----+----+----+    :
+:   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :
+:   | len       |     3 |   :     :   +----+----+----+    :
+:   | capacity  |     3 |   :     :                       :
+:   +-----------+-------+   :     :                       :
+:                           :     :                       :
+:    s2                     :     :                       :
+:   +-----------+-------+   :     :   +----+----+----+    :
+:   | ptr       |   o---+---+-----+-->| C  | p  | p  |    :
+:   | len       |     3 |   :     :   +----+----+----+    :
+:   | capacity  |     3 |   :     :                       :
+:   +-----------+-------+   :     :                       :
+:                           :     `- - - - - - - - - - - -'
+`- - - - - - - - - - - - - -'
+```
+
+
+Key points:
+
+- C++ has made a slightly different choice than Rust. Because `=` copies data,
+  the string data has to be cloned. Otherwise we would get a double-free when
+  either string goes out of scope.
+
+- C++ also has [`std::move`], which is used to indicate when a value may be
+  moved from. If the example had been `s2 = std::move(s1)`, no heap allocation
+  would take place. After the move, `s1` would be in a valid but unspecified
+  state. Unlike Rust, the programmer is allowed to keep using `s1`.
+
+- Unlike Rust, `=` in C++ can run arbitrary code as determined by the type
+  which is being copied or moved.
+
+[`std::move`]: https://en.cppreference.com/w/cpp/utility/move
+
+</details>
diff --git a/src/memory-management/ownership.md b/src/memory-management/ownership.md
new file mode 100644
index 00000000..1ee91054
--- /dev/null
+++ b/src/memory-management/ownership.md
@@ -0,0 +1,35 @@
+---
+minutes: 5
+---
+
+# Ownership
+
+All variable bindings have a _scope_ where they are valid and it is an error to
+use a variable outside its scope:
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable,compile_fail
+struct Point(i32, i32);
+
+fn main() {
+    {
+        let p = Point(3, 4);
+        println!("x: {}", p.0);
+    }
+    println!("y: {}", p.1);
+}
+```
+
+We say that the variable _owns_ the value. Every Rust value has precisely one
+owner at all times.
+
+At the end of the scope, the variable is _dropped_ and the data is freed.
+A destructor can run here to free up resources.
+
+<details>
+
+Students familiar with garbage-collection implementations will know that a
+garbage collector starts with a set of "roots" to find all reachable memory.
+Rust's "single owner" principle is a similar idea.
+
+</details>
diff --git a/src/memory-management/stack.md b/src/memory-management/review.md
similarity index 78%
rename from src/memory-management/stack.md
rename to src/memory-management/review.md
index bd312020..e6d588b6 100644
--- a/src/memory-management/stack.md
+++ b/src/memory-management/review.md
@@ -1,4 +1,23 @@
-# Stack and Heap Example
+---
+minutes: 5
+---
+
+# Review of Program Memory
+
+Programs allocate memory in two ways:
+
+* Stack: Continuous area of memory for local variables.
+  * Values have fixed sizes known at compile time.
+  * Extremely fast: just move a stack pointer.
+  * Easy to manage: follows function calls.
+  * Great memory locality.
+
+* Heap: Storage of values outside of function calls.
+  * Values have dynamic sizes determined at runtime.
+  * Slightly slower than the stack: some book-keeping needed.
+  * No guarantee of memory locality.
+
+## Example
 
 Creating a `String` puts fixed-sized metadata on the stack and dynamically sized
 data, the actual string, on the heap:
diff --git a/src/memory-management/rust.md b/src/memory-management/rust.md
deleted file mode 100644
index 7d822391..00000000
--- a/src/memory-management/rust.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Memory Management in Rust
-
-Memory management in Rust is a mix:
-
-* Safe and correct like Java, but without a garbage collector.
-* Scope-based like C++, but the compiler enforces full adherence.
-* A Rust user can choose the right abstraction for the situation, some even have no cost at runtime like C.
-
-Rust achieves this by modeling _ownership_ explicitly.
-
-<details>
-
-* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper types such as [Box], [Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via various means, and prevent the potential errors in C.
-
-* You may be asked about destructors here, the [Drop] trait is the Rust equivalent.
-
-</details>
-
-[Box]: https://doc.rust-lang.org/std/boxed/struct.Box.html
-[Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html
-[Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html
-[Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html
-[Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html
diff --git a/src/memory-management/scope-based.md b/src/memory-management/scope-based.md
deleted file mode 100644
index 20f3eb4e..00000000
--- a/src/memory-management/scope-based.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Scope-Based Memory Management
-
-Constructors and destructors let you hook into the lifetime of an object.
-
-By wrapping a pointer in an object, you can free memory when the object is
-destroyed. The compiler guarantees that this happens, even if an exception is
-raised.
-
-This is often called _resource acquisition is initialization_ (RAII) and gives
-you smart pointers.
-
-## C++ Example
-
-```c++
-void say_hello(std::unique_ptr<Person> person) {
-  std::cout << "Hello " << person->name << std::endl;
-}
-```
-
-* The `std::unique_ptr` object is allocated on the stack, and points to
-  memory allocated on the heap.
-* At the end of `say_hello`, the `std::unique_ptr` destructor will run.
-* The destructor frees the `Person` object it points to.
-
-Special move constructors are used when passing ownership to a function:
-
-<!-- mdbook-xgettext: skip -->
-```c++
-std::unique_ptr<Person> person = find_person("Carla");
-say_hello(std::move(person));
-```
diff --git a/src/memory-management/solution.md b/src/memory-management/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/memory-management/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/memory-management/stack-vs-heap.md b/src/memory-management/stack-vs-heap.md
deleted file mode 100644
index 59c93146..00000000
--- a/src/memory-management/stack-vs-heap.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# The Stack vs The Heap
-
-* Stack: Continuous area of memory for local variables.
-  * Values have fixed sizes known at compile time.
-  * Extremely fast: just move a stack pointer.
-  * Easy to manage: follows function calls.
-  * Great memory locality.
-
-* Heap: Storage of values outside of function calls.
-  * Values have dynamic sizes determined at runtime.
-  * Slightly slower than the stack: some book-keeping needed.
-  * No guarantee of memory locality.
diff --git a/src/methods-and-traits.md b/src/methods-and-traits.md
new file mode 100644
index 00000000..6254ba51
--- /dev/null
+++ b/src/methods-and-traits.md
@@ -0,0 +1,3 @@
+# Methods and Traits
+
+{{%segment outline}}
diff --git a/src/methods-and-traits/Cargo.toml b/src/methods-and-traits/Cargo.toml
new file mode 100644
index 00000000..b5347e60
--- /dev/null
+++ b/src/methods-and-traits/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "methods-and-traits"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "methods-and-traits"
+path = "exercise.rs"
+
diff --git a/src/methods-and-traits/deriving.md b/src/methods-and-traits/deriving.md
new file mode 100644
index 00000000..16564b96
--- /dev/null
+++ b/src/methods-and-traits/deriving.md
@@ -0,0 +1,33 @@
+---
+minutes: 5
+---
+
+# Deriving
+
+Supported traits can be automatically implemented for your custom types, as
+follows:
+
+```rust,editable
+#[derive(Debug, Clone, Default)]
+struct Player {
+    name: String,
+    strength: u8,
+    hit_points: u8,
+}
+
+fn main() {
+    let p1 = Player::default(); // Default trait adds `default` constructor.
+    let mut p2 = p1.clone();    // Clone trait adds `clone` method.
+    p2.name = String::from("EldurScrollz");
+    // Debug trait adds support for printing with `{:?}`.
+    println!("{:?} vs. {:?}", p1, p2);
+}
+```
+
+<details>
+
+Derivation is implemented with macros, and many crates provide useful derive
+macros to add useful functionality. For example, `serde` can derive
+serialization support for a struct using `#[derive(Serialize)]`.
+
+</detail>
diff --git a/src/exercises/day-3/simple-gui.md b/src/methods-and-traits/exercise.md
similarity index 76%
rename from src/exercises/day-3/simple-gui.md
rename to src/methods-and-traits/exercise.md
index ecaf0120..2b2f40b3 100644
--- a/src/exercises/day-3/simple-gui.md
+++ b/src/methods-and-traits/exercise.md
@@ -1,4 +1,8 @@
-# Drawing A Simple GUI
+---
+minutes: 30
+---
+
+# Exercise: GUI Library
 
 Let us design a classical GUI library using our new knowledge of traits and
 trait objects. We'll only implement the drawing of it (as text) for simplicity.
@@ -16,40 +20,19 @@ The widgets will implement a `Widget` trait, see below.
 Copy the code below to <https://play.rust-lang.org/>, fill in the missing
 `draw_into` methods so that you implement the `Widget` trait:
 
-```rust,should_panic
+```rust,compile_fail
 // TODO: remove this when you're done with your implementation.
 #![allow(unused_imports, unused_variables, dead_code)]
 
-{{#include simple-gui.rs:setup}}
+{{#include exercise.rs:setup}}
 
-{{#include simple-gui.rs:Label-width}}
-        unimplemented!()
-    }
+// TODO: Implement `Widget` for `Label`.
 
-{{#include simple-gui.rs:Label-draw_into}}
-        unimplemented!()
-    }
-}
+// TODO: Implement `Widget` for `Button`.
 
-{{#include simple-gui.rs:Button-width}}
-        unimplemented!()
-    }
+// TODO: Implement `Widget` for `Window`.
 
-{{#include simple-gui.rs:Button-draw_into}}
-        unimplemented!()
-    }
-}
-
-{{#include simple-gui.rs:Window-width}}
-        unimplemented!()
-    }
-
-{{#include simple-gui.rs:Window-draw_into}}
-        unimplemented!()
-    }
-}
-
-{{#include simple-gui.rs:main}}
+{{#include exercise.rs:main}}
 ```
 
 The output of the above program can be something simple like this:
diff --git a/src/exercises/day-3/simple-gui.rs b/src/methods-and-traits/exercise.rs
similarity index 89%
rename from src/exercises/day-3/simple-gui.rs
rename to src/methods-and-traits/exercise.rs
index dd2058cb..24bf690a 100644
--- a/src/exercises/day-3/simple-gui.rs
+++ b/src/methods-and-traits/exercise.rs
@@ -77,20 +77,15 @@ impl Window {
         )
     }
 }
-
 // ANCHOR_END: setup
 
-// ANCHOR: Window-width
 impl Widget for Window {
     fn width(&self) -> usize {
-        // ANCHOR_END: Window-width
         // Add 4 paddings for borders
         self.inner_width() + 4
     }
 
-    // ANCHOR: Window-draw_into
     fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
-        // ANCHOR_END: Window-draw_into
         let mut inner = String::new();
         for widget in &self.widgets {
             widget.draw_into(&mut inner);
@@ -111,16 +106,12 @@ impl Widget for Window {
     }
 }
 
-// ANCHOR: Button-width
 impl Widget for Button {
     fn width(&self) -> usize {
-        // ANCHOR_END: Button-width
         self.label.width() + 8 // add a bit of padding
     }
 
-    // ANCHOR: Button-draw_into
     fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
-        // ANCHOR_END: Button-draw_into
         let width = self.width();
         let mut label = String::new();
         self.label.draw_into(&mut label);
@@ -133,10 +124,8 @@ impl Widget for Button {
     }
 }
 
-// ANCHOR: Label-width
 impl Widget for Label {
     fn width(&self) -> usize {
-        // ANCHOR_END: Label-width
         self.label
             .lines()
             .map(|line| line.chars().count())
@@ -144,9 +133,7 @@ impl Widget for Label {
             .unwrap_or(0)
     }
 
-    // ANCHOR: Label-draw_into
     fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
-        // ANCHOR_END: Label-draw_into
         writeln!(buffer, "{}", &self.label).unwrap();
     }
 }
@@ -155,9 +142,7 @@ impl Widget for Label {
 fn main() {
     let mut window = Window::new("Rust GUI Demo 1.23");
     window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
-    window.add_widget(Box::new(Button::new(
-        "Click me!"
-    )));
+    window.add_widget(Box::new(Button::new("Click me!")));
     window.draw();
 }
 // ANCHOR_END: main
diff --git a/src/methods-and-traits/methods.md b/src/methods-and-traits/methods.md
new file mode 100644
index 00000000..92a1f22b
--- /dev/null
+++ b/src/methods-and-traits/methods.md
@@ -0,0 +1,80 @@
+---
+minutes: 10
+---
+
+# Methods
+
+Rust allows you to associate functions with your new types. You do this with an
+`impl` block:
+
+```rust,editable
+#[derive(Debug)]
+struct Race {
+    name: String,
+    laps: Vec<i32>,
+}
+
+impl Race {
+    fn new(name: &str) -> Self {  // No receiver, a static method
+        Race { name: String::from(name), laps: Vec::new() }
+    }
+
+    fn add_lap(&mut self, lap: i32) {  // Exclusive borrowed read-write access to self
+        self.laps.push(lap);
+    }
+
+    fn print_laps(&self) {  // Shared and read-only borrowed access to self
+        println!("Recorded {} laps for {}:", self.laps.len(), self.name);
+        for (idx, lap) in self.laps.iter().enumerate() {
+            println!("Lap {idx}: {lap} sec");
+        }
+    }
+
+    fn finish(self) {  // Exclusive ownership of self
+        let total = self.laps.iter().sum::<i32>();
+        println!("Race {} is finished, total lap time: {}", self.name, total);
+    }
+}
+
+fn main() {
+    let mut race = Race::new("Monaco Grand Prix");
+    race.add_lap(70);
+    race.add_lap(68);
+    race.print_laps();
+    race.add_lap(71);
+    race.print_laps();
+    race.finish();
+    // race.add_lap(42);
+}
+```
+
+The `self` arguments specify the "receiver" - the object the method acts on. There
+are several common receivers for a method:
+
+* `&self`: borrows the object from the caller using a shared and immutable
+  reference. The object can be used again afterwards.
+* `&mut self`: borrows the object from the caller using a unique and mutable
+  reference. The object can be used again afterwards.
+* `self`: takes ownership of the object and moves it away from the caller. The
+  method becomes the owner of the object. The object will be dropped (deallocated)
+  when the method returns, unless its ownership is explicitly
+  transmitted. Complete ownership does not automatically mean mutability.
+* `mut self`: same as above, but the method can mutate the object.
+* No receiver: this becomes a static method on the struct. Typically used to
+  create constructors which are called `new` by convention.
+
+<details>
+
+Key Points:
+* It can be helpful to introduce methods by comparing them to functions.
+  * Methods are called on an instance of a type (such as a struct or enum), the first parameter represents the instance as `self`.
+  * Developers may choose to use methods to take advantage of method receiver syntax and to help keep them more organized. By using methods we can keep all the implementation code in one predictable place.
+* Point out the use of the keyword `self`, a method receiver.
+  * Show that it is an abbreviated term for `self: Self` and perhaps show how the struct name could also be used.
+  * Explain that `Self` is a type alias for the type the `impl` block is in and can be used elsewhere in the block.
+  * Note how `self` is used like other structs and dot notation can be used to refer to individual fields.
+  * This might be a good time to demonstrate how the `&self` differs from `self` by trying to run `finish` twice.
+  * Beyond variants on `self`, there are also [special wrapper types](https://doc.rust-lang.org/reference/special-types-and-traits.html) allowed to be receiver types, such as `Box<Self>`.
+* Note that references have not been covered yet. References in method receivers are a particularly "natural" form of reference, so there is no need to go into a great level of detail.
+
+</details>
diff --git a/src/methods-and-traits/solution.md b/src/methods-and-traits/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/methods-and-traits/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/traits/trait-objects.md b/src/methods-and-traits/trait-objects.md
similarity index 99%
rename from src/traits/trait-objects.md
rename to src/methods-and-traits/trait-objects.md
index 2f57bf9f..65c678fa 100644
--- a/src/traits/trait-objects.md
+++ b/src/methods-and-traits/trait-objects.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # Trait Objects
 
 Trait objects allow for values of different types, for instance in a collection:
diff --git a/src/methods-and-traits/traits.md b/src/methods-and-traits/traits.md
new file mode 100644
index 00000000..ac59b1b7
--- /dev/null
+++ b/src/methods-and-traits/traits.md
@@ -0,0 +1,49 @@
+---
+minutes: 10
+---
+
+# Traits
+
+Rust lets you abstract over types with traits. They're similar to interfaces:
+
+```rust,editable
+struct Dog { name: String, age: i8 }
+struct Cat { lives: i8 } // No name needed, cats won't respond anyway.
+
+trait Pet {
+    fn talk(&self) -> String;
+
+    fn greet(&self) {
+        println!("Oh you're a cutie! What's your name? {}", self.talk());
+    }
+}
+
+impl Pet for Dog {
+    fn talk(&self) -> String { format!("Woof, my name is {}!", self.name) }
+}
+
+impl Pet for Cat {
+    fn talk(&self) -> String { String::from("Miau!") }
+}
+
+fn main() {
+    let captain_floof = Cat { lives: 9 };
+    let fido = Dog { name: String::from("Fido"), age: 5 };
+
+    captain_floof.greet();
+    fido.greet();
+}
+```
+
+<details>
+
+* A trait defines a number of methods that types must have in order to implement
+  the trait.
+
+* Traits are implemented in an `impl <trait> for <type> { .. }` block.
+
+* Traits may specify pre-implemented (provided) methods and methods that users
+  are required to implement themselves. Provided methods can rely on required
+  methods. In this case, `greet` is provided, and relies on `talk`.
+
+</details>
diff --git a/src/methods.md b/src/methods.md
deleted file mode 100644
index a922b5ca..00000000
--- a/src/methods.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Methods
-
-Rust allows you to associate functions with your new types. You do this with an
-`impl` block:
-
-```rust,editable
-#[derive(Debug)]
-struct Person {
-    name: String,
-    age: u8,
-}
-
-impl Person {
-    fn say_hello(&self) {
-        println!("Hello, my name is {}", self.name);
-    }
-}
-
-fn main() {
-    let peter = Person {
-        name: String::from("Peter"),
-        age: 27,
-    };
-    peter.say_hello();
-}
-```
-
-<details>
-
-Key Points:
-* It can be helpful to introduce methods by comparing them to functions.
-  * Methods are called on an instance of a type (such as a struct or enum), the first parameter represents the instance as `self`.
-  * Developers may choose to use methods to take advantage of method receiver syntax and to help keep them more organized. By using methods we can keep all the implementation code in one predictable place.
-* Point out the use of the keyword `self`, a method receiver.
-  * Show that it is an abbreviated term for `self: Self` and perhaps show how the struct name could also be used.
-  * Explain that `Self` is a type alias for the type the `impl` block is in and can be used elsewhere in the block.
-  * Note how `self` is used like other structs and dot notation can be used to refer to individual fields.
-  * This might be a good time to demonstrate how the `&self` differs from `self` by modifying the code and trying to run say_hello twice.
-* We describe the distinction between method receivers next.
-
-</details>
diff --git a/src/methods/example.md b/src/methods/example.md
deleted file mode 100644
index 1ee19b10..00000000
--- a/src/methods/example.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# Example
-
-```rust,editable
-#[derive(Debug)]
-struct Race {
-    name: String,
-    laps: Vec<i32>,
-}
-
-impl Race {
-    fn new(name: &str) -> Race {  // No receiver, a static method
-        Race { name: String::from(name), laps: Vec::new() }
-    }
-
-    fn add_lap(&mut self, lap: i32) {  // Exclusive borrowed read-write access to self
-        self.laps.push(lap);
-    }
-
-    fn print_laps(&self) {  // Shared and read-only borrowed access to self
-        println!("Recorded {} laps for {}:", self.laps.len(), self.name);
-        for (idx, lap) in self.laps.iter().enumerate() {
-            println!("Lap {idx}: {lap} sec");
-        }
-    }
-
-    fn finish(self) {  // Exclusive ownership of self
-        let total = self.laps.iter().sum::<i32>();
-        println!("Race {} is finished, total lap time: {}", self.name, total);
-    }
-}
-
-fn main() {
-    let mut race = Race::new("Monaco Grand Prix");
-    race.add_lap(70);
-    race.add_lap(68);
-    race.print_laps();
-    race.add_lap(71);
-    race.print_laps();
-    race.finish();
-    // race.add_lap(42);
-}
-```
-
-<details>
-    
-Key Points:
-* All four methods here use a different method receiver.
-  * You can point out how that changes what the function can do with the variable values and if/how it can be used again in `main`.
-  * You can showcase the error that appears when trying to call `finish` twice.
-* Note that although the method receivers are different, the non-static functions are called the same way in the main body. Rust enables automatic referencing and dereferencing when calling methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method signature.
-* You might point out that `print_laps` is using a vector that is iterated over. We describe vectors in more detail in the afternoon. 
-
-</details>
diff --git a/src/methods/receiver.md b/src/methods/receiver.md
deleted file mode 100644
index 6ef789be..00000000
--- a/src/methods/receiver.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Method Receiver
-
-The `&self` above indicates that the method borrows the object immutably. There
-are other possible receivers for a method:
-
-* `&self`: borrows the object from the caller using a shared and immutable
-  reference. The object can be used again afterwards.
-* `&mut self`: borrows the object from the caller using a unique and mutable
-  reference. The object can be used again afterwards.
-* `self`: takes ownership of the object and moves it away from the caller. The
-  method becomes the owner of the object. The object will be dropped (deallocated)
-  when the method returns, unless its ownership is explicitly
-  transmitted. Complete ownership does not automatically mean mutability.
-* `mut self`: same as above, but the method can mutate the object. 
-* No receiver: this becomes a static method on the struct. Typically used to
-  create constructors which are called `new` by convention.
-
-Beyond variants on `self`, there are also
-[special wrapper types](https://doc.rust-lang.org/reference/special-types-and-traits.html)
-allowed to be receiver types, such as `Box<Self>`.
-
-<details>
-  
-Consider emphasizing "shared and immutable" and "unique and mutable". These constraints always come
-together in Rust due to borrow checker rules, and `self` is no exception. It isn't possible to
-reference a struct from multiple locations and call a mutating (`&mut self`) method on it.
-  
-</details>
diff --git a/src/modules.md b/src/modules.md
index bf208d6f..b4e93751 100644
--- a/src/modules.md
+++ b/src/modules.md
@@ -1,32 +1,3 @@
 # Modules
 
-We have seen how `impl` blocks let us namespace functions to a type.
-
-Similarly, `mod` lets us namespace types and functions:
-
-```rust,editable
-mod foo {
-    pub fn do_something() {
-        println!("In the foo module");
-    }
-}
-
-mod bar {
-    pub fn do_something() {
-        println!("In the bar module");
-    }
-}
-
-fn main() {
-    foo::do_something();
-    bar::do_something();
-}
-```
-
-<details>
-
-* Packages provide functionality and include a `Cargo.toml` file that describes how to build a bundle of 1+ crates.
-* Crates are a tree of modules, where a binary crate creates an executable and a library crate compiles to a library.
-* Modules define organization, scope, and are the focus of this section.
-
-</details>
+{{%segment outline}}
diff --git a/src/modules/exercise.md b/src/modules/exercise.md
new file mode 100644
index 00000000..4c2154f1
--- /dev/null
+++ b/src/modules/exercise.md
@@ -0,0 +1,35 @@
+---
+minutes: 20
+---
+
+# Exercise: Modules for the GUI Library
+
+In this exercise, you will reorganize the GUI Library exercise from the
+"Methods and Traits" segment of the course into a collection of modules. It is
+typical to put each type or set of closely-related types into its own module,
+so each widget type should get its own module.
+
+If you no longer have your version, that's fine - refer back to the [provided
+solution](../methods-and-traits/solution.html).
+
+## Cargo Setup
+
+The Rust playground only supports one file, so you will need to make a Cargo
+project on your local filesystem:
+
+```shell
+cargo init gui-modules
+cd gui-modules
+cargo run
+```
+
+Edit `src/main.rs` to add `mod` statements, and add additional files in the
+`src` directory.
+
+<details>
+
+Encourage students to divide the code in a way that feels natural for them, and
+get accustomed to the required `mod`, `use`, and `pub` declarations. Afterward,
+discuss what organizations are most idiomatic.
+
+</details>
diff --git a/src/modules/filesystem.md b/src/modules/filesystem.md
index b935ec2f..16a1636f 100644
--- a/src/modules/filesystem.md
+++ b/src/modules/filesystem.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Filesystem Hierarchy
 
 Omitting the module content will tell Rust to look for it in another file:
diff --git a/src/modules/modules.md b/src/modules/modules.md
new file mode 100644
index 00000000..5a59767c
--- /dev/null
+++ b/src/modules/modules.md
@@ -0,0 +1,36 @@
+---
+minutes: 5
+---
+
+# Modules
+
+We have seen how `impl` blocks let us namespace functions to a type.
+
+Similarly, `mod` lets us namespace types and functions:
+
+```rust,editable
+mod foo {
+    pub fn do_something() {
+        println!("In the foo module");
+    }
+}
+
+mod bar {
+    pub fn do_something() {
+        println!("In the bar module");
+    }
+}
+
+fn main() {
+    foo::do_something();
+    bar::do_something();
+}
+```
+
+<details>
+
+* Packages provide functionality and include a `Cargo.toml` file that describes how to build a bundle of 1+ crates.
+* Crates are a tree of modules, where a binary crate creates an executable and a library crate compiles to a library.
+* Modules define organization, scope, and are the focus of this section.
+
+</details>
diff --git a/src/modules/paths.md b/src/modules/paths.md
index bf4b9546..53bdba6c 100644
--- a/src/modules/paths.md
+++ b/src/modules/paths.md
@@ -1,4 +1,18 @@
-# Paths
+---
+minutes: 10
+---
+
+# use, super, self
+
+A module can bring symbols from another module into scope with `use`.
+You will typically see something like this at the top of each module:
+
+```rust,editable
+use std::collections::HashSet;
+use std::process::abort;
+```
+
+## Paths
 
 Paths are resolved as follows:
 
@@ -10,10 +24,29 @@ Paths are resolved as follows:
    * `crate::foo` refers to `foo` in the root of the current crate,
    * `bar::foo` refers to `foo` in the `bar` crate.
 
-A module can bring symbols from another module into scope with `use`.
-You will typically see something like this at the top of each module:
+<details>
 
-```rust,editable
-use std::collections::HashSet;
-use std::mem::transmute;
-```
+* It is common to "re-export" symbols at a shorter path. For example, the
+  top-level `lib.rs` in a crate might have
+
+  ```rust,ignore
+  mod storage;
+
+  pub use storage::disk::DiskStorage;
+  pub use storage::network::NetworkStorage;
+  ```
+
+  making `DiskStorage` and `NetworkStorage` available to other crates with a
+  convenient, short path.
+
+* For the most part, only items that appear in a module need to be `use`'d.
+  However, a trait must be in scope to call any methods on that trait, even if
+  a type implementing that trait is already in scope. For example, to use the
+  `read_to_string` method on a type implementing the `Read` trait, you need to
+  `use std::io::Read`.
+
+* The `use` statement can have a wildcard: `use std::io::*`. This is
+  discouraged because it is not clear which items are imported, and those might
+  change over time.
+
+</details>
diff --git a/src/modules/solution.md b/src/modules/solution.md
new file mode 100644
index 00000000..ea277616
--- /dev/null
+++ b/src/modules/solution.md
@@ -0,0 +1,185 @@
+# Solution
+
+<!-- 
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+
+```rust,ignore
+// ---- src/widgets.rs ----
+pub trait Widget {
+    /// Natural width of `self`.
+    fn width(&self) -> usize;
+
+    /// Draw the widget into a buffer.
+    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);
+
+    /// Draw the widget on standard output.
+    fn draw(&self) {
+        let mut buffer = String::new();
+        self.draw_into(&mut buffer);
+        println!("{buffer}");
+    }
+}
+
+pub use button::Button;
+pub use label::Label;
+pub use window::Window;
+```
+
+```rust,ignore
+// ---- src/widgets/label.rs ----
+use super::Widget;
+
+pub struct Label {
+    label: String,
+}
+
+impl Label {
+    pub fn new(label: &str) -> Label {
+        Label {
+            label: label.to_owned(),
+        }
+    }
+}
+
+impl Widget for Label {
+    fn width(&self) -> usize {
+        // ANCHOR_END: Label-width
+        self.label
+            .lines()
+            .map(|line| line.chars().count())
+            .max()
+            .unwrap_or(0)
+    }
+
+    // ANCHOR: Label-draw_into
+    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
+        // ANCHOR_END: Label-draw_into
+        writeln!(buffer, "{}", &self.label).unwrap();
+    }
+}
+```
+
+```rust,ignore
+// ---- src/widgets/button.rs ----
+use super::{Label, Widget};
+
+pub struct Button {
+    label: Label,
+}
+
+impl Button {
+    pub fn new(label: &str) -> Button {
+        Button {
+            label: Label::new(label),
+        }
+    }
+}
+
+impl Widget for Button {
+    fn width(&self) -> usize {
+        // ANCHOR_END: Button-width
+        self.label.width() + 8 // add a bit of padding
+    }
+
+    // ANCHOR: Button-draw_into
+    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
+        // ANCHOR_END: Button-draw_into
+        let width = self.width();
+        let mut label = String::new();
+        self.label.draw_into(&mut label);
+
+        writeln!(buffer, "+{:-<width$}+", "").unwrap();
+        for line in label.lines() {
+            writeln!(buffer, "|{:^width$}|", &line).unwrap();
+        }
+        writeln!(buffer, "+{:-<width$}+", "").unwrap();
+    }
+}
+```
+
+```rust,ignore
+// ---- src/widgets/window.rs ----
+use super::Widget;
+
+pub struct Window {
+    title: String,
+    widgets: Vec<Box<dyn Widget>>,
+}
+
+impl Window {
+    pub fn new(title: &str) -> Window {
+        Window {
+            title: title.to_owned(),
+            widgets: Vec::new(),
+        }
+    }
+
+    pub fn add_widget(&mut self, widget: Box<dyn Widget>) {
+        self.widgets.push(widget);
+    }
+
+    fn inner_width(&self) -> usize {
+        std::cmp::max(
+            self.title.chars().count(),
+            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),
+        )
+    }
+}
+
+impl Widget for Window {
+    fn width(&self) -> usize {
+        // ANCHOR_END: Window-width
+        // Add 4 paddings for borders
+        self.inner_width() + 4
+    }
+
+    // ANCHOR: Window-draw_into
+    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
+        // ANCHOR_END: Window-draw_into
+        let mut inner = String::new();
+        for widget in &self.widgets {
+            widget.draw_into(&mut inner);
+        }
+
+        let inner_width = self.inner_width();
+
+        // TODO: after learning about error handling, you can change
+        // draw_into to return Result<(), std::fmt::Error>. Then use
+        // the ?-operator here instead of .unwrap().
+        writeln!(buffer, "+-{:-<inner_width$}-+", "").unwrap();
+        writeln!(buffer, "| {:^inner_width$} |", &self.title).unwrap();
+        writeln!(buffer, "+={:=<inner_width$}=+", "").unwrap();
+        for line in inner.lines() {
+            writeln!(buffer, "| {:inner_width$} |", line).unwrap();
+        }
+        writeln!(buffer, "+-{:-<inner_width$}-+", "").unwrap();
+    }
+}
+```
+
+```rust,ignore
+// ---- src/main.rs ----
+use widgets::Widget;
+
+fn main() {
+    let mut window = widgets::Window::new("Rust GUI Demo 1.23");
+    window.add_widget(Box::new(widgets::Label::new(
+        "This is a small text GUI demo.",
+    )));
+    window.add_widget(Box::new(widgets::Button::new("Click me!")));
+    window.draw();
+}
+```
diff --git a/src/modules/visibility.md b/src/modules/visibility.md
index 2525f2ad..92914e79 100644
--- a/src/modules/visibility.md
+++ b/src/modules/visibility.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Visibility
 
 Modules are a privacy boundary:
diff --git a/src/ownership.md b/src/ownership.md
deleted file mode 100644
index 47dd62e0..00000000
--- a/src/ownership.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Ownership
-
-All variable bindings have a _scope_ where they are valid and it is an error to
-use a variable outside its scope:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable,compile_fail
-struct Point(i32, i32);
-
-fn main() {
-    {
-        let p = Point(3, 4);
-        println!("x: {}", p.0);
-    }
-    println!("y: {}", p.1);
-}
-```
-
-* At the end of the scope, the variable is _dropped_ and the data is freed.
-* A destructor can run here to free up resources.
-* We say that the variable _owns_ the value.
diff --git a/src/ownership/double-free-modern-cpp.md b/src/ownership/double-free-modern-cpp.md
deleted file mode 100644
index 425812fa..00000000
--- a/src/ownership/double-free-modern-cpp.md
+++ /dev/null
@@ -1,71 +0,0 @@
-# Defensive Copies in Modern C++ 
-
-Modern C++ solves this differently:
-
-```c++
-std::string s1 = "Cpp";
-std::string s2 = s1;  // Duplicate the data in s1.
-```
-
-* The heap data from `s1` is duplicated and `s2` gets its own independent copy.
-* When `s1` and `s2` go out of scope, they each free their own memory.
-
-Before copy-assignment:
-
-
-```bob
- Stack                             Heap
-.- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.
-:                           :     :                       :
-:    s1                     :     :                       :
-:   +-----------+-------+   :     :   +----+----+----+    :
-:   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :
-:   | len       |     3 |   :     :   +----+----+----+    :
-:   | capacity  |     3 |   :     :                       :
-:   +-----------+-------+   :     :                       :
-:                           :     `- - - - - - - - - - - -'
-`- - - - - - - - - - - - - -'
-```
-
-After copy-assignment:
-
-```bob
- Stack                             Heap
-.- - - - - - - - - - - - - -.     .- - - - - - - - - - - -.
-:                           :     :                       :
-:    s1                     :     :                       :
-:   +-----------+-------+   :     :   +----+----+----+    :
-:   | ptr       |   o---+---+--+--+-->| C  | p  | p  |    :
-:   | len       |     3 |   :     :   +----+----+----+    :
-:   | capacity  |     3 |   :     :                       :
-:   +-----------+-------+   :     :                       :
-:                           :     :                       :
-:    s2                     :     :                       :
-:   +-----------+-------+   :     :   +----+----+----+    :
-:   | ptr       |   o---+---+-----+-->| C  | p  | p  |    :
-:   | len       |     3 |   :     :   +----+----+----+    :
-:   | capacity  |     3 |   :     :                       :
-:   +-----------+-------+   :     :                       :
-:                           :     `- - - - - - - - - - - -'
-`- - - - - - - - - - - - - -'
-```
-
-<details>
-
-Key points:
-
-- C++ has made a slightly different choice than Rust. Because `=` copies data,
-  the string data has to be cloned. Otherwise we would get a double-free when
-  either string goes out of scope.
-
-- C++ also has [`std::move`], which is used to indicate when a value may be
-  moved from. If the example had been `s2 = std::move(s1)`, no heap allocation
-  would take place. After the move, `s1` would be in a valid but unspecified
-  state. Unlike Rust, the programmer is allowed to keep using `s1`.
-
-- Unlike Rust, `=` in C++ can run arbitrary code as determined by the type
-  which is being copied or moved.
-
-[`std::move`]: https://en.cppreference.com/w/cpp/utility/move
- 
-</details>
diff --git a/src/ownership/lifetimes-function-calls.md b/src/ownership/lifetimes-function-calls.md
deleted file mode 100644
index 24d9c198..00000000
--- a/src/ownership/lifetimes-function-calls.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Lifetimes in Function Calls
-
-In addition to borrowing its arguments, a function can return a borrowed value:
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-#[derive(Debug)]
-struct Point(i32, i32);
-
-fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {
-    if p1.0 < p2.0 { p1 } else { p2 }
-}
-
-fn main() {
-    let p1: Point = Point(10, 10);
-    let p2: Point = Point(20, 20);
-    let p3: &Point = left_most(&p1, &p2);
-    println!("p3: {p3:?}");
-}
-```
-
-* `'a` is a generic parameter, it is inferred by the compiler.
-* Lifetimes start with `'` and `'a` is a typical default name.
-* Read `&'a Point` as "a borrowed `Point` which is valid for at least the
-  lifetime `a`".
-  * The _at least_ part is important when parameters are in different scopes.
-
-<details>
-
-In the above example, try the following:
-
-* Move the declaration of `p2` and `p3` into a new scope (`{ ... }`), resulting in the following code:
-  <!-- mdbook-xgettext: skip -->
-  ```rust,ignore
-  #[derive(Debug)]
-  struct Point(i32, i32);
-
-  fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {
-      if p1.0 < p2.0 { p1 } else { p2 }
-  }
-
-  fn main() {
-      let p1: Point = Point(10, 10);
-      let p3: &Point;
-      {
-          let p2: Point = Point(20, 20);
-          p3 = left_most(&p1, &p2);
-      }
-      println!("p3: {p3:?}");
-  }
-  ```
-  Note how this does not compile since `p3` outlives `p2`.
-
-* Reset the workspace and change the function signature to `fn left_most<'a, 'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile because the relationship between the lifetimes `'a` and `'b` is unclear.
-* Another way to explain it:
-  * Two references to two values are borrowed by a function and the function returns
-    another reference.
-  * It must have come from one of those two inputs (or from a global variable).
-  * Which one is it? The compiler needs to know, so at the call site the returned reference is not used
-    for longer than a variable from where the reference came from.
-
-</details>
diff --git a/src/ownership/lifetimes.md b/src/ownership/lifetimes.md
deleted file mode 100644
index 606d1116..00000000
--- a/src/ownership/lifetimes.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Lifetimes
-
-A borrowed value has a _lifetime_:
-
-* The lifetime can be implicit: `add(p1: &Point, p2: &Point) -> Point`.
-* Lifetimes can also be explicit: `&'a Point`, `&'document str`.
-* Read `&'a Point` as "a borrowed `Point` which is valid for at least the
-  lifetime `a`".
-* Lifetimes are always inferred by the compiler: you cannot assign a lifetime
-  yourself.
-  * Lifetime annotations create constraints; the compiler verifies that there is
-    a valid solution.
-* Lifetimes for function arguments and return values must be fully specified,
-  but Rust allows lifetimes to be elided in most cases with [a few simple
-  rules](https://doc.rust-lang.org/nomicon/lifetime-elision.html).
diff --git a/src/ownership/move-semantics.md b/src/ownership/move-semantics.md
deleted file mode 100644
index ecea9163..00000000
--- a/src/ownership/move-semantics.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Move Semantics
-
-An assignment will transfer _ownership_ between variables:
-
-```rust,editable
-fn main() {
-    let s1: String = String::from("Hello!");
-    let s2: String = s1;
-    println!("s2: {s2}");
-    // println!("s1: {s1}");
-}
-```
-
-* The assignment of `s1` to `s2` transfers ownership.
-* When `s1` goes out of scope, nothing happens: it does not own anything.
-* When `s2` goes out of scope, the string data is freed.
-* There is always _exactly_ one variable binding which owns a value.
-
-<details>
-
-* Mention that this is the opposite of the defaults in C++, which copies by value unless you use `std::move` (and the move constructor is defined!).
-
-* It is only the ownership that moves. Whether any machine code is generated to manipulate the data itself is a matter of optimization, and such copies are aggressively optimized away.
-
-* Simple values (such as integers) can be marked `Copy` (see later slides).
-
-* In Rust, clones are explicit (by using `clone`).
-
-</details>
diff --git a/src/ownership/moved-strings-rust.md b/src/ownership/moved-strings-rust.md
deleted file mode 100644
index b33c7bf8..00000000
--- a/src/ownership/moved-strings-rust.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# Moved Strings in Rust
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable
-fn main() {
-    let s1: String = String::from("Rust");
-    let s2: String = s1;
-}
-```
-
-* The heap data from `s1` is reused for `s2`.
-* When `s1` goes out of scope, nothing happens (it has been moved from).
-
-Before move to `s2`:
-
-```bob
- Stack                             Heap
-.- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.
-:                           :     :                           :
-:    s1                     :     :                           :
-:   +-----------+-------+   :     :   +----+----+----+----+   :
-:   | ptr       |   o---+---+-----+-->| R  | u  | s  | t  |   :
-:   | len       |     4 |   :     :   +----+----+----+----+   :
-:   | capacity  |     4 |   :     :                           :
-:   +-----------+-------+   :     :                           :
-:                           :     `- - - - - - - - - - - - - -'
-:                           :
-`- - - - - - - - - - - - - -'
-```
-
-After move to `s2`:
-
-```bob
- Stack                             Heap
-.- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - -.
-:                           :     :                           :
-:    s1 "(inaccessible)"    :     :                           :
-:   +-----------+-------+   :     :   +----+----+----+----+   :
-:   | ptr       |   o---+---+--+--+-->| R  | u  | s  | t  |   :
-:   | len       |     4 |   :  |  :   +----+----+----+----+   :
-:   | capacity  |     4 |   :  |  :                           :
-:   +-----------+-------+   :  |  :                           :
-:                           :  |  `- - - - - - - - - - - - - -'
-:    s2                     :  |
-:   +-----------+-------+   :  |
-:   | ptr       |   o---+---+--'
-:   | len       |     4 |   :
-:   | capacity  |     4 |   :
-:   +-----------+-------+   :
-:                           :
-`- - - - - - - - - - - - - -'
-```
diff --git a/src/ownership/moves-function-calls.md b/src/ownership/moves-function-calls.md
deleted file mode 100644
index e30f2126..00000000
--- a/src/ownership/moves-function-calls.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# Moves in Function Calls
-
-When you pass a value to a function, the value is assigned to the function
-parameter. This transfers ownership:
-
-```rust,editable
-fn say_hello(name: String) {
-    println!("Hello {name}")
-}
-
-fn main() {
-    let name = String::from("Alice");
-    say_hello(name);
-    // say_hello(name);
-}
-```
-
-<details>
-
-* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` cannot be used anymore within `main`.
-* The heap memory allocated for `name` will be freed at the end of the `say_hello` function.
-* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` accepts a reference as a parameter.
-* Alternatively, `main` can pass a clone of `name` in the first call (`name.clone()`).
-* Rust makes it harder than C++ to inadvertently create copies by making move semantics the default, and by forcing programmers to make clones explicit.
-
-</details>
diff --git a/src/ownership/shared-unique-borrows.md b/src/ownership/shared-unique-borrows.md
deleted file mode 100644
index 57c48e02..00000000
--- a/src/ownership/shared-unique-borrows.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# Shared and Unique Borrows
-
-Rust puts constraints on the ways you can borrow values:
-
-* You can have one or more `&T` values at any given time, _or_
-* You can have exactly one `&mut T` value.
-
-<!-- mdbook-xgettext: skip -->
-```rust,editable,compile_fail
-fn main() {
-    let mut a: i32 = 10;
-    let b: &i32 = &a;
-
-    {
-        let c: &mut i32 = &mut a;
-        *c = 20;
-    }
-
-    println!("a: {a}");
-    println!("b: {b}");
-}
-```
-
-<details>
-
-* The above code does not compile because `a` is borrowed as mutable (through `c`) and as immutable (through `b`) at the same time.
-* Move the `println!` statement for `b` before the scope that introduces `c` to make the code compile.
-* After that change, the compiler realizes that `b` is only ever used before the new mutable borrow of `a` through `c`. This is a feature of the borrow checker called "non-lexical lifetimes".
-
-</details>
diff --git a/src/pattern-matching.md b/src/pattern-matching.md
index a8779f6c..16737d6f 100644
--- a/src/pattern-matching.md
+++ b/src/pattern-matching.md
@@ -1,35 +1,3 @@
 # Pattern Matching
 
-The `match` keyword lets you match a value against one or more _patterns_. The
-comparisons are done from top to bottom and the first match wins.
-
-The patterns can be simple values, similarly to `switch` in C and C++:
-
-```rust,editable
-fn main() {
-    let input = 'x';
-
-    match input {
-        'q'                   => println!("Quitting"),
-        'a' | 's' | 'w' | 'd' => println!("Moving around"),
-        '0'..='9'             => println!("Number input"),
-        _                     => println!("Something else"),
-    }
-}
-```
-
-The `_` pattern is a wildcard pattern which matches any value.
-
-<details>
-    
-Key Points:
-* You might point out how some specific characters are being used when in a pattern
-  * `|` as an `or`
-  * `..` can expand as much as it needs to be
-  * `1..=5` represents an inclusive range
-  * `_` is a wild card
-* It can be useful to show how binding works, by for instance replacing a wildcard character with a variable, or removing the quotes around `q`.
-* You can demonstrate matching on a reference.
-* This might be a good time to bring up the concept of irrefutable patterns, as the term can show up in error messages.
-   
-</details>
+{{%segment outline}}
diff --git a/src/pattern-matching/Cargo.toml b/src/pattern-matching/Cargo.toml
new file mode 100644
index 00000000..dc619b2e
--- /dev/null
+++ b/src/pattern-matching/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "pattern-matching"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "eval"
+path = "exercise.rs"
diff --git a/src/pattern-matching/destructuring-arrays.md b/src/pattern-matching/destructuring-arrays.md
deleted file mode 100644
index fdf7ec23..00000000
--- a/src/pattern-matching/destructuring-arrays.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# Destructuring Arrays
-
-You can destructure arrays, tuples, and slices by matching on their elements:
-
-```rust,editable
-{{#include ../../third_party/rust-by-example/destructuring-arrays.rs}}
-```
-
-
-<details>
-
-* Destructuring of slices of unknown length also works with patterns of fixed length.
-
-
-     ```rust,editable
-     fn main() {
-         inspect(&[0, -2, 3]);
-         inspect(&[0, -2, 3, 4]);
-     }
-
-     #[rustfmt::skip]
-     fn inspect(slice: &[i32]) {
-         println!("Tell me about {slice:?}");
-         match slice {
-             &[0, y, z] => println!("First is 0, y = {y}, and z = {z}"),
-             &[1, ..]   => println!("First is 1 and the rest were ignored"),
-             _          => println!("All elements were ignored"),
-         }
-     }
-     ```
-  
-* Create a new pattern using `_` to represent an element. 
-* Add more values to the array.
-* Point out that how `..` will expand to account for different number of elements.
-* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`
-
-</details>
diff --git a/src/pattern-matching/destructuring-structs.md b/src/pattern-matching/destructuring-structs.md
deleted file mode 100644
index 67fbb211..00000000
--- a/src/pattern-matching/destructuring-structs.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# Destructuring Structs
-
-You can also destructure `structs`:
-
-```rust,editable
-{{#include ../../third_party/rust-by-example/destructuring-structs.rs}}
-```
-<details>
-
-* Change the literal values in `foo` to match with the other patterns.
-* Add a new field to `Foo` and make changes to the pattern as needed.
-* The distinction between a capture and a constant expression can be hard to
-  spot. Try changing the `2` in the second arm to a variable, and see that it subtly
-  doesn't work. Change it to a `const` and see it working again.
-
-</details>
diff --git a/src/pattern-matching/destructuring-enums.md b/src/pattern-matching/destructuring.md
similarity index 55%
rename from src/pattern-matching/destructuring-enums.md
rename to src/pattern-matching/destructuring.md
index 378cef76..c419e382 100644
--- a/src/pattern-matching/destructuring-enums.md
+++ b/src/pattern-matching/destructuring.md
@@ -1,4 +1,17 @@
-# Destructuring Enums
+---
+minutes: 10
+---
+
+# Destructuring
+
+Like tuples, structs and enums can also be destructured by matching:
+
+## Structs
+
+```rust,editable
+{{#include ../../third_party/rust-by-example/destructuring-structs.rs}}
+```
+## Enums
 
 Patterns can also be used to bind variables to parts of your values. This is how
 you inspect the structure of your types. Let us start with a simple `enum` type:
@@ -32,8 +45,20 @@ arm, `half` is bound to the value inside the `Ok` variant. In the second arm,
 
 <details>
 
+# Structs
+
+* Change the literal values in `foo` to match with the other patterns.
+* Add a new field to `Foo` and make changes to the pattern as needed.
+* The distinction between a capture and a constant expression can be hard to
+  spot. Try changing the `2` in the second arm to a variable, and see that it subtly
+  doesn't work. Change it to a `const` and see it working again.
+
+# Enums
+
 Key points:
 * The `if`/`else` expression is returning an enum that is later unpacked with a `match`.
 * You can try adding a third variant to the enum definition and displaying the errors when running the code. Point out the places where your code is now inexhaustive and how the compiler tries to give you hints.
+* The values in the enum variants can only be accessed after being pattern matched. The pattern binds references to the fields in the "match arm" after the `=>`.
+* Demonstrate what happens when the search is inexhaustive. Note the advantage the Rust compiler provides by confirming when all cases are handled.
 
 </details>
diff --git a/src/exercises/day-1/pattern-matching.md b/src/pattern-matching/exercise.md
similarity index 69%
rename from src/exercises/day-1/pattern-matching.md
rename to src/pattern-matching/exercise.md
index 532f067b..f48c4873 100644
--- a/src/exercises/day-1/pattern-matching.md
+++ b/src/pattern-matching/exercise.md
@@ -1,19 +1,24 @@
+---
+minutes: 30
+---
+
 # Exercise: Expression Evaluation
 
-Let's write a simple recursive evaluator for arithmetic expressions. 
+Let's write a simple recursive evaluator for arithmetic expressions. Start with
+an enum defining the binary operations:
 
 ```rust
-{{#include pattern-matching.rs:Operation}}
+{{#include exercise.rs:Operation}}
 
-{{#include pattern-matching.rs:Expression}}
+{{#include exercise.rs:Expression}}
 
-{{#include pattern-matching.rs:Res}}
+{{#include exercise.rs:Res}}
 
-{{#include pattern-matching.rs:eval}}
+{{#include exercise.rs:eval}}
     todo!()
 }
 
-{{#include pattern-matching.rs:tests}}
+{{#include exercise.rs:tests}}
 ```
 
 The `Box` type here is a smart pointer, and will be covered in detail later in
@@ -27,7 +32,15 @@ very similar to the standard-library `Result` which we will see later.
 
 Copy and paste the code into the Rust playground, and begin implementing
 `eval`. The final product should pass the tests. It may be helpful to use
-`todo!()` and get the tests to pass one-by-one.
+`todo!()` and get the tests to pass one-by-one. You can also skip a test
+temporarily with
+`#[ignore]`:
+
+```none
+#[test]
+#[ignore]
+fn test_value() { .. }
+```
 
 If you finish early, try writing a test that results in an integer overflow.
 How could you handle this with `Res::Err` instead of a panic?
diff --git a/src/exercises/day-1/pattern-matching.rs b/src/pattern-matching/exercise.rs
similarity index 99%
rename from src/exercises/day-1/pattern-matching.rs
rename to src/pattern-matching/exercise.rs
index 0491c70c..7c1e3c55 100644
--- a/src/exercises/day-1/pattern-matching.rs
+++ b/src/pattern-matching/exercise.rs
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#![allow(dead_code)]
 // ANCHOR: solution
 // ANCHOR: Operation
 /// An operation to perform on two subexpressions.
@@ -139,6 +140,7 @@ fn test_error() {
     );
 }
 // ANCHOR_END: tests
+
 fn main() {
     let expr = Expression::Op {
         op: Operation::Sub,
diff --git a/src/pattern-matching/let-control-flow.md b/src/pattern-matching/let-control-flow.md
new file mode 100644
index 00000000..aa381d5f
--- /dev/null
+++ b/src/pattern-matching/let-control-flow.md
@@ -0,0 +1,124 @@
+---
+minutes: 10
+---
+
+# Let Control Flow
+
+Rust has a few control flow constructs which differ from other languages. They
+are used for pattern matching:
+
+- `if let` expressions
+- `while let` expressions
+- `match` expressions
+# `if let` expressions
+
+The [`if let`
+expression](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions)
+lets you execute different code depending on whether a value matches a pattern:
+
+```rust,editable
+fn sleep_for(secs: f32) {
+    let dur = if let Ok(dur) = std::time::Duration::try_from_secs_f32(secs) {
+        dur
+    } else {
+        std::time::Duration::from_millis(500)
+    };
+    std::thread::sleep(dur);
+    println!("slept for {:?}", dur);
+}
+
+fn main() {
+    sleep_for(-10.0);
+    sleep_for(0.8);
+}
+```
+
+For the common case of matching a pattern and returning from the function, use
+[`let
+else`](https://doc.rust-lang.org/rust-by-example/flow_control/let_else.html).
+The "else" case must diverge (`return`, `break`, or panic - anything but
+falling off the end of the block).
+
+```rust,editable
+fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
+    let s = if let Some(s) = maybe_string {
+        s
+    } else {
+        return Err(String::from("got None"));
+    };
+
+    let first_byte_char = if let Some(first_byte_char) = s.chars().next() {
+        first_byte_char
+    } else {
+        return Err(String::from("got empty string"));
+    };
+
+    if let Some(digit) = first_byte_char.to_digit(16) {
+        Ok(digit)
+    } else {
+        Err(String::from("not a hex digit"))
+    }
+}
+
+fn main() {
+    println!("result: {:?}", hex_or_die_trying(Some(String::from("foo"))));
+}
+```
+
+Like with `if let`, there is a [`while let`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-pattern-loops)
+variant which repeatedly tests a value against a pattern:
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable
+fn main() {
+    let mut name = String::from("Comprehensive Rust 🦀");
+    while let Some(c) = name.pop() {
+        println!("character: {c}");
+    }
+    // (There are more efficient ways to reverse a string!)
+}
+```
+
+Here
+[`String::pop`](https://doc.rust-lang.org/stable/std/string/struct.String.html#method.pop)
+returns `Some(c)` until the string is empty, after which it will return `None`.
+The `while let` lets us keep iterating through all items.
+
+<details>
+
+## if-let
+
+* Unlike `match`, `if let` does not have to cover all branches. This can make it more concise than `match`.
+* A common usage is handling `Some` values when working with `Option`.
+* Unlike `match`, `if let` does not support guard clauses for pattern matching.
+
+## let-else
+
+`if-let`s can pile up, as shown.  The `let-else` construct supports flattening this nested code.
+Rewrite the awkward version for students, so they can see the transformation.
+
+The rewritten version is:
+```rust
+fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
+    let Some(s) = maybe_string else {
+        return Err(String::from("got None"));
+    };
+
+    let Some(first_byte_char) = s.chars().next() else {
+        return Err(String::from("got empty string"));
+    };
+
+    let Some(digit) = first_byte_char.to_digit(16) else {
+        return Err(String::from("not a hex digit"));
+    };
+
+    return Ok(digit);
+}
+```
+
+# while-let
+
+* Point out that the `while let` loop will keep going as long as the value matches the pattern.
+* You could rewrite the `while let` loop as an infinite loop with an if statement that breaks when there is no value to unwrap for `name.pop()`. The `while let` provides syntactic sugar for the above scenario.
+
+</details>
diff --git a/src/pattern-matching/match-guards.md b/src/pattern-matching/match-guards.md
deleted file mode 100644
index ce04e50a..00000000
--- a/src/pattern-matching/match-guards.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Match Guards
-
-When matching, you can add a _guard_ to a pattern. This is an arbitrary Boolean
-expression which will be executed if the pattern matches:
-
-```rust,editable
-{{#include ../../third_party/rust-by-example/match-guards.rs}}
-```
-
-<details>
-
-Key Points:
-* Match guards as a separate syntax feature are important and necessary when we wish to concisely express more complex ideas than patterns alone would allow.
-* They are not the same as separate `if` expression inside of the match arm. An `if` expression inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` condition inside of that block won't result in other arms
-of the original `match` expression being considered.  
-* You can use the variables defined in the pattern in your if expression.
-* The condition defined in the guard applies to every expression in a pattern with an `|`.
-</details>
diff --git a/src/pattern-matching/solution.md b/src/pattern-matching/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/pattern-matching/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/references.md b/src/references.md
new file mode 100644
index 00000000..e48db3a6
--- /dev/null
+++ b/src/references.md
@@ -0,0 +1,3 @@
+# References
+
+{{%segment outline}}
diff --git a/src/references/Cargo.toml b/src/references/Cargo.toml
new file mode 100644
index 00000000..279efb39
--- /dev/null
+++ b/src/references/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "references"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "references"
+path = "exercise.rs"
diff --git a/src/references/exclusive.md b/src/references/exclusive.md
new file mode 100644
index 00000000..b8b7f5e0
--- /dev/null
+++ b/src/references/exclusive.md
@@ -0,0 +1,34 @@
+---
+minutes: 10
+---
+
+# Exclusive References
+
+Exclusive references, also known as mutable references, allow changing the value
+they refer to. They have type `&mut T`.
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable
+fn main() {
+    let mut point = (1, 2);
+    let x_coord = &mut point.0;
+    *x_coord = 20;
+    println!("point: {point:?}");
+}
+```
+
+<details>
+
+Key points:
+
+* "Exclusive" means that only this reference can be used to access the value.
+  No other references (shared or exclusive) can exist at the same time, and the
+  referenced value cannot be accessed while the exclusive reference exists. Try
+  making an `&point.0` or changing `point.0` while `x_coord` is alive.
+
+* Be sure to note the difference between `let mut x_coord: &i32` and `let
+  x_coord: &mut i32`. The first one represents a shared reference which can be
+  bound to different values, while the second represents an exclusive reference
+  to a mutable value.
+
+</details>
diff --git a/src/references/exercise.md b/src/references/exercise.md
new file mode 100644
index 00000000..6bad4bd7
--- /dev/null
+++ b/src/references/exercise.md
@@ -0,0 +1,31 @@
+---
+minutes: 30
+---
+
+# Exercise: Geometry
+
+We will create a few utility functions for 3-dimensional geometry, representing
+a point as `[f64;3]`. It is up to you to determine the function signatures.
+
+```rust,compile_fail
+// Calculate the magnitude of a vector by summing the squares of its coordinates
+// and taking the square root. Use the `sqrt()` method to calculate the square
+// root, like `v.sqrt()`.
+
+{{#include exercise.rs:magnitude}}
+fn magnitude(...) -> f64 {
+    todo!()
+}
+
+// Normalize a vector by calculating its magnitude and dividing all of its
+// coordinates by that magnitude.
+
+{{#include exercise.rs:normalize}}
+fn normalize(...) {
+    todo!()
+}
+
+// Use the following `main` to test your work.
+
+{{#include exercise.rs:main}}
+```
diff --git a/src/references/exercise.rs b/src/references/exercise.rs
new file mode 100644
index 00000000..d0203fd1
--- /dev/null
+++ b/src/references/exercise.rs
@@ -0,0 +1,45 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+/// Calculate the magnitude of the given vector.
+fn magnitude(vector: &[f64; 3]) -> f64 {
+    let mut mag_squared = 0.0;
+    for coord in vector {
+        mag_squared += coord * coord;
+    }
+    mag_squared.sqrt()
+}
+
+/// Change the magnitude of the vector to 1.0 without changing its direction.
+fn normalize(vector: &mut [f64; 3]) {
+    let mag = magnitude(vector);
+    vector[0] /= mag;
+    vector[1] /= mag;
+    vector[2] /= mag;
+}
+
+// ANCHOR: main
+fn main() {
+    println!(
+        "Magnitude of a unit vector: {}",
+        magnitude(&[0.0, 1.0, 0.0])
+    );
+
+    let mut v = [1.0, 2.0, 9.0];
+    println!("Magnitude of {v:?}: {}", magnitude(&v));
+    normalize(&mut v);
+    println!("Magnitude of {v:?} after normalization: {}", magnitude(&v));
+}
+// ANCHOR_END: main
diff --git a/src/references/shared.md b/src/references/shared.md
new file mode 100644
index 00000000..7e2ee007
--- /dev/null
+++ b/src/references/shared.md
@@ -0,0 +1,70 @@
+---
+minutes: 10
+---
+
+# Shared References
+
+A reference provides a way to access another value without taking responsibility
+for the value, and is also called "borrowing". Shared references are read-only,
+and the referenced data cannot change.
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable
+fn main() {
+    let a = 'A';
+    let b = 'B';
+    let mut r: &char = &a;
+    println!("r: {}", *r);
+    r = &b;
+    println!("r: {}", *r);
+}
+```
+
+A shared reference to a type `T` has type `&T`. A reference value is made with the `&`
+operator. The `*` operator "dereferences" a reference, yielding its value.
+
+Rust will statically forbid dangling references:
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable,compile_fail
+fn x_axis(x: i32) -> &(i32, i32) {
+    let point = (x, 0);
+    return &point;
+}
+```
+
+<details>
+
+* A reference is said to "borrow" the value it refers to, and this is a good
+  model for students not familiar with pointers: code can use the reference to
+  access the value, but is still "owned" by the original variable. The course
+  will get into more detail on ownership in day 3.
+
+* References are implemented as pointers, and a key advantage is that they can
+  be much smaller than the thing they point to. Students familiar with C or C++
+  will recognize references as pointers. Later parts of the course will cover
+  how Rust prevents the memory-safety bugs that come from using raw pointers.
+
+* Rust does not automatically create references for you - the `&` is always
+  required.
+
+* Rust will auto-dereference in some cases, in particular when invoking
+  methods (try `r.count_ones()`). There is no need for an `->` operator
+  like in C++.
+
+* In this example, `r` is mutable so that it can be reassigned (`r = &b`).
+  Note that this re-binds `r`, so that it refers to something else. This is
+  different from C++, where assignment to a reference changes the referenced
+  value.
+
+* A shared reference does not allow modifying the value it refers to, even if
+  that value was mutable. Try `*r = 'X'`.
+
+* Rust is tracking the lifetimes of all references to ensure they live long
+  enough. Dangling references cannot occur in safe Rust. `x_axis` would return
+  a reference to `point`, but `point` will be deallocated when the function
+  returns, so this will not compile.
+
+* We will talk more about borrowing when we get to ownership.
+
+</details>
diff --git a/src/references/solution.md b/src/references/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/references/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/running-the-course.md b/src/running-the-course.md
index e75d721c..3c931b1e 100644
--- a/src/running-the-course.md
+++ b/src/running-the-course.md
@@ -5,13 +5,10 @@
 Here is a bit of background information about how we've been running the course
 internally at Google.
 
-We typically run classes from 10:00 am to 4:00 pm, with a 1 hour lunch
-break in the middle. This leaves 2.5 hours for the morning class and
-2.5 hours for the afternoon class. Note that this is just a
-recommendation: you can also spend 3 hour on the morning session to
-give people more time for exercises. The downside of longer session is
-that people can become very tired after 6 full hours of class in the
-afternoon.
+We typically run classes from 9:00 am to 4:00 pm, with a 1 hour lunch break in
+the middle. This leaves 3 hours for the morning class and 3 hours for the
+afternoon class. Both sessions contain multiple breaks and time for students to
+work on exercises.
 
 Before you run the course, you will want to:
 
diff --git a/src/running-the-course/course-structure.md b/src/running-the-course/course-structure.md
index 395546df..b33529b6 100644
--- a/src/running-the-course/course-structure.md
+++ b/src/running-the-course/course-structure.md
@@ -5,11 +5,9 @@
 ## Rust Fundamentals
 
 The first three days make up [Rust Fundaments](../welcome-day-1.md).
-The days are fast paced and we cover a lot of ground:
+The days are fast paced and we cover a lot of ground!
 
-* Day 1: Basic Rust, syntax, control flow, creating and consuming values.
-* Day 2: Memory management, ownership, compound data types, and the standard library.
-* Day 3: Generics, traits, error handling, testing, and unsafe Rust.
+{{%course outline Fundamentals}}
 
 ## Deep Dives
 
diff --git a/src/slices-and-lifetimes.md b/src/slices-and-lifetimes.md
new file mode 100644
index 00000000..03c8206a
--- /dev/null
+++ b/src/slices-and-lifetimes.md
@@ -0,0 +1,3 @@
+# Slices and Lifetimes
+
+{{%segment outline}}
diff --git a/src/slices-and-lifetimes/Cargo.toml b/src/slices-and-lifetimes/Cargo.toml
new file mode 100644
index 00000000..62fac4b7
--- /dev/null
+++ b/src/slices-and-lifetimes/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "slices-and-lifetimes"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+thiserror = "*"
+
+[[bin]]
+name = "protobuf"
+path = "exercise.rs"
diff --git a/src/slices-and-lifetimes/exercise.md b/src/slices-and-lifetimes/exercise.md
new file mode 100644
index 00000000..f1a543d4
--- /dev/null
+++ b/src/slices-and-lifetimes/exercise.md
@@ -0,0 +1,60 @@
+---
+minutes: 30
+---
+
+# Exercise: Protobuf Parsing
+
+In this exercise, you will build a parser for the [protobuf binary
+encoding](https://protobuf.dev/programming-guides/encoding/). Don't worry, it's
+simpler than it seems! This illustrates a common parsing pattern, passing slices
+of data. The underlying data itself is never copied.
+
+Fully parsing a protobuf message requires knowing the types of the fields,
+indexed by their field numbers. That is typically provided in a `proto` file. In
+this exercise, we'll encode that information into `match` statements in
+functions that get called for each field.
+
+We'll use the following proto:
+
+```proto
+message PhoneNumber {
+  optional string number = 1;
+  optional string type = 2;
+}
+
+message Person {
+  optional string name = 1;
+  optional int32 id = 2;
+  repeated PhoneNumber phones = 3;
+}
+```
+
+A proto message is encoded as a series of fields, one after the next. Each is
+implemented as a "tag" followed by the value. The tag contains a field number
+(e.g., `2` for the `id` field of a `Person` message) and a wire type defining
+how the payload should be determined from the byte stream.
+
+Integers, including the tag, are represented with a variable-length encoding
+called VARINT. Luckily, `parse_varint` is defined for you below. The given code
+also defines callbacks to handle `Person` and `PhoneNumber` fields, and to parse
+a message into a series of calls to those callbacks.
+
+What remains for you is to implement the `parse_field` function.
+
+<!-- compile_fail because `mdbook test` does not allow use of `thiserror` -->
+```rust,editable,compile_fail
+{{#include exercise.rs:preliminaries }}
+
+
+{{#include exercise.rs:parse_field }}
+    // 1. Read and unpack the tag.
+    // 2. Based on the wire type, build a Field, consuming as many bytes as
+    //    necessary.
+    // 3. Return the field, and any un-consumed bytes.
+    todo!()
+}
+
+{{#include exercise.rs:parse_message }}
+
+{{#include exercise.rs:main }}
+```
diff --git a/src/slices-and-lifetimes/exercise.rs b/src/slices-and-lifetimes/exercise.rs
new file mode 100644
index 00000000..23dfd416
--- /dev/null
+++ b/src/slices-and-lifetimes/exercise.rs
@@ -0,0 +1,253 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+// ANCHOR: preliminaries
+use std::convert::TryFrom;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+enum Error {
+    #[error("Invalid varint")]
+    InvalidVarint,
+    #[error("Invalid wire-type")]
+    InvalidWireType,
+    #[error("Unexpected EOF")]
+    UnexpectedEOF,
+    #[error("Invalid length")]
+    InvalidSize(#[from] std::num::TryFromIntError),
+    #[error("Unexpected wire-type)")]
+    UnexpectedWireType,
+    #[error("Invalid string (not UTF-8)")]
+    InvalidString,
+}
+
+/// A wire type as seen on the wire.
+enum WireType {
+    /// The Varint WireType indicates the value is a single VARINT.
+    Varint,
+    //I64,  -- not needed for this exercise
+    /// The Len WireType indicates that the value is a length represented as a VARINT
+    /// followed by exactly that number of bytes.
+    Len,
+    /// The I32 WireType indicates that the value is precisely 4 bytes in little-endian order
+    /// containing a 32-bit signed integer.
+    I32,
+}
+
+#[derive(Debug)]
+/// A field's value, typed based on the wire type.
+enum FieldValue<'a> {
+    Varint(u64),
+    //I64(i64),  -- not needed for this exercise
+    Len(&'a [u8]),
+    I32(i32),
+}
+
+#[derive(Debug)]
+/// A field, containing the field number and its value.
+struct Field<'a> {
+    field_num: u64,
+    value: FieldValue<'a>,
+}
+
+impl TryFrom<u64> for WireType {
+    type Error = Error;
+
+    fn try_from(value: u64) -> Result<WireType, Error> {
+        Ok(match value {
+            0 => WireType::Varint,
+            //1 => WireType::I64,  -- not needed for this exercise
+            2 => WireType::Len,
+            5 => WireType::I32,
+            _ => return Err(Error::InvalidWireType),
+        })
+    }
+}
+
+impl<'a> FieldValue<'a> {
+    fn as_string(&self) -> Result<&'a str, Error> {
+        let FieldValue::Len(data) = self else {
+            return Err(Error::UnexpectedWireType);
+        };
+        Ok(std::str::from_utf8(data).map_err(|_| Error::InvalidString)?)
+    }
+
+    fn as_bytes(&self) -> Result<&'a [u8], Error> {
+        let FieldValue::Len(data) = self else {
+            return Err(Error::UnexpectedWireType);
+        };
+        Ok(data)
+    }
+
+    fn as_u64(&self) -> Result<u64, Error> {
+        let FieldValue::Varint(value) = self else {
+            return Err(Error::UnexpectedWireType);
+        };
+        Ok(*value)
+    }
+}
+
+/// Parse a VARINT, returning the parsed value and the remaining bytes.
+fn parse_varint(data: &[u8]) -> Result<(u64, &[u8]), Error> {
+    for i in 0..7 {
+        let Some(b) = data.get(i) else {
+            return Err(Error::InvalidVarint);
+        };
+        if b & 0x80 == 0 {
+            // This is the last byte of the VARINT, so convert it to
+            // a u64 and return it.
+            let mut value = 0u64;
+            for b in data[..=i].iter().rev() {
+                value = (value << 7) | (b & 0x7f) as u64;
+            }
+            return Ok((value, &data[i + 1..]));
+        }
+    }
+
+    // More than 7 bytes is invalid.
+    Err(Error::InvalidVarint)
+}
+
+/// Convert a tag into a field number and a WireType.
+fn unpack_tag(tag: u64) -> Result<(u64, WireType), Error> {
+    let field_num = tag >> 3;
+    let wire_type = WireType::try_from(tag & 0x7)?;
+    Ok((field_num, wire_type))
+}
+// ANCHOR_END: preliminaries
+
+// ANCHOR: parse_field
+/// Parse a field, returning the remaining bytes
+fn parse_field(data: &[u8]) -> Result<(Field, &[u8]), Error> {
+    // ANCHOR_END: parse_field
+    let (tag, remainder) = parse_varint(data)?;
+    let (field_num, wire_type) = unpack_tag(tag)?;
+    let (fieldvalue, remainder) = match wire_type {
+        WireType::Varint => {
+            let (value, remainder) = parse_varint(remainder)?;
+            (FieldValue::Varint(value), remainder)
+        }
+        WireType::Len => {
+            let (len, remainder) = parse_varint(remainder)?;
+            let len: usize = len.try_into()?;
+            if remainder.len() < len as usize {
+                return Err(Error::UnexpectedEOF);
+            }
+            let (value, remainder) = remainder.split_at(len);
+            (FieldValue::Len(value), remainder)
+        }
+        WireType::I32 => {
+            if remainder.len() < 4usize {
+                return Err(Error::UnexpectedEOF);
+            }
+            let (value, remainder) = remainder.split_at(4);
+            // Unwrap error because `value` is definitely 4 bytes long.
+            let value = i32::from_le_bytes(value.try_into().unwrap());
+            (FieldValue::I32(value), remainder)
+        }
+    };
+    Ok((
+        Field {
+            field_num,
+            value: fieldvalue,
+        },
+        remainder,
+    ))
+}
+
+// ANCHOR: parse_message
+/// Parse a message in the given data, calling `field_callback` for each field in the message.
+///
+/// The entire input is consumed.
+fn parse_message(
+    mut data: &[u8],
+    field_callback: impl Fn(Field) -> Result<(), Error>,
+) -> Result<(), Error> {
+    while !data.is_empty() {
+        let parsed = parse_field(data)?;
+        field_callback(parsed.0)?;
+        data = parsed.1;
+    }
+    Ok(())
+}
+// ANCHOR_END: parse_message
+
+// ANCHOR: main
+fn main() {
+    /// Handle a field in a Person message.
+    fn person_field(field: Field) -> Result<(), Error> {
+        match field.field_num {
+            1 => println!("name: {}", field.value.as_string()?),
+            2 => println!("id: {}", field.value.as_u64()?),
+            3 => {
+                println!("phone:");
+                parse_message(field.value.as_bytes()?, phone_number_field)?;
+            }
+            _ => {} // skip everything else
+        }
+        Ok(())
+    }
+
+    /// Handle a field in a PhoneNumber message.
+    fn phone_number_field(field: Field) -> Result<(), Error> {
+        match field.field_num {
+            1 => println!("  number: {}", field.value.as_string()?),
+            2 => println!("  type: {}", field.value.as_string()?),
+            _ => {} // skip everything else
+        }
+        Ok(())
+    }
+
+    parse_message(
+        &[
+            0x0a, 0x07, 0x6d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c, 0x10, 0x2a, 0x1a, 0x16,
+            0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x30, 0x32, 0x2d, 0x35, 0x35, 0x35, 0x2d, 0x31,
+            0x32, 0x31, 0x32, 0x12, 0x04, 0x68, 0x6f, 0x6d, 0x65, 0x1a, 0x18, 0x0a, 0x0e,
+            0x2b, 0x31, 0x38, 0x30, 0x30, 0x2d, 0x38, 0x36, 0x37, 0x2d, 0x35, 0x33, 0x30,
+            0x38, 0x12, 0x06, 0x6d, 0x6f, 0x62, 0x69, 0x6c, 0x65,
+        ],
+        person_field,
+    )
+    .unwrap()
+}
+// ANCHOR_END: main
+
+// ANCHOR: tests
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn as_string() {
+        assert!(FieldValue::Varint(10).as_string().is_err());
+        assert!(FieldValue::I32(10).as_string().is_err());
+        assert_eq!(FieldValue::Len(b"hello").as_string().unwrap(), "hello");
+    }
+
+    #[test]
+    fn as_bytes() {
+        assert!(FieldValue::Varint(10).as_bytes().is_err());
+        assert!(FieldValue::I32(10).as_bytes().is_err());
+        assert_eq!(FieldValue::Len(b"hello").as_bytes().unwrap(), b"hello");
+    }
+
+    #[test]
+    fn as_u64() {
+        assert_eq!(FieldValue::Varint(10).as_u64().unwrap(), 10u64);
+        assert!(FieldValue::I32(10).as_u64().is_err());
+        assert!(FieldValue::Len(b"hello").as_u64().is_err());
+    }
+}
+// ANCHOR_END: tests
diff --git a/src/slices-and-lifetimes/lifetime-annotations.md b/src/slices-and-lifetimes/lifetime-annotations.md
new file mode 100644
index 00000000..510a37fb
--- /dev/null
+++ b/src/slices-and-lifetimes/lifetime-annotations.md
@@ -0,0 +1,56 @@
+---
+minutes: 10
+---
+
+# Lifetimes
+
+A reference has a _lifetime_, which must "outlive" the value it refers to. This
+is verified by the borrow checker.
+
+The lifetime can be implicit - this is what we have seen so far.  Lifetimes can
+also be explicit: `&'a Point`, `&'document str`.  Lifetimes start with `'` and
+`'a` is a typical default name.  Read `&'a Point` as "a borrowed `Point` which
+is valid for at least the lifetime `a`".
+
+Lifetimes are always inferred by the compiler: you cannot assign a lifetime
+yourself. Explicit lifetime annotations create constraints where there is
+ambiguity; the compiler verifies that there is a valid solution.
+
+Lifetimes become more complicated when considering passing values to and
+returning values from functions.
+
+```rust,compile_fail
+#[derive(Debug)]
+struct Point(i32, i32);
+
+fn left_most(p1: &Point, p2: &Point) -> &Point {
+  if p1.0 < p2.0 { p1 } else { p2 }
+}
+
+fn main() {
+  let p1: Point = Point(10, 10);
+  let p2: Point = Point(20, 20);
+  let p3 = left_most(&p1, &p2); // What is the lifetime of p3?
+  println!("p3: {p3:?}");
+}
+```
+
+<details>
+
+In this example, the the compiler does not know what lifetime to infer for
+`p3`. Looking inside the function body shows that it can only safely assume
+that `p3`'s lifetime is the shorter of `p1` and `p2`. But just like types, Rust
+requires explicit annotations of lifetimes on function arguments and return
+values.
+
+Add `'a` appropriately to `left_most`:
+
+```rust,ignore
+fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {
+```
+
+This says, "given p1 and p2 which both outlive `'a`, the return value lives for at least `'a`.
+
+In common cases, lifetimes can be elided, as described on the next slide.
+
+</details>
diff --git a/src/slices-and-lifetimes/lifetime-elision.md b/src/slices-and-lifetimes/lifetime-elision.md
new file mode 100644
index 00000000..d3d72dfa
--- /dev/null
+++ b/src/slices-and-lifetimes/lifetime-elision.md
@@ -0,0 +1,67 @@
+---
+minutes: 5
+---
+
+# Lifetimes in Function Calls
+
+Lifetimes for function arguments and return values must be fully specified, but
+Rust allows lifetimes to be elided in most cases with [a few simple
+rules](https://doc.rust-lang.org/nomicon/lifetime-elision.html). This is not
+inference -- it is just a syntactic shorthand.
+
+* Each argument which does not have a lifetime annotation is given one.
+* If there is only one argument lifetime, it is given to all un-annotated return values.
+* If there are multiple argument lifetimes, but the first one is for `self`, that lifetime is given to all un-annotated return values.
+
+<!-- mdbook-xgettext: skip -->
+```rust,editable
+#[derive(Debug)]
+struct Point(i32, i32);
+
+fn cab_distance(p1: &Point, p2: &Point) -> i32 {
+    (p1.0 - p2.0).abs() + (p1.1 - p2.1).abs()
+}
+
+fn nearest<'a>(points: &'a [Point], query: &Point) -> Option<&'a Point> {
+    let mut nearest = None;
+    for p in points {
+        if let Some((_, nearest_dist)) = nearest {
+            let dist = cab_distance(p, query);
+            if dist < nearest_dist {
+                nearest = Some((p, dist));
+            }
+        } else {
+            nearest = Some((p, cab_distance(p, query)));
+        };
+    }
+    nearest.map(|(p, _)| p)
+}
+
+fn main() {
+    println!(
+        "{:?}",
+        nearest(
+            &[Point(1, 0), Point(1, 0), Point(-1, 0), Point(0, -1),],
+            &Point(0, 2)
+        )
+    );
+}
+```
+
+<details>
+
+In this example, `cab_distance` is trivially elided.
+
+The `nearest` function provides another example of a function with multiple references in its arguments that requires explicit annotation.
+
+Try adjusting the signature to "lie" about the lifetimes returned:
+
+```rust,ignore
+fn nearest<'a>(points: &'a [Point], query: &'q Point) -> Option<&'q Point> {
+```
+
+This won't compile, demonstrating that the annotations are checked for validity
+by the compiler.  Note that this is not the case for raw pointers (unsafe), and
+this is a common source of errors with unsafe Rust.
+
+</details>
diff --git a/src/basic-syntax/slices.md b/src/slices-and-lifetimes/slices.md
similarity index 98%
rename from src/basic-syntax/slices.md
rename to src/slices-and-lifetimes/slices.md
index 48d63d6c..59ed3deb 100644
--- a/src/basic-syntax/slices.md
+++ b/src/slices-and-lifetimes/slices.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # Slices
 
 A slice gives you a view into a larger collection:
@@ -22,16 +26,17 @@ fn main() {
 * We create a slice by borrowing `a` and specifying the starting and ending indexes in brackets.
 
 * If the slice starts at index 0, Rust’s range syntax allows us to drop the starting index, meaning that `&a[0..a.len()]` and `&a[..a.len()]` are identical.
-    
+
 * The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are identical.
 
 * To easily create a slice of the full array, we can therefore use `&a[..]`.
 
 * `s` is a reference to a slice of `i32`s. Notice that the type of `s` (`&[i32]`) no longer mentions the array length. This allows us to perform computation on slices of different sizes.
- 
-* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) for at least as long as our slice. 
-    
+
+* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) for at least as long as our slice.
+
 * The question about modifying `a[3]` can spark an interesting discussion, but the answer is that for memory safety reasons
   you cannot do it through `a` at this point in the execution, but you can read the data from both `a` and `s` safely.
   It works before you created the slice, and again after the `println`, when the slice is no longer used. More details will be explained in the borrow checker section.
+
 </details>
diff --git a/src/slices-and-lifetimes/solution.md b/src/slices-and-lifetimes/solution.md
new file mode 100644
index 00000000..81412e7b
--- /dev/null
+++ b/src/slices-and-lifetimes/solution.md
@@ -0,0 +1,6 @@
+# Solution
+
+<!-- compile_fail because `mdbook test` does not allow use of `thiserror` -->
+```rust,editable,compile_fail
+{{#include exercise.rs:solution}}
+```
diff --git a/src/basic-syntax/string-slices.md b/src/slices-and-lifetimes/str.md
similarity index 58%
rename from src/basic-syntax/string-slices.md
rename to src/slices-and-lifetimes/str.md
index bb7bdddf..3aa9a6b5 100644
--- a/src/basic-syntax/string-slices.md
+++ b/src/slices-and-lifetimes/str.md
@@ -1,6 +1,14 @@
-# `String` vs `str`
+---
+minutes: 10
+---
 
-We can now understand the two string types in Rust:
+<!-- NOTES:
+Including `&str` as a way of representing a slice of valid utf-8
+-->
+# String References
+
+We can now understand the two string types in Rust: `&str` is almost like
+`&[char]`, but with its data stored in a variable-length encoding (UTF-8).
 
 ```rust,editable
 fn main() {
@@ -11,7 +19,7 @@ fn main() {
     println!("s2: {s2}");
     s2.push_str(s1);
     println!("s2: {s2}");
-    
+
     let s3: &str = &s2[6..];
     println!("s3: {s3}");
 }
@@ -24,21 +32,34 @@ Rust terminology:
 
 <details>
 
-* `&str` introduces a string slice, which is an immutable reference to UTF-8 encoded string data 
+* `&str` introduces a string slice, which is an immutable reference to UTF-8 encoded string data
   stored in a block of memory. String literals (`”Hello”`), are stored in the program’s binary.
 
 * Rust’s `String` type is a wrapper around a vector of bytes. As with a `Vec<T>`, it is owned.
-    
-* As with many other types `String::from()` creates a string from a string literal; `String::new()` 
+
+* As with many other types `String::from()` creates a string from a string literal; `String::new()`
   creates a new empty string, to which string data can be added using the `push()` and `push_str()` methods.
 
-* The `format!()` macro is a convenient way to generate an owned string from dynamic values. It 
+* The `format!()` macro is a convenient way to generate an owned string from dynamic values. It
   accepts the same format specification as `println!()`.
-    
-* You can borrow `&str` slices from `String` via `&` and optionally range selection.
-    
-* For C++ programmers: think of `&str` as `const char*` from C++, but the one that always points 
-  to a valid string in memory. Rust `String` is a rough equivalent of `std::string` from C++ 
+
+* You can borrow `&str` slices from `String` via `&` and optionally range
+  selection.  If you select a byte range that is not aligned to character
+  boundaries, the expression will panic.  The `chars` iterator iterates over
+  characters and is preferred over trying to get character boundaries right.
+
+* For C++ programmers: think of `&str` as `const char*` from C++, but the one that always points
+  to a valid string in memory. Rust `String` is a rough equivalent of `std::string` from C++
   (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string optimization).
-    
+
+* Byte strings literals allow you to create a `&[u8]` value directly:
+
+  <!-- mdbook-xgettext: skip -->
+  ```rust,editable
+  fn main() {
+      println!("{:?}", b"abc");
+      println!("{:?}", &[97, 98, 99]);
+  }
+  ```
+
 </details>
diff --git a/src/ownership/lifetimes-data-structures.md b/src/slices-and-lifetimes/struct-lifetimes.md
similarity index 98%
rename from src/ownership/lifetimes-data-structures.md
rename to src/slices-and-lifetimes/struct-lifetimes.md
index db7adbc1..09ad2809 100644
--- a/src/ownership/lifetimes-data-structures.md
+++ b/src/slices-and-lifetimes/struct-lifetimes.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Lifetimes in Data Structures
 
 If a data type stores borrowed data, it must be annotated with a lifetime:
@@ -27,4 +31,5 @@ fn main() {
 * Types with borrowed data force users to hold on to the original data. This can be useful for creating lightweight views, but it generally makes them somewhat harder to use.
 * When possible, make data structures own their data directly.
 * Some structs with multiple references inside can have more than one lifetime annotation. This can be necessary if there is a need to describe lifetime relationships between the references themselves, in addition to the lifetime of the struct itself. Those are very advanced use cases.
+
 </details>
diff --git a/src/smart-pointers.md b/src/smart-pointers.md
new file mode 100644
index 00000000..8974d8ec
--- /dev/null
+++ b/src/smart-pointers.md
@@ -0,0 +1,3 @@
+# Smart Pointers
+
+{{%segment outline}}
diff --git a/src/smart-pointers/Cargo.toml b/src/smart-pointers/Cargo.toml
new file mode 100644
index 00000000..1e2a539d
--- /dev/null
+++ b/src/smart-pointers/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "smart-pointers"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "binary-tree"
+path = "exercise.rs"
+
diff --git a/src/smart-pointers/box.md b/src/smart-pointers/box.md
new file mode 100644
index 00000000..8e596892
--- /dev/null
+++ b/src/smart-pointers/box.md
@@ -0,0 +1,109 @@
+---
+minutes: 10
+---
+
+# `Box<T>`
+
+[`Box`](https://doc.rust-lang.org/std/boxed/struct.Box.html) is an owned pointer to data on the heap:
+
+```rust,editable
+fn main() {
+    let five = Box::new(5);
+    println!("five: {}", *five);
+}
+```
+
+
+```bob
+ Stack                     Heap
+.- - - - - - -.     .- - - - - - -.
+:             :     :             :
+:    five     :     :             :
+:   +-----+   :     :   +-----+   :
+:   | o---|---+-----+-->|  5  |   :
+:   +-----+   :     :   +-----+   :
+:             :     :             :
+:             :     :             :
+`- - - - - - -'     `- - - - - - -'
+```
+
+`Box<T>` implements `Deref<Target = T>`, which means that you can [call methods
+from `T` directly on a `Box<T>`](https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion).
+
+Recursive data types or data types with dynamic sizes need to use a `Box`:
+
+```rust,editable
+#[derive(Debug)]
+enum List<T> {
+    Cons(T, Box<List<T>>),
+    Nil,
+}
+
+fn main() {
+    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
+    println!("{list:?}");
+}
+```
+
+```bob
+ Stack                           Heap
+.- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - - -.
+:                         :     :                                               :
+:    list                 :     :                                               :
+:   +------+----+----+    :     :    +------+----+----+    +------+----+----+   :
+:   | Cons | 1  | o--+----+-----+--->| Cons | 2  | o--+--->| Nil  | // | // |   :
+:   +------+----+----+    :     :    +------+----+----+    +------+----+----+   :
+:                         :     :                                               :
+:                         :     :                                               :
+'- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - - -'
+```
+<details>
+
+* `Box` is like `std::unique_ptr` in C++, except that it's guaranteed to be not null.
+* In the above example, you can even leave out the `*` in the `println!` statement thanks to `Deref`.
+* A `Box` can be useful when you:
+   * have a type whose size that can't be known at compile time, but the Rust compiler wants to know an exact size.
+   * want to transfer ownership of a large amount of data. To avoid copying large amounts of data on the stack, instead store the data on the heap in a `Box` so only the pointer is moved.
+
+* If `Box` was not used and we attempted to embed a `List` directly into the `List`,
+the compiler would not compute a fixed size of the struct in memory (`List` would be of infinite size).
+
+* `Box` solves this problem as it has the same size as a regular pointer and just points at the next
+element of the `List` in the heap.
+
+* Remove the `Box` in the List definition and show the compiler error. "Recursive with indirection" is a hint you might want to use a Box or reference of some kind, instead of storing a value directly.
+
+# More to Explore
+
+## Niche Optimization
+
+```rust,editable
+#[derive(Debug)]
+enum List<T> {
+    Cons(T, Box<List<T>>),
+    Nil,
+}
+
+fn main() {
+    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
+    println!("{list:?}");
+}
+```
+
+A `Box` cannot be empty, so the pointer is always valid and non-`null`. This
+allows the compiler to optimize the memory layout:
+
+```bob
+ Stack                           Heap
+.- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - -.
+:                         :     :                                             :
+:    list                 :     :                                             :
+:   +----+----+           :     :    +----+----+    +----+------+             :
+:   | 1  | o--+-----------+-----+--->| 2  | o--+--->| // | null |             :
+:   +----+----+           :     :    +----+----+    +----+------+             :
+:                         :     :                                             :
+:                         :     :                                             :
+`- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - -'
+```
+
+</details>
diff --git a/src/smart-pointers/exercise.md b/src/smart-pointers/exercise.md
new file mode 100644
index 00000000..f30562e1
--- /dev/null
+++ b/src/smart-pointers/exercise.md
@@ -0,0 +1,23 @@
+---
+minutes: 30
+---
+
+# Exercise: Binary Tree
+
+A binary tree is a tree-type data structure where every node has two children
+(left and right). We will create a tree where each node stores a value. For a
+given node N, all nodes in a N's left subtree contain smaller values, and all
+nodes in N's right subtree will contain larger values.
+
+Implement the following types, so that the given tests pass.
+
+```rust,editable
+{{#include exercise.rs:types}}
+
+// Implement `new`, `insert`, and `has`.
+
+{{#include exercise.rs:tests}}
+```
+
+Extra Credit: implement an iterator over a binary tree that returns the values
+in order.
diff --git a/src/smart-pointers/exercise.rs b/src/smart-pointers/exercise.rs
new file mode 100644
index 00000000..e1f184b9
--- /dev/null
+++ b/src/smart-pointers/exercise.rs
@@ -0,0 +1,132 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+// ANCHOR: types
+#[derive(Debug)]
+struct BinaryTreeNode<T: Ord + Copy> {
+    value: T,
+    left: BinaryTree<T>,
+    right: BinaryTree<T>,
+}
+
+/// A container storing a set of values, using a binary tree.
+///
+/// If the same value is added multiple times, it is only stored once.
+#[derive(Debug)]
+pub struct BinaryTree<T: Ord + Copy>(Option<Box<BinaryTreeNode<T>>>);
+// ANCHOR_END: types
+
+impl<T: Ord + Copy> BinaryTree<T> {
+    fn new() -> Self {
+        Self(None)
+    }
+
+    fn insert(&mut self, value: T) {
+        match &mut self.0 {
+            None => {
+                self.0 = Some(Box::new(BinaryTreeNode {
+                    value,
+                    left: BinaryTree::new(),
+                    right: BinaryTree::new(),
+                }));
+            }
+            Some(ref mut n) => {
+                if value < n.value {
+                    n.left.insert(value);
+                } else if value > n.value {
+                    n.right.insert(value);
+                }
+            }
+        }
+    }
+
+    fn has(&self, value: T) -> bool {
+        match &self.0 {
+            None => false,
+            Some(n) => {
+                if value == n.value {
+                    true
+                } else if value < n.value {
+                    n.left.has(value)
+                } else {
+                    n.right.has(value)
+                }
+            }
+        }
+    }
+
+    fn len(&self) -> usize {
+        match &self.0 {
+            None => 0,
+            Some(n) => 1 + n.left.len() + n.right.len(),
+        }
+    }
+}
+
+fn main() {
+    let mut tree = BinaryTree::new();
+    tree.insert("foo");
+    assert_eq!(tree.len(), 1);
+    tree.insert("bar");
+    assert!(tree.has("foo"));
+}
+
+// ANCHOR: tests
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn len() {
+        let mut tree = BinaryTree::new();
+        assert_eq!(tree.len(), 0);
+        tree.insert(2);
+        assert_eq!(tree.len(), 1);
+        tree.insert(1);
+        assert_eq!(tree.len(), 2);
+        tree.insert(2); // not a unique item
+        assert_eq!(tree.len(), 2);
+    }
+
+    #[test]
+    fn has() {
+        let mut tree = BinaryTree::new();
+        fn check_has(tree: &BinaryTree<i32>, exp: &[bool]) {
+            let got: Vec<bool> = (0..exp.len()).map(|i| tree.has(i as i32)).collect();
+            assert_eq!(&got, exp);
+        }
+
+        check_has(&tree, &[false, false, false, false, false]);
+        tree.insert(0);
+        check_has(&tree, &[true, false, false, false, false]);
+        tree.insert(4);
+        check_has(&tree, &[true, false, false, false, true]);
+        tree.insert(4);
+        check_has(&tree, &[true, false, false, false, true]);
+        tree.insert(3);
+        check_has(&tree, &[true, false, false, true, true]);
+    }
+
+    #[test]
+    fn unbalanced() {
+        let mut tree = BinaryTree::new();
+        for i in 0..100 {
+            tree.insert(i);
+        }
+        assert_eq!(tree.len(), 100);
+        assert!(tree.has(50));
+    }
+}
+// ANCHOR_END: tests
diff --git a/src/std/rc.md b/src/smart-pointers/rc.md
similarity index 98%
rename from src/std/rc.md
rename to src/smart-pointers/rc.md
index 73e887e3..c6c5ce4c 100644
--- a/src/std/rc.md
+++ b/src/smart-pointers/rc.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # `Rc`
 
 [`Rc`][1] is a reference-counted shared pointer. Use this when you need to refer
diff --git a/src/smart-pointers/solution.md b/src/smart-pointers/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/smart-pointers/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/std-traits.md b/src/std-traits.md
new file mode 100644
index 00000000..2cdb511d
--- /dev/null
+++ b/src/std-traits.md
@@ -0,0 +1,12 @@
+# Standard Library Traits
+
+{{%segment outline}}
+
+<details>
+
+As with the standard-library types, spend time reviewing the documentation for
+each trait.
+
+This section is long. Take a break midway through.
+
+</details>
diff --git a/src/std-traits/Cargo.toml b/src/std-traits/Cargo.toml
new file mode 100644
index 00000000..e00c67b4
--- /dev/null
+++ b/src/std-traits/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "std-traits"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "std-traits"
+path = "exercise.rs"
diff --git a/src/std-traits/casting.md b/src/std-traits/casting.md
new file mode 100644
index 00000000..7b9cacfa
--- /dev/null
+++ b/src/std-traits/casting.md
@@ -0,0 +1,32 @@
+---
+minutes: 5
+---
+
+# Casting
+
+Rust has no _implicit_ type conversions, but does support explicit casts with
+`as`. These generally follow C semantics where those are defined.
+
+```rust,editable
+fn main() {
+    let value: i64 = 1000;
+    println!("as u16: {}", value as u16);
+    println!("as i16: {}", value as i16);
+    println!("as u8: {}", value as u8);
+}
+```
+
+The results of `as` are _always_ defined in Rust and consistent across
+platforms.  This might not match your intuition for changing sign or casting to
+a smaller type -- check the docs, and comment for clarity.
+
+<details>
+
+Consider taking a break after this slide.
+
+`as` is similar to a C++ static cast.  Use of `as` in cases where data might be
+lost is generally discouraged, or at least deserves an explanatory comment.
+
+This is common in casting integers to `usize` for use as an index.
+
+</details>
diff --git a/src/traits/closures.md b/src/std-traits/closures.md
similarity index 98%
rename from src/traits/closures.md
rename to src/std-traits/closures.md
index c09cce6c..5cdf6846 100644
--- a/src/traits/closures.md
+++ b/src/std-traits/closures.md
@@ -1,3 +1,7 @@
+---
+minutes: 20
+---
+
 # Closures
 
 Closures or lambda expressions have types which cannot be named. However, they
diff --git a/src/std-traits/comparisons.md b/src/std-traits/comparisons.md
new file mode 100644
index 00000000..3a55dc75
--- /dev/null
+++ b/src/std-traits/comparisons.md
@@ -0,0 +1,64 @@
+---
+minutes: 10
+---
+
+# Comparisons
+
+These traits support comparisons between values. All traits can be derived for
+types containing fields that implement these traits.
+
+## `PartialEq` and `Eq`
+
+`PartialEq` is a partial equivalence relation, with required method `eq` and
+provided method `ne`. The `==` and `!=` operators will call these methods.
+
+```rust,editable
+struct Key { id: u32, metadata: Option<String> }
+impl PartialEq for Key {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+```
+
+`Eq` is a full equivalence relation (reflexive, symmetric, and transitive) and
+implies `PartialEq`.  Functions that require full equivalence will use `Eq` as
+a trait bound.
+
+## `PartialOrd` and `Ord`
+
+`PartialOrd` defines a partial ordering, with a `partial_cmp` method. It is
+used to implement the `<`, `<=`, `>=`, and `>` operators.
+
+```rust,editable
+use std::cmp::Ordering;
+#[derive(Eq, PartialEq)]
+struct Citation { author: String, year: u32 }
+impl PartialOrd for Citation {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match self.author.partial_cmp(&other.author) {
+            Some(Ordering::Equal) => self.year.partial_cmp(&other.year),
+            author_ord => author_ord,
+        }
+    }
+}
+```
+
+`Ord` is a total ordering, with `cmp` returning `Ordering`.
+
+<details>
+
+`PartialEq` can be implemented between different types, but `Eq` cannot, because it is reflexive:
+
+```rust,editable
+struct Key { id: u32, metadata: Option<String> }
+impl PartialEq<u32> for Key {
+    fn eq(&self, other: &u32) -> bool {
+        self.id == *other
+    }
+}
+```
+
+In practice, it's common to derive these traits, but uncommon to implement them.
+
+</details>
diff --git a/src/traits/default.md b/src/std-traits/default.md
similarity index 98%
rename from src/traits/default.md
rename to src/std-traits/default.md
index 321116e9..50404295 100644
--- a/src/traits/default.md
+++ b/src/std-traits/default.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # The `Default` Trait
 
 [`Default`][1] trait produces a default value for a type.
@@ -48,4 +52,4 @@ fn main() {
 </details>
 
 [1]: https://doc.rust-lang.org/std/default/trait.Default.html
-[2]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-instances-from-other-instances-with-struct-update-syntax
\ No newline at end of file
+[2]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-instances-from-other-instances-with-struct-update-syntax
diff --git a/src/std-traits/exercise.md b/src/std-traits/exercise.md
new file mode 100644
index 00000000..8ac3171e
--- /dev/null
+++ b/src/std-traits/exercise.md
@@ -0,0 +1,21 @@
+---
+minutes: 30
+---
+
+# Exercise: ROT13
+
+In this example, you will implement the classic ["ROT13"
+cipher](https://en.wikipedia.org/wiki/ROT13). Copy this code to the playground,
+and implement the missing bits. Only rotate ASCII alphabetic characters, to
+ensure the result is still valid UTF-8.
+
+```rust,compile_fail
+{{#include exercise.rs:head }}
+
+// Implement the `Read` trait for `RotDecoder`.
+
+{{#include exercise.rs:main }}
+```
+
+What happens if you chain two `RotDecoder` instances together, each rotating by
+13 characters?
diff --git a/src/std-traits/exercise.rs b/src/std-traits/exercise.rs
new file mode 100644
index 00000000..b1412906
--- /dev/null
+++ b/src/std-traits/exercise.rs
@@ -0,0 +1,82 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![allow(unused_variables, dead_code)]
+// ANCHOR: solution
+// ANCHOR: head
+use std::io::Read;
+
+struct RotDecoder<R: Read> {
+    input: R,
+    rot: u8,
+}
+// ANCHOR_END: head
+
+impl<R: Read> Read for RotDecoder<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let size = self.input.read(buf)?;
+        for b in &mut buf[..size] {
+            if b.is_ascii_alphabetic() {
+                let base = if b.is_ascii_uppercase() { 'A' } else { 'a' } as u8;
+                *b = (*b - base + self.rot) % 26 + base;
+            }
+        }
+        Ok(size)
+    }
+}
+
+// ANCHOR: main
+fn main() {
+    let mut rot = RotDecoder {
+        input: "Gb trg gb gur bgure fvqr!".as_bytes(),
+        rot: 13,
+    };
+    let mut result = String::new();
+    rot.read_to_string(&mut result).unwrap();
+    println!("{}", result);
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn joke() {
+        let mut rot = RotDecoder {
+            input: "Gb trg gb gur bgure fvqr!".as_bytes(),
+            rot: 13,
+        };
+        let mut result = String::new();
+        rot.read_to_string(&mut result).unwrap();
+        assert_eq!(&result, "To get to the other side!");
+    }
+
+    #[test]
+    fn binary() {
+        let input: Vec<u8> = (0..=255u8).collect();
+        let mut rot = RotDecoder::<&[u8]> {
+            input: input.as_ref(),
+            rot: 13,
+        };
+        let mut buf = [0u8; 256];
+        assert_eq!(rot.read(&mut buf).unwrap(), 256);
+        for i in 0..=255 {
+            if input[i] != buf[i] {
+                assert!(input[i].is_ascii_alphabetic());
+                assert!(buf[i].is_ascii_alphabetic());
+            }
+        }
+    }
+}
+// ANCHOR_END: main
diff --git a/src/traits/from-into.md b/src/std-traits/from-and-into.md
similarity index 98%
rename from src/traits/from-into.md
rename to src/std-traits/from-and-into.md
index fe480441..dd4ae235 100644
--- a/src/traits/from-into.md
+++ b/src/std-traits/from-and-into.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # `From` and `Into`
 
 Types implement [`From`][1] and [`Into`][2] to facilitate type conversions:
@@ -25,11 +29,11 @@ fn main() {
 ```
 
 <details>
-  
+
 * That's why it is common to only implement `From`, as your type will get `Into` implementation too.
 * When declaring a function argument input type like "anything that can be converted into a `String`", the rule is opposite, you should use `Into`.
   Your function will accept types that implement `From` and those that _only_ implement `Into`.
-    
+
 </details>
 
 [1]: https://doc.rust-lang.org/std/convert/trait.From.html
diff --git a/src/traits/operators.md b/src/std-traits/operators.md
similarity index 96%
rename from src/traits/operators.md
rename to src/std-traits/operators.md
index 99e78394..9648002e 100644
--- a/src/traits/operators.md
+++ b/src/std-traits/operators.md
@@ -1,4 +1,8 @@
-# `Add`, `Mul`, ...
+---
+minutes: 10
+---
+
+# Operators
 
 Operator overloading is implemented via traits in [`std::ops`][1]:
 
@@ -25,7 +29,7 @@ fn main() {
 
 Discussion points:
 
-* You could implement `Add` for `&Point`. In which situations is that useful? 
+* You could implement `Add` for `&Point`. In which situations is that useful?
     * Answer: `Add:add` consumes `self`. If type `T` for which you are
         overloading the operator is not `Copy`, you should consider overloading
         the operator for `&T` as well. This avoids unnecessary cloning on the
diff --git a/src/traits/read-write.md b/src/std-traits/read-and-write.md
similarity index 98%
rename from src/traits/read-write.md
rename to src/std-traits/read-and-write.md
index d9238dfc..8146a50d 100644
--- a/src/traits/read-write.md
+++ b/src/std-traits/read-and-write.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # `Read` and `Write`
 
 Using [`Read`][1] and [`BufRead`][2], you can abstract over `u8` sources:
diff --git a/src/std-traits/solution.md b/src/std-traits/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/std-traits/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/std-types.md b/src/std-types.md
new file mode 100644
index 00000000..cfa68bd7
--- /dev/null
+++ b/src/std-types.md
@@ -0,0 +1,10 @@
+# Standard Library Types
+
+{{%segment outline}}
+
+<details>
+
+For each of the slides in this section, spend some time reviewing the
+documentation pages, highlighting some of the more common methods.
+
+</details>
diff --git a/src/std-types/Cargo.toml b/src/std-types/Cargo.toml
new file mode 100644
index 00000000..fe46d703
--- /dev/null
+++ b/src/std-types/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "std-types"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "hashset"
+path = "exercise.rs"
diff --git a/src/std-types/docs.md b/src/std-types/docs.md
new file mode 100644
index 00000000..e380e7ee
--- /dev/null
+++ b/src/std-types/docs.md
@@ -0,0 +1,45 @@
+---
+minutes: 5
+---
+
+# Language Docs
+
+Rust comes with extensive documentation of the language and the standard library.
+
+For example:
+ * All of the details about [loops](https://doc.rust-lang.org/stable/reference/expressions/loop-expr.html).
+ * Primitive types like [`u8`](https://doc.rust-lang.org/stable/std/primitive.u8.html).
+ * Standard-library items like [`Option`](https://doc.rust-lang.org/stable/std/option/enum.Option.html) or [`BinaryHeap`](https://doc.rust-lang.org/stable/std/collections/struct.BinaryHeap.html).
+
+In fact, you can document your own code:
+
+```rust,editable
+/// Determine whether the first argument is divisible by the second argument.
+///
+/// If the second argument is zero, the result is false.
+fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
+    if rhs == 0 {
+        return false;
+    }
+    lhs % rhs == 0
+}
+```
+
+The contents are treated as Markdown. All published Rust library crates are
+automatically documented at [`docs.rs`](https://docs.rs) using the
+[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is
+idiomatic to document all public items in an API using this pattern.
+
+To document an item from inside the item (such as inside a module), use `//!`
+or `/*! .. */`, called "inner doc comments":
+
+```rust,editable
+//! This module contains functionality relating to divisibility of integers.
+```
+
+<details>
+
+* Show students the generated docs for the `rand` crate at
+  [`docs.rs/rand`](https://docs.rs/rand).
+
+</details>
diff --git a/src/std-types/exercise.md b/src/std-types/exercise.md
new file mode 100644
index 00000000..ac41036f
--- /dev/null
+++ b/src/std-types/exercise.md
@@ -0,0 +1,54 @@
+---
+minutes: 10
+---
+
+# Exercise: Counter
+
+In this exercise you will take a very simple data structure and make it generic.
+It uses a
+[`std::collections::HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html)
+to keep track of which values have been seen and how many times each one has
+appeared.
+
+The initial version of `Counter` is hard coded to only work for `u32` values.
+Make the struct and its methods generic over the type of value being tracked,
+that way `Counter` can track any type of value.
+
+If you finish early, try using the
+[`entry`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html#method.entry)
+method to halve the number of hash lookups required to implement the `count`
+method.
+
+```rust,compile_fail,editable
+use std::collections::HashMap;
+
+/// Counter counts the number of times each value of type T has been seen.
+struct Counter {
+    values: HashMap<u32, u64>,
+}
+
+impl Counter {
+    /// Create a new Counter.
+    fn new() -> Self {
+        Counter {
+            values: HashMap::new(),
+        }
+    }
+
+    /// Count an occurrence of the given value.
+    fn count(&mut self, value: u32) {
+        if self.values.contains_key(&value) {
+            *self.values.get_mut(&value).unwrap() += 1;
+        } else {
+            self.values.insert(value, 1);
+        }
+    }
+
+    /// Return the number of times the given value has been seen.
+    fn times_seen(&self, value: u32) -> u64 {
+        self.values.get(&value).copied().unwrap_or_default()
+    }
+}
+
+{{#include exercise.rs:main}}
+```
diff --git a/src/std-types/exercise.rs b/src/std-types/exercise.rs
new file mode 100644
index 00000000..75f15b56
--- /dev/null
+++ b/src/std-types/exercise.rs
@@ -0,0 +1,64 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![allow(unused_variables, dead_code)]
+// ANCHOR: solution
+use std::collections::HashMap;
+use std::hash::Hash;
+
+/// Counter counts the number of times each value of type T has been seen.
+struct Counter<T: Eq + Hash> {
+    values: HashMap<T, u64>,
+}
+
+impl<T: Eq + Hash> Counter<T> {
+    /// Create a new Counter.
+    fn new() -> Self {
+        Counter {
+            values: HashMap::new(),
+        }
+    }
+
+    /// Count an occurrence of the given value.
+    fn count(&mut self, value: T) {
+        *self.values.entry(value).or_default() += 1;
+    }
+
+    /// Return the number of times the given value has been seen.
+    fn times_seen(&self, value: T) -> u64 {
+        self.values.get(&value).copied().unwrap_or_default()
+    }
+}
+
+// ANCHOR: main
+fn main() {
+    let mut ctr = Counter::new();
+    ctr.count(13);
+    ctr.count(14);
+    ctr.count(16);
+    ctr.count(14);
+    ctr.count(14);
+    ctr.count(11);
+
+    for i in 10..20 {
+        println!("saw {} values equal to {}", ctr.times_seen(i), i);
+    }
+
+    let mut strctr = Counter::new();
+    strctr.count("apple");
+    strctr.count("orange");
+    strctr.count("apple");
+    println!("got {} apples", strctr.times_seen("apple"));
+}
+// ANCHOR_END: main
diff --git a/src/std/hashmap.md b/src/std-types/hashmap.md
similarity index 99%
rename from src/std/hashmap.md
rename to src/std-types/hashmap.md
index 5470fc78..06072b41 100644
--- a/src/std/hashmap.md
+++ b/src/std-types/hashmap.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # `HashMap`
 
 Standard hash map with protection against HashDoS attacks:
diff --git a/src/std-types/option.md b/src/std-types/option.md
new file mode 100644
index 00000000..e26c98a7
--- /dev/null
+++ b/src/std-types/option.md
@@ -0,0 +1,32 @@
+---
+minutes: 10
+---
+
+# Option
+
+We have already seen some use of `Option<T>`. It stores either a
+value of type `T` or nothing. For example,
+[`String::find`](https://doc.rust-lang.org/stable/std/string/struct.String.html#method.find)
+returns an `Option<usize>`.
+
+```rust,editable,should_panic
+fn main() {
+    let name = "Löwe 老虎 Léopard Gepardi";
+    let mut position: Option<usize> = name.find('é');
+    println!("find returned {position:?}");
+    assert_eq!(position.unwrap(), 14);
+    position = name.find('Z');
+    println!("find returned {position:?}");
+    assert_eq!(position.expect("Character not found"), 0);
+}
+```
+
+<details>
+
+  * `Option` is widely used, not just in the standard library.
+  * `unwrap` will return the value in an `Option`, or panic. `expect` is similar but takes an error message.
+    * You can panic on None, but you can't "accidentally" forget to check for None.
+    * It's common to `unwrap`/`expect` all over the place when hacking something together, but production code typically handles `None` in a nicer fashion.
+  * The niche optimization means that `Option<T>` often has the same size in memory as `T`.
+
+</details>
diff --git a/src/std-types/result.md b/src/std-types/result.md
new file mode 100644
index 00000000..f6f19f89
--- /dev/null
+++ b/src/std-types/result.md
@@ -0,0 +1,43 @@
+---
+minutes: 10
+---
+
+# Result
+
+`Result` is similar to `Option`, but indicates the success or failure of an
+operation, each with a different type. This is similar to the `Res` defined
+in the expression exercise, but generic: `Result<T, E>` where `T` is used in
+the `Ok` variant and `E` appears in the `Err` variant.
+
+```rust,editable
+use std::fs::File;
+use std::io::Read;
+
+fn main() {
+    let file: Result<File, std::io::Error> = File::open("diary.txt");
+    match file {
+        Ok(mut file) => {
+            let mut contents = String::new();
+            if let Ok(bytes) = file.read_to_string(&mut contents) {
+                println!("Dear diary: {contents} ({bytes} bytes)");
+            } else {
+                println!("Could not read file content");
+            }
+        },
+        Err(err) => {
+            println!("The diary could not be opened: {err}");
+        }
+    }
+}
+```
+
+<details>
+
+  * As with `Option`, the successful value sits inside of `Result`, forcing the developer to
+    explicitly extract it. This encourages error checking. In the case where an error should never happen,
+    `unwrap()` or `expect()` can be called, and this is a signal of the developer intent too.
+  * `Result` documentation is a recommended read. Not during the course, but it is worth mentioning.
+    It contains a lot of convenience methods and functions that help functional-style programming.
+* `Result` is the standard type to implement error handling as we will see on Day 3.
+
+</details>
diff --git a/src/std-types/solution.md b/src/std-types/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/std-types/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/std-types/std.md b/src/std-types/std.md
new file mode 100644
index 00000000..872d652d
--- /dev/null
+++ b/src/std-types/std.md
@@ -0,0 +1,15 @@
+---
+minutes: 3
+---
+
+# Standard Library
+
+Rust comes with a standard library which helps establish a set of common types
+used by Rust libraries and programs. This way, two libraries can work together
+smoothly because they both use the same `String` type.
+
+In fact, Rust contains several layers of the Standard Library: `core`, `alloc` and `std`.
+* `core` includes the most basic types and functions that don't depend on `libc`, allocator or
+  even the presence of an operating system.
+* `alloc` includes types which require a global heap allocator, such as `Vec`, `Box` and `Arc`.
+* Embedded Rust applications often only use `core`, and sometimes `alloc`.
diff --git a/src/std/string.md b/src/std-types/string.md
similarity index 92%
rename from src/std/string.md
rename to src/std-types/string.md
index 291e1d5d..ae06546c 100644
--- a/src/std/string.md
+++ b/src/std-types/string.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # String
 
 [`String`][1] is the standard heap-allocated growable UTF-8 string buffer:
@@ -30,8 +34,9 @@ fn main() {
 * `String::new` returns a new empty string, use `String::with_capacity` when you know how much data you want to push to the string.
 * `String::len` returns the size of the `String` in bytes (which can be different from its length in characters).
 * `String::chars` returns an iterator over the actual characters. Note that a `char` can be different from what a human will consider a "character" due to [grapheme clusters](https://docs.rs/unicode-segmentation/latest/unicode_segmentation/struct.Graphemes.html).
-*  When people refer to strings they could either be talking about `&str` or `String`.  
+*  When people refer to strings they could either be talking about `&str` or `String`.
 * When a type implements `Deref<Target = T>`, the compiler will let you transparently call methods from `T`.
+    * We haven't discussed the `Deref` trait yet, so at this point this mostly explains the structure of the sidebar in the documentation.
     * `String` implements `Deref<Target = str>` which transparently gives it access to `str`'s methods.
     * Write and compare `let s3 = s1.deref();` and  `let s3 = &*s1;`.
 * `String` is implemented as a wrapper around a vector of bytes, many of the operations you see supported on vectors are also supported on `String`, but with some extra guarantees.
diff --git a/src/std/vec.md b/src/std-types/vec.md
similarity index 89%
rename from src/std/vec.md
rename to src/std-types/vec.md
index 9ce78157..f128119e 100644
--- a/src/std/vec.md
+++ b/src/std-types/vec.md
@@ -1,3 +1,7 @@
+---
+minutes: 10
+---
+
 # `Vec`
 
 [`Vec`][1] is the standard resizable heap-allocated buffer:
@@ -43,7 +47,7 @@ methods on a `Vec`.
   elements to the vector.
 * To index the vector you use `[` `]`, but they will panic if out of bounds. Alternatively, using
   `get` will return an `Option`. The `pop` function will remove the last element.
-* Show iterating over a vector and mutating the value:
-  `for e in &mut v { *e += 50; }`
+* Slices are covered on day 3. For now, students only need to know that a value
+  of type `Vec` gives access to all of the documented read-only slice methods, too.
 
 </details>
diff --git a/src/std.md b/src/std.md
deleted file mode 100644
index 38329713..00000000
--- a/src/std.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Standard Library
-
-Rust comes with a standard library which helps establish a set of common types
-used by Rust libraries and programs. This way, two libraries can work together
-smoothly because they both use the same `String` type.
-
-The common vocabulary types include:
-
-* [`Option` and `Result`](std/option-result.md) types: used for optional values
-  and [error handling](error-handling.md).
-
-* [`String`](std/string.md): the default string type used for owned data.
-
-* [`Vec`](std/vec.md): a standard extensible vector.
-
-* [`HashMap`](std/hashmap.md): a hash map type with a configurable hashing
-  algorithm.
-
-* [`Box`](std/box.md): an owned pointer for heap-allocated data.
-
-* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated data.
-
-<details>
-  
-  * In fact, Rust contains several layers of the Standard Library: `core`, `alloc` and `std`. 
-  * `core` includes the most basic types and functions that don't depend on `libc`, allocator or
-    even the presence of an operating system. 
-  * `alloc` includes types which require a global heap allocator, such as `Vec`, `Box` and `Arc`.
-  * Embedded Rust applications often only use `core`, and sometimes `alloc`.
-
-</details>
diff --git a/src/std/box-niche.md b/src/std/box-niche.md
deleted file mode 100644
index d0fbfb1c..00000000
--- a/src/std/box-niche.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# Niche Optimization
-
-```rust,editable
-#[derive(Debug)]
-enum List<T> {
-    Cons(T, Box<List<T>>),
-    Nil,
-}
-
-fn main() {
-    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
-    println!("{list:?}");
-}
-```
-
-A `Box` cannot be empty, so the pointer is always valid and non-`null`. This
-allows the compiler to optimize the memory layout:
-
-```bob
- Stack                           Heap
-.- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - -.
-:                         :     :                                             :
-:    list                 :     :                                             :
-:   +----+----+           :     :    +----+----+    +----+------+             :
-:   | 1  | o--+-----------+-----+--->| 2  | o--+--->| // | null |             :
-:   +----+----+           :     :    +----+----+    +----+------+             :
-:                         :     :                                             :
-:                         :     :                                             :
-`- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - -'
-```
diff --git a/src/std/box-recursive.md b/src/std/box-recursive.md
deleted file mode 100644
index bc7273ef..00000000
--- a/src/std/box-recursive.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Box with Recursive Data Structures
-
-Recursive data types or data types with dynamic sizes need to use a `Box`:
-
-```rust,editable
-#[derive(Debug)]
-enum List<T> {
-    Cons(T, Box<List<T>>),
-    Nil,
-}
-
-fn main() {
-    let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
-    println!("{list:?}");
-}
-```
-
-```bob
- Stack                           Heap
-.- - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - - - -.
-:                         :     :                                               :
-:    list                 :     :                                               :
-:   +------+----+----+    :     :    +------+----+----+    +------+----+----+   :
-:   | Cons | 1  | o--+----+-----+--->| Cons | 2  | o--+--->| Nil  | // | // |   :
-:   +------+----+----+    :     :    +------+----+----+    +------+----+----+   :
-:                         :     :                                               :
-:                         :     :                                               :
-'- - - - - - - - - - - - -'     '- - - - - - - - - - - - - - - - - - - - - - - -'
-```
-
-<details>
-
-* If `Box` was not used and we attempted to embed a `List` directly into the `List`,
-the compiler would not compute a fixed size of the struct in memory (`List` would be of infinite size).
-
-* `Box` solves this problem as it has the same size as a regular pointer and just points at the next
-element of the `List` in the heap.
-
-* Remove the `Box` in the List definition and show the compiler error. "Recursive with indirection" is a hint you might want to use a Box or reference of some kind, instead of storing a value directly.   
-    
-</details>
diff --git a/src/std/box.md b/src/std/box.md
deleted file mode 100644
index cbd187c6..00000000
--- a/src/std/box.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# `Box`
-
-[`Box`][1] is an owned pointer to data on the heap:
-
-```rust,editable
-fn main() {
-    let five = Box::new(5);
-    println!("five: {}", *five);
-}
-```
-
-
-```bob
- Stack                     Heap
-.- - - - - - -.     .- - - - - - -.
-:             :     :             :
-:    five     :     :             :
-:   +-----+   :     :   +-----+   :
-:   | o---|---+-----+-->|  5  |   :
-:   +-----+   :     :   +-----+   :
-:             :     :             :
-:             :     :             :
-`- - - - - - -'     `- - - - - - -'
-```
-
-`Box<T>` implements `Deref<Target = T>`, which means that you can [call methods
-from `T` directly on a `Box<T>`][2].
-
-[1]: https://doc.rust-lang.org/std/boxed/struct.Box.html
-[2]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion
-
-<details>
-
-* `Box` is like `std::unique_ptr` in C++, except that it's guaranteed to be not null. 
-* In the above example, you can even leave out the `*` in the `println!` statement thanks to `Deref`. 
-* A `Box` can be useful when you:
-   * have a type whose size that can't be known at compile time, but the Rust compiler wants to know an exact size.
-   * want to transfer ownership of a large amount of data. To avoid copying large amounts of data on the stack, instead store the data on the heap in a `Box` so only the pointer is moved.
-</details>
diff --git a/src/std/option-result.md b/src/std/option-result.md
deleted file mode 100644
index e29265fa..00000000
--- a/src/std/option-result.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# `Option` and `Result`
-
-The types represent optional data:
-
-```rust,editable
-fn main() {
-    let numbers = vec![10, 20, 30];
-    let first: Option<&i8> = numbers.first();
-    println!("first: {first:?}");
-
-    let arr: Result<[i8; 3], Vec<i8>> = numbers.try_into();
-    println!("arr: {arr:?}");
-}
-```
-
-<details>
-
-* `Option` and `Result` are widely used not just in the standard library.
-* `Option<&T>` has zero space overhead compared to `&T`.
-* `Result` is the standard type to implement error handling as we will see on Day 3.
-* `try_into` attempts to convert the vector into a fixed-sized array. This can fail:
-  * If the vector has the right size, `Result::Ok` is returned with the array.
-  * Otherwise, `Result::Err` is returned with the original vector.
-
-</details>
diff --git a/src/structs/field-shorthand.md b/src/structs/field-shorthand.md
deleted file mode 100644
index 4b5ff253..00000000
--- a/src/structs/field-shorthand.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Field Shorthand Syntax
-
-If you already have variables with the right names, then you can create the
-struct using a shorthand:
-
-```rust,editable
-#[derive(Debug)]
-struct Person {
-    name: String,
-    age: u8,
-}
-
-impl Person {
-    fn new(name: String, age: u8) -> Person {
-        Person { name, age }
-    }
-}
-
-fn main() {
-    let peter = Person::new(String::from("Peter"), 27);
-    println!("{peter:?}");
-}
-```
-
-<details>
-
-*  The `new` function could be written using `Self` as a type, as it is interchangeable with the struct type name
-
-     ```rust,editable
-     #[derive(Debug)]
-     struct Person {
-         name: String,
-         age: u8,
-     }
-     impl Person {
-         fn new(name: String, age: u8) -> Self {
-             Self { name, age }
-         }
-     }
-     ```    
-* Implement the `Default` trait for the struct. Define some fields and use the default values for the other fields.
-
-     ```rust,editable
-     #[derive(Debug)]
-     struct Person {
-         name: String,
-         age: u8,
-     }
-     impl Default for Person {
-         fn default() -> Person {
-             Person {
-                 name: "Bot".to_string(),
-                 age: 0,
-             }
-         }
-     }
-     fn create_default() {
-         let tmp = Person {
-             ..Person::default()
-         };
-         let tmp = Person {
-             name: "Sam".to_string(),
-             ..Person::default()
-         };
-     }
-     ```
-
-* Methods are defined in the `impl` block.
-* Use struct update syntax to define a new structure using `peter`. Note that the variable `peter` will no longer be accessible afterwards.
-* Use `{:#?}` when printing structs to request the `Debug` representation.
-
-</details>
diff --git a/src/testing.md b/src/testing.md
index 16f67935..8e801858 100644
--- a/src/testing.md
+++ b/src/testing.md
@@ -1,7 +1,3 @@
 # Testing
 
-Rust and Cargo come with a simple unit test framework:
-
-* Unit tests are supported throughout your code.
-
-* Integration tests are supported via the `tests/` directory.
+{{%segment outline}}
diff --git a/src/testing/Cargo.toml b/src/testing/Cargo.toml
new file mode 100644
index 00000000..10005b57
--- /dev/null
+++ b/src/testing/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "testing"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "luhn"
+path = "exercise.rs"
+
diff --git a/src/exercises/day-1/luhn.md b/src/testing/exercise.md
similarity index 61%
rename from src/exercises/day-1/luhn.md
rename to src/testing/exercise.md
index d4e7f15a..ee843aaa 100644
--- a/src/exercises/day-1/luhn.md
+++ b/src/testing/exercise.md
@@ -1,3 +1,9 @@
+---
+minutes: 30
+---
+
+# Exercise: Luhn Algorithm
+
 # Luhn Algorithm
 
 The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used to
@@ -16,22 +22,16 @@ following to validate the credit card number:
 
 * The credit card number is valid if the sum ends with `0`.
 
-Copy the code below to <https://play.rust-lang.org/> and implement the function.
-
-Try to solve the problem the "simple" way first, using `for` loops and integers.
-Then, revisit the solution and try to implement it with iterators.
+The provided code provides a buggy implementation of the luhn algorithm, along
+with two basic unit tests that confirm that most the algorithm is implemented
+correctly.
 
+Copy the code below to <https://play.rust-lang.org/> and write additional tests
+to uncover bugs in the provided implementation, fixing any bugs you find.
 
 ```rust
-// TODO: remove this when you're done with your implementation.
-#![allow(unused_variables, dead_code)]
+{{#include exercise.rs:luhn}}
 
-{{#include luhn.rs:luhn}}
-    unimplemented!()
+{{#include exercise.rs:unit-tests}}
 }
-
-{{#include luhn.rs:unit-tests}}
-
-#[allow(dead_code)]
-fn main() {}
 ```
diff --git a/src/testing/exercise.rs b/src/testing/exercise.rs
new file mode 100644
index 00000000..24d92505
--- /dev/null
+++ b/src/testing/exercise.rs
@@ -0,0 +1,126 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ANCHOR: solution
+// This is the buggy version that appears in the problem.
+#[cfg(never)]
+// ANCHOR: luhn
+pub fn luhn(cc_number: &str) -> bool {
+    let mut sum = 0;
+    let mut double = false;
+
+    for c in cc_number.chars().rev() {
+        if let Some(digit) = c.to_digit(10) {
+            if double {
+                let double_digit = digit * 2;
+                sum += if double_digit > 9 {
+                    double_digit - 9
+                } else {
+                    double_digit
+                };
+            } else {
+                sum += digit;
+            }
+            double = !double;
+        } else {
+            continue;
+        }
+    }
+
+    sum % 10 == 0
+}
+// ANCHOR_END: luhn
+
+// This is the solution and passes all of the tests below.
+pub fn luhn(cc_number: &str) -> bool {
+    let mut sum = 0;
+    let mut double = false;
+    let mut digits = 0;
+
+    for c in cc_number.chars().rev() {
+        if let Some(digit) = c.to_digit(10) {
+            digits += 1;
+            if double {
+                let double_digit = digit * 2;
+                sum += if double_digit > 9 {
+                    double_digit - 9
+                } else {
+                    double_digit
+                };
+            } else {
+                sum += digit;
+            }
+            double = !double;
+        } else if c.is_whitespace() {
+            continue;
+        } else {
+            return false;
+        }
+    }
+
+    digits >= 2 && sum % 10 == 0
+}
+
+fn main() {
+    let cc_number = "1234 5678 1234 5670";
+    println!(
+        "Is {cc_number} a valid credit card number? {}",
+        if luhn(cc_number) { "yes" } else { "no" }
+    );
+}
+
+// ANCHOR: unit-tests
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_valid_cc_number() {
+        assert!(luhn("4263 9826 4026 9299"));
+        assert!(luhn("4539 3195 0343 6467"));
+        assert!(luhn("7992 7398 713"));
+    }
+
+    #[test]
+    fn test_invalid_cc_number() {
+        assert!(!luhn("4223 9826 4026 9299"));
+        assert!(!luhn("4539 3195 0343 6476"));
+        assert!(!luhn("8273 1232 7352 0569"));
+    }
+    // ANCHOR_END: unit-tests
+
+    #[test]
+    fn test_non_digit_cc_number() {
+        assert!(!luhn("foo"));
+        assert!(!luhn("foo 0 0"));
+    }
+
+    #[test]
+    fn test_empty_cc_number() {
+        assert!(!luhn(""));
+        assert!(!luhn(" "));
+        assert!(!luhn("  "));
+        assert!(!luhn("    "));
+    }
+
+    #[test]
+    fn test_single_digit_cc_number() {
+        assert!(!luhn("0"));
+    }
+
+    #[test]
+    fn test_two_digit_cc_number() {
+        assert!(luhn(" 0 0 "));
+    }
+}
diff --git a/src/testing/integration-tests.md b/src/testing/integration-tests.md
deleted file mode 100644
index 1a45ef17..00000000
--- a/src/testing/integration-tests.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# Integration Tests
-
-If you want to test your library as a client, use an integration test.
-
-Create a `.rs` file under `tests/`:
-
-```rust,ignore
-use my_library::init;
-
-#[test]
-fn test_init() {
-    assert!(init().is_ok());
-}
-```
-
-These tests only have access to the public API of your crate.
diff --git a/src/testing/lints.md b/src/testing/lints.md
new file mode 100644
index 00000000..f55af925
--- /dev/null
+++ b/src/testing/lints.md
@@ -0,0 +1,35 @@
+---
+minutes: 5
+---
+
+# Compiler Lints and Clippy
+
+The Rust compiler produces fantastic error messages, as well as helpful
+built-in lints. [Clippy](https://doc.rust-lang.org/clippy/) provides even more
+lints, organized into groups that can be enabled per-project.
+
+```rust,editable,should_panic
+#[deny(clippy::cast_possible_truncation)]
+fn main() {
+    let x = 3;
+    while (x < 70000) {
+        x *= 2;
+    }
+    println!("X probably fits in a u16, right? {}", x as u16);
+}
+```
+
+<details>
+
+Run the code sample and examine the error message. There are also lints visible
+here, but those will not be shown once the code compiles. Switch to the
+Playground site to show those lints.
+
+After resolving the lints, run `clippy` on the playground site to show clippy
+warnings. Clippy has extensive documentation of its lints, and adds new lints
+(including default-deny lints) all the time.
+
+Note that errors or warnings with `help: ...` can be fixed with `cargo fix` or
+via your editor.
+
+</details>
diff --git a/src/testing/doc-tests.md b/src/testing/other.md
similarity index 66%
rename from src/testing/doc-tests.md
rename to src/testing/other.md
index 4b1a85ed..e62b24b7 100644
--- a/src/testing/doc-tests.md
+++ b/src/testing/other.md
@@ -1,4 +1,28 @@
-# Documentation Tests
+---
+minutes: 10
+---
+
+# Other Types of Tests
+
+## Integration Tests
+
+If you want to test your library as a client, use an integration test.
+
+Create a `.rs` file under `tests/`:
+
+```rust,ignore
+// tests/my_library.rs
+use my_library::init;
+
+#[test]
+fn test_init() {
+    assert!(init().is_ok());
+}
+```
+
+These tests only have access to the public API of your crate.
+
+## Documentation Tests
 
 Rust has built-in support for documentation tests:
 
diff --git a/src/testing/solution.md b/src/testing/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/testing/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/testing/test-modules.md b/src/testing/test-modules.md
deleted file mode 100644
index a89bd098..00000000
--- a/src/testing/test-modules.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Test Modules
-
-Unit tests are often put in a nested module (run tests on the
-[Playground](https://play.rust-lang.org/)):
-
-```rust,editable
-fn helper(a: &str, b: &str) -> String {
-    format!("{a} {b}")
-}
-
-pub fn main() {
-    println!("{}", helper("Hello", "World"));
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_helper() {
-        assert_eq!(helper("foo", "bar"), "foo bar");
-    }
-}
-```
-
-* This lets you unit test private helpers.
-* The `#[cfg(test)]` attribute is only active when you run `cargo test`.
diff --git a/src/testing/unit-tests.md b/src/testing/unit-tests.md
index 130899ce..766491f9 100644
--- a/src/testing/unit-tests.md
+++ b/src/testing/unit-tests.md
@@ -1,6 +1,18 @@
+---
+minutes: 5
+---
+
 # Unit Tests
 
-Mark unit tests with `#[test]`:
+Rust and Cargo come with a simple unit test framework:
+
+* Unit tests are supported throughout your code.
+
+* Integration tests are supported via the `tests/` directory.
+
+Tests are marked with `#[test]`.  Unit tests are often put in a nested `tests`
+module, using `#[cfg(test)]` to conditionally compile them only when building
+tests.
 
 ```rust,editable,ignore
 fn first_word(text: &str) -> &str {
@@ -10,20 +22,32 @@ fn first_word(text: &str) -> &str {
     }
 }
 
-#[test]
-fn test_empty() {
-    assert_eq!(first_word(""), "");
-}
+#[cfg(test)]
+mod test {
+    use super::*;
 
-#[test]
-fn test_single_word() {
-    assert_eq!(first_word("Hello"), "Hello");
-}
+    #[test]
+    fn test_empty() {
+        assert_eq!(first_word(""), "");
+    }
 
-#[test]
-fn test_multiple_words() {
-    assert_eq!(first_word("Hello World"), "Hello");
+    #[test]
+    fn test_single_word() {
+        assert_eq!(first_word("Hello"), "Hello");
+    }
+
+    #[test]
+    fn test_multiple_words() {
+        assert_eq!(first_word("Hello World"), "Hello");
+    }
 }
 ```
 
-Use `cargo test` to find and run the unit tests.
+* This lets you unit test private helpers.
+* The `#[cfg(test)]` attribute is only active when you run `cargo test`.
+
+<details>
+
+Run the tests in the playground in order to show their results.
+
+</details>
diff --git a/src/testing/useful-crates.md b/src/testing/useful-crates.md
index 7435643d..91a6847c 100644
--- a/src/testing/useful-crates.md
+++ b/src/testing/useful-crates.md
@@ -1,4 +1,8 @@
-## Useful crates for writing tests
+---
+minutes: 3
+---
+
+# Useful Crates
 
 Rust comes with only basic support for writing tests.
 
diff --git a/src/traits.md b/src/traits.md
deleted file mode 100644
index 7757779a..00000000
--- a/src/traits.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# Traits
-
-Rust lets you abstract over types with traits. They're similar to interfaces:
-
-```rust,editable
-struct Dog { name: String, age: i8 }
-struct Cat { lives: i8 } // No name needed, cats won't respond anyway.
-
-trait Pet {
-    fn talk(&self) -> String;
-}
-
-impl Pet for Dog {
-    fn talk(&self) -> String { format!("Woof, my name is {}!", self.name) }
-}
-
-impl Pet for Cat {
-    fn talk(&self) -> String { String::from("Miau!") }
-}
-
-fn greet<P: Pet>(pet: &P) {
-    println!("Oh you're a cutie! What's your name? {}", pet.talk());
-}
-
-fn main() {
-    let captain_floof = Cat { lives: 9 };
-    let fido = Dog { name: String::from("Fido"), age: 5 };
-
-    greet(&captain_floof);
-    greet(&fido);
-}
-```
diff --git a/src/traits/default-methods.md b/src/traits/default-methods.md
deleted file mode 100644
index d48a3140..00000000
--- a/src/traits/default-methods.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Default Methods
-
-Traits can implement behavior in terms of other trait methods:
-
-```rust,editable
-trait Equals {
-    fn equals(&self, other: &Self) -> bool;
-    fn not_equals(&self, other: &Self) -> bool {
-        !self.equals(other)
-    }
-}
-
-#[derive(Debug)]
-struct Centimeter(i16);
-
-impl Equals for Centimeter {
-    fn equals(&self, other: &Centimeter) -> bool {
-        self.0 == other.0
-    }
-}
-
-fn main() {
-    let a = Centimeter(10);
-    let b = Centimeter(20);
-    println!("{a:?} equals {b:?}: {}", a.equals(&b));
-    println!("{a:?} not_equals {b:?}: {}", a.not_equals(&b));
-}
-```
-
-<details>
-
-* Traits may specify pre-implemented (default) methods and methods that users are required to
-  implement themselves. Methods with default implementations can rely on required methods.
-
-* Move method `not_equals` to a new trait `NotEquals`.
-
-* Make `Equals` a super trait for `NotEquals`.
-    ```rust,editable,compile_fail
-    trait NotEquals: Equals {
-        fn not_equals(&self, other: &Self) -> bool {
-            !self.equals(other)
-        }
-    }
-    ```
-
-* Provide a blanket implementation of `NotEquals` for `Equals`.
-    ```rust,editable,compile_fail
-    trait NotEquals {
-        fn not_equals(&self, other: &Self) -> bool;
-    }
-
-    impl<T> NotEquals for T where T: Equals {
-        fn not_equals(&self, other: &Self) -> bool {
-            !self.equals(other)
-        }
-    }
-    ```
-  * With the blanket implementation, you no longer need `Equals` as a super trait for `NotEqual`.
-    
-</details>
diff --git a/src/traits/deriving-traits.md b/src/traits/deriving-traits.md
deleted file mode 100644
index 843f6009..00000000
--- a/src/traits/deriving-traits.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Deriving Traits
-
-Rust derive macros work by automatically generating code that implements the specified traits for a data structure.
-
-You can let the compiler derive a number of traits as follows:
-
-```rust,editable
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-struct Player {
-    name: String,
-    strength: u8,
-    hit_points: u8,
-}
-
-fn main() {
-    let p1 = Player::default();
-    let p2 = p1.clone();
-    println!("Is {:?}\nequal to {:?}?\nThe answer is {}!", &p1, &p2,
-             if p1 == p2 { "yes" } else { "no" });
-}
-```
diff --git a/src/traits/from-iterator.md b/src/traits/from-iterator.md
deleted file mode 100644
index 2eb89330..00000000
--- a/src/traits/from-iterator.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# FromIterator
-
-[`FromIterator`][1] lets you build a collection from an [`Iterator`][2].
-
-```rust,editable
-fn main() {
-    let primes = vec![2, 3, 5, 7];
-    let prime_squares = primes
-        .into_iter()
-        .map(|prime| prime * prime)
-        .collect::<Vec<_>>();
-    println!("prime_squares: {prime_squares:?}");
-}
-```
-
-<details>
-
-`Iterator` implements
-`fn collect<B>(self) -> B
-where
-    B: FromIterator<Self::Item>,
-    Self: Sized`
-
-There are also implementations which let you do cool things like convert an
-`Iterator<Item = Result<V, E>>` into a `Result<Vec<V>, E>`.
-
-</details>
-
-[1]: https://doc.rust-lang.org/std/iter/trait.FromIterator.html
-[2]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
diff --git a/src/traits/important-traits.md b/src/traits/important-traits.md
deleted file mode 100644
index b7ce7362..00000000
--- a/src/traits/important-traits.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Important Traits
-
-We will now look at some of the most common traits of the Rust standard library:
-
-* [`Iterator`][1] and [`IntoIterator`][2] used in `for` loops,
-* [`From`][3] and [`Into`][4] used to convert values,
-* [`Read`][5] and [`Write`][6] used for IO,
-* [`Add`][7], [`Mul`][8], ... used for operator overloading, and
-* [`Drop`][9] used for defining destructors.
-* [`Default`][10] used to construct a default instance of a type.
-
-[1]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
-[2]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html
-[3]: https://doc.rust-lang.org/std/convert/trait.From.html
-[4]: https://doc.rust-lang.org/std/convert/trait.Into.html
-[5]: https://doc.rust-lang.org/std/io/trait.Read.html
-[6]: https://doc.rust-lang.org/std/io/trait.Write.html
-[7]: https://doc.rust-lang.org/std/ops/trait.Add.html
-[8]: https://doc.rust-lang.org/std/ops/trait.Mul.html
-[9]: https://doc.rust-lang.org/std/ops/trait.Drop.html
-[10]: https://doc.rust-lang.org/std/default/trait.Default.html
diff --git a/src/traits/trait-bounds.md b/src/traits/trait-bounds.md
deleted file mode 100644
index 9e5f5eb6..00000000
--- a/src/traits/trait-bounds.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# Trait Bounds
-
-When working with generics, you often want to require the types to implement
-some trait, so that you can call this trait's methods.
-
-You can do this with `T: Trait` or `impl Trait`:
-
-```rust,editable
-fn duplicate<T: Clone>(a: T) -> (T, T) {
-    (a.clone(), a.clone())
-}
-
-// Syntactic sugar for:
-//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {
-fn add_42_millions(x: impl Into<i32>) -> i32 {
-    x.into() + 42_000_000
-}
-
-// struct NotClonable;
-
-fn main() {
-    let foo = String::from("foo");
-    let pair = duplicate(foo);
-    println!("{pair:?}");
-
-    let many = add_42_millions(42_i8);
-    println!("{many}");
-    let many_more = add_42_millions(10_000_000);
-    println!("{many_more}");
-}
-```
-
-<details>
-
-Show a `where` clause, students will encounter it when reading code.
-    
-```rust,ignore
-fn duplicate<T>(a: T) -> (T, T)
-where
-    T: Clone,
-{
-    (a.clone(), a.clone())
-}
-```
-
-* It declutters the function signature if you have many parameters.
-* It has additional features making it more powerful.
-    * If someone asks, the extra feature is that the type on the left of ":" can be arbitrary, like `Option<T>`.
-    
-</details>
diff --git a/src/tuples-and-arrays.md b/src/tuples-and-arrays.md
new file mode 100644
index 00000000..675851ba
--- /dev/null
+++ b/src/tuples-and-arrays.md
@@ -0,0 +1,3 @@
+# Tuples and Arrays
+
+{{%segment outline}}
diff --git a/src/tuples-and-arrays/Cargo.toml b/src/tuples-and-arrays/Cargo.toml
new file mode 100644
index 00000000..f61a7b1d
--- /dev/null
+++ b/src/tuples-and-arrays/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "tuples-and-arrays"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "transpose"
+path = "exercise.rs"
+
diff --git a/src/tuples-and-arrays/destructuring.md b/src/tuples-and-arrays/destructuring.md
new file mode 100644
index 00000000..7ba67f61
--- /dev/null
+++ b/src/tuples-and-arrays/destructuring.md
@@ -0,0 +1,44 @@
+---
+minutes: 5
+---
+
+# Destructuring
+
+Destructuring is a way of extracting data from a data structure by writing a
+pattern that is matched up to the data structure, binding variables to
+subcomponents of the data structure.
+
+You can destructure tuples and arrays by matching on their elements:
+
+## Tuples
+
+```rust,editable
+fn main() {
+    describe_point((1, 0));
+}
+
+fn describe_point(point: (i32, i32)) {
+    match point {
+        (0, _) => println!("on Y axis"),
+        (_, 0) => println!("on X axis"),
+        (x, _) if x < 0 => println!("left of Y axis"),
+        (_, y) if y < 0 => println!("below X axis"),
+        _ => println!("first quadrant"),
+    }
+}
+```
+
+## Arrays
+
+```rust,editable
+{{#include ../../third_party/rust-by-example/destructuring-arrays.rs}}
+```
+
+<details>
+
+* Create a new array pattern using `_` to represent an element.
+* Add more values to the array.
+* Point out that how `..` will expand to account for different number of elements.
+* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`
+
+</details>
diff --git a/src/tuples-and-arrays/exercise.md b/src/tuples-and-arrays/exercise.md
new file mode 100644
index 00000000..036f5758
--- /dev/null
+++ b/src/tuples-and-arrays/exercise.md
@@ -0,0 +1,47 @@
+---
+minutes: 30
+---
+
+# Exercise: Nested Arrays
+
+Arrays can contain other arrays:
+
+```rust
+let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+```
+
+What is the type of this variable?
+
+Use an array such as the above to write a function `transpose` which will
+transpose a matrix (turn rows into columns):
+
+<!-- mdbook-xgettext: skip -->
+```bob
+           ⎛⎡1 2 3⎤⎞      ⎡1 4 7⎤
+"transpose"⎜⎢4 5 6⎥⎟  "=="⎢2 5 8⎥
+           ⎝⎣7 8 9⎦⎠      ⎣3 6 9⎦
+```
+
+Hard-code both functions to operate on 3 × 3 matrices.
+
+Copy the code below to <https://play.rust-lang.org/> and implement the
+functions:
+
+```rust,should_panic
+// TODO: remove this when you're done with your implementation.
+#![allow(unused_variables, dead_code)]
+
+{{#include exercise.rs:transpose}}
+    unimplemented!()
+}
+
+{{#include exercise.rs:main}}
+```
+
+<details>
+
+The `transpose` function takes its argument by value, but we haven't covered
+ownership yet. Try printing a matrix after it has been transposed, to show the
+"value has been moved" error, as a preview of ownership and move semantics.
+
+</details>
diff --git a/src/exercises/day-1/for-loops.rs b/src/tuples-and-arrays/exercise.rs
similarity index 83%
rename from src/exercises/day-1/for-loops.rs
rename to src/tuples-and-arrays/exercise.rs
index e2d9663d..43291f5f 100644
--- a/src/exercises/day-1/for-loops.rs
+++ b/src/tuples-and-arrays/exercise.rs
@@ -22,15 +22,7 @@ fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
             result[j][i] = matrix[i][j];
         }
     }
-    return result;
-}
-
-// ANCHOR: pretty_print
-fn pretty_print(matrix: &[[i32; 3]; 3]) {
-    // ANCHOR_END: pretty_print
-    for row in matrix {
-        println!("{row:?}");
-    }
+    result
 }
 
 // ANCHOR: tests
@@ -61,10 +53,8 @@ fn main() {
         [301, 302, 303],
     ];
 
-    println!("matrix:");
-    pretty_print(&matrix);
-
+    println!("matrix: {:#?}", matrix);
     let transposed = transpose(matrix);
-    println!("transposed:");
-    pretty_print(&transposed);
+    println!("transposed: {:#?}", transposed);
 }
+// ANCHOR_END: main
diff --git a/src/tuples-and-arrays/iteration.md b/src/tuples-and-arrays/iteration.md
new file mode 100644
index 00000000..2df452a1
--- /dev/null
+++ b/src/tuples-and-arrays/iteration.md
@@ -0,0 +1,28 @@
+---
+minutes: 3
+---
+
+# Array Iteration
+
+The `for` statement supports iterating over arrays (but not tuples).
+
+```rust,editable
+fn main() {
+    let primes = [2, 3, 5, 7, 11, 13, 17, 19];
+    for prime in primes {
+        for i in 2..prime {
+            assert_ne!(prime % i, 0); 
+        }   
+    }   
+}
+```
+
+<details>
+
+This functionality uses the `IntoIterator` trait, but we haven't covered that yet.
+
+The `assert_ne!` macro is new here. There are also `assert_eq!` and `assert!`
+macros. These are always checked while, debug-only variants like
+`debug_assert!` compile to nothing in release builds.
+
+</details>
diff --git a/src/tuples-and-arrays/match.md b/src/tuples-and-arrays/match.md
new file mode 100644
index 00000000..7c296a3e
--- /dev/null
+++ b/src/tuples-and-arrays/match.md
@@ -0,0 +1,50 @@
+---
+minutes: 10
+---
+
+# Pattern Matching
+
+The `match` keyword lets you match a value against one or more _patterns_. The
+comparisons are done from top to bottom and the first match wins.
+
+The patterns can be simple values, similarly to `switch` in C and C++:
+
+```rust,editable
+fn main() {
+    let input = 'x';
+    match input {
+        'q'                       => println!("Quitting"),
+        'a' | 's' | 'w' | 'd'     => println!("Moving around"),
+        '0'..='9'                 => println!("Number input"),
+        key if key.is_lowercase() => println!("Lowercase: {key}"),
+        _                         => println!("Something else"),
+    }
+}
+```
+
+The `_` pattern is a wildcard pattern which matches any value. The expressions
+_must_ be irrefutable, meaning that it covers every possibility, so `_` is
+often used as the final catch-all case.
+
+Match can be used as an expression. Just like like `if`, each match arm must have the same type. The type is the last
+expression of the block, if any. In the example above, the type is `()`.
+
+A variable in the pattern (`key` in this example) will create a binding that
+can be used within the match arm.
+
+A match guard causes the arm to match only if the condition is true.
+
+<details>
+
+Key Points:
+* You might point out how some specific characters are being used when in a pattern
+  * `|` as an `or`
+  * `..` can expand as much as it needs to be
+  * `1..=5` represents an inclusive range
+  * `_` is a wild card
+
+* Match guards as a separate syntax feature are important and necessary when we wish to concisely express more complex ideas than patterns alone would allow.
+* They are not the same as separate `if` expression inside of the match arm. An `if` expression inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` condition inside of that block won't result in other arms
+of the original `match` expression being considered.
+* The condition defined in the guard applies to every expression in a pattern with an `|`.
+</details>
diff --git a/src/tuples-and-arrays/solution.md b/src/tuples-and-arrays/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/tuples-and-arrays/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/basic-syntax/compound-types.md b/src/tuples-and-arrays/tuples-and-arrays.md
similarity index 78%
rename from src/basic-syntax/compound-types.md
rename to src/tuples-and-arrays/tuples-and-arrays.md
index aab46a68..b047c42d 100644
--- a/src/basic-syntax/compound-types.md
+++ b/src/tuples-and-arrays/tuples-and-arrays.md
@@ -1,4 +1,12 @@
-# Compound Types
+---
+minutes: 10
+---
+
+# Tuples and Arrays
+
+Tuples and arrays are the first "compound" types we have seen. All elements of
+an array have the same type, while tuples can accommodate different types.
+Both types have a size fixed at compile time.
 
 |        | Types                         | Literals                          |
 |--------|-------------------------------|-----------------------------------|
@@ -35,7 +43,12 @@ Arrays:
 
 * A value of the array type `[T; N]` holds `N` (a compile-time constant) elements of the same type `T`.
   Note that the length of the array is *part of its type*, which means that `[u8; 3]` and
-  `[u8; 4]` are considered two different types.
+  `[u8; 4]` are considered two different types. Slices, which have a size determined at runtime,
+  are covered later.
+
+* Try accessing an out-of-bounds array element. Array accesses are checked at
+  runtime. Rust can usually optimize these checks away, and they can be avoided
+  using unsafe Rust.
 
 * We can use literals to assign values to arrays.
 
@@ -57,8 +70,8 @@ Tuples:
 * The empty tuple `()` is also known as the "unit type". It is both a type, and
   the only valid value of that type --- that is to say both the type and its value
   are expressed as `()`. It is used to indicate, for example, that a function or
-  expression has no return value, as we'll see in a future slide. 
-    * You can think of it as `void` that can be familiar to you from other 
+  expression has no return value, as we'll see in a future slide.
+    * You can think of it as `void` that can be familiar to you from other
       programming languages.
 
 </details>
diff --git a/src/types-and-values.md b/src/types-and-values.md
new file mode 100644
index 00000000..72ba0b11
--- /dev/null
+++ b/src/types-and-values.md
@@ -0,0 +1,3 @@
+# Types and Values
+
+{{%segment outline}}
diff --git a/src/types-and-values/Cargo.toml b/src/types-and-values/Cargo.toml
new file mode 100644
index 00000000..4603dd99
--- /dev/null
+++ b/src/types-and-values/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "types-and-values"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "fizzbuzz"
+path = "exercise.rs"
diff --git a/src/types-and-values/arithmetic.md b/src/types-and-values/arithmetic.md
new file mode 100644
index 00000000..294888bf
--- /dev/null
+++ b/src/types-and-values/arithmetic.md
@@ -0,0 +1,37 @@
+---
+minutes: 5
+---
+
+# Arithmetic
+
+```rust,editable
+fn interproduct(a: i32, b: i32, c: i32) -> i32 {
+    return a * b + b * c + c * a;
+}
+
+fn main() {
+    println!("result: {}", interproduct(120, 100, 248));
+}
+```
+
+<details>
+
+This is the first time we've seen a function other than `main`, but the meaning
+should be clear: it takes three integers, and returns an integer. Functions will
+be covered in more detail later.
+
+Arithmetic is very similar to other languages, with similar precedence.
+
+What about integer overflow? In C and C++ overflow of _signed_ integers is
+actually undefined, and might do different things on different platforms or
+compilers. In Rust, it's defined.
+
+Change the `i32`'s to `i16` to see an integer overflow, which panics (checked)
+in a debug build and wraps in a release build.  There are other options, such
+as overflowing, saturating, and carrying.  These are accessed with method
+syntax, e.g., `(a * b).saturating_add(b * c).saturating_add(c * a)`.
+
+In fact, the compiler will detect overflow of constant expressions, which is
+why the example requires a separate function.
+
+</details>
diff --git a/src/types-and-values/exercise.md b/src/types-and-values/exercise.md
new file mode 100644
index 00000000..fc5fd74e
--- /dev/null
+++ b/src/types-and-values/exercise.md
@@ -0,0 +1,26 @@
+---
+minutes: 30
+---
+
+# Exercise: Fibonacci
+
+The first and second Fibonacci numbers are both `1`.  For n>2, he n'th
+Fibonacci number is calculated recursively as the sum of the n-1'th and n-2'th
+Fibonacci numbers.
+
+Write a function `fib(n)` that calculates the n'th Fibonacci number.  When will
+this function panic?
+
+```rust,editable,should_panic
+{{#include exercise.rs:fib}}
+    if n <= 2 {
+        // The base case.
+        todo!("Implement this")
+    } else {
+        // The recursive case.
+        todo!("Implement this")
+    }
+}
+
+{{#include exercise.rs:main}}
+```
diff --git a/mdbook-course/src/lib.rs b/src/types-and-values/exercise.rs
similarity index 67%
rename from mdbook-course/src/lib.rs
rename to src/types-and-values/exercise.rs
index f9175571..b7459d68 100644
--- a/mdbook-course/src/lib.rs
+++ b/src/types-and-values/exercise.rs
@@ -12,4 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-pub mod frontmatter;
+// ANCHOR: solution
+// ANCHOR: fib
+fn fib(n: u32) -> u32 {
+    // ANCHOR_END: fib
+    if n < 2 {
+        return 1;
+    } else {
+        return fib(n - 1) + fib(n - 2);
+    }
+}
+
+// ANCHOR: main
+fn main() {
+    let n = 20;
+    println!("fib(n) = {}", fib(n));
+}
+// ANCHOR_END: main
diff --git a/src/basic-syntax/type-inference.md b/src/types-and-values/inference.md
similarity index 52%
rename from src/basic-syntax/type-inference.md
rename to src/types-and-values/inference.md
index 30fa3566..7e688435 100644
--- a/src/basic-syntax/type-inference.md
+++ b/src/types-and-values/inference.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Type Inference
 
 Rust will look at how the variable is _used_ to determine the type:
@@ -25,26 +29,22 @@ fn main() {
 <details>
 
 This slide demonstrates how the Rust compiler infers types based on constraints given by variable declarations and usages.
-    
+
 It is very important to emphasize that variables declared like this are not of some sort of dynamic "any type" that can
 hold any data. The machine code generated by such declaration is identical to the explicit declaration of a type.
 The compiler does the job for us and helps us write more concise code.
 
-The following code tells the compiler to copy into a certain generic container without the code ever explicitly specifying the contained type, using `_` as a placeholder:
+When nothing constrains the type of an integer literal, Rust defaults to `i32`.
+This sometimes appears as `{integer}` in error messages. Similarly,
+floating-point literals default to `f64`.
 
-<!-- mdbook-xgettext: skip -->
-```rust,editable
+```rust,compile_fail
 fn main() {
-    let mut v = Vec::new();
-    v.push((10, false));
-    v.push((20, true));
-    println!("v: {v:?}");
-
-    let vv = v.iter().collect::<std::collections::HashSet<_>>();
-    println!("vv: {vv:?}");
+    let x = 3.14;
+    let y = 20;
+    assert_eq!(x, y);
+    // ERROR: no implementation for `{float} == {integer}`
 }
 ```
 
-[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) relies on [`FromIterator`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html), which [`HashSet`](https://doc.rust-lang.org/std/collections/struct.HashSet.html#impl-FromIterator%3CT%3E-for-HashSet%3CT,+S%3E) implements.
-
 </details>
diff --git a/src/types-and-values/solution.md b/src/types-and-values/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/types-and-values/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/types-and-values/strings.md b/src/types-and-values/strings.md
new file mode 100644
index 00000000..b62998c3
--- /dev/null
+++ b/src/types-and-values/strings.md
@@ -0,0 +1,55 @@
+---
+minutes: 10
+---
+
+# Strings
+
+Rust has two types to represent strings, both of which will be covered in more
+depth later.  Both _always_ store UTF-8 encoded strings.
+
+ * `String` - a modifiable, owned string.
+ * `&str` - a read-only string. String literals have this type.
+
+```rust,editable
+fn main() {
+    let greeting: &str = "Greetings";
+    let planet: &str = "🪐";
+    let mut sentence = String::new();
+    sentence.push_str(greeting);
+    sentence.push_str(", ");
+    sentence.push_str(planet);
+    println!("final sentence: {}", sentence);
+    println!("{:?}", &sentence[0..5]);
+    //println!("{:?}", &sentence[12..13]);
+}
+```
+
+<details>
+
+This slide introduces strings. Everything here will be covered in more depth
+later, but this is enough for subsequent slides and exercises to use strings.
+
+- Invalid UTF-8 in a string is UB, and this not allowed in safe Rust.
+
+- `String` is a user-defined type with a constructor (`::new()`) and methods like `s.push_str(..)`.
+
+- The `&` in `&str` indicates that this is a reference. We will cover references later, so for now
+  just think of `&str` as a unit meaning "a read-only string".
+
+- The commented-out line is indexing into the string by byte position. `12..13`
+  does not end on a character boundary, so the program panics. Adjust it to a
+  range that does, based on the error message.
+
+- Raw strings allow you to create a `&str` value with escapes disabled: `r"\n"
+  == "\\\\n"`. You can embed double-quotes by using an equal amount of `#` on
+  either side of the quotes:
+
+  <!-- mdbook-xgettext: skip -->
+  ```rust,editable
+  fn main() {
+      println!(r#"<a href="link.html">link</a>"#);
+      println!("<a href=\"link.html\">link</a>");
+  }
+  ```
+
+</details>
diff --git a/src/basic-syntax/scalar-types.md b/src/types-and-values/values.md
similarity index 62%
rename from src/basic-syntax/scalar-types.md
rename to src/types-and-values/values.md
index 65bc2f45..f1b9d2c2 100644
--- a/src/basic-syntax/scalar-types.md
+++ b/src/types-and-values/values.md
@@ -1,11 +1,16 @@
-# Scalar Types
+---
+minutes: 10
+---
+
+# Values
+
+Here are some basic built-in types, and the syntax for literal values of each type.
 
 |                        | Types                                      | Literals                       |
 |------------------------|--------------------------------------------|--------------------------------|
 | Signed integers        | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | `-10`, `0`, `1_000`, `123_i64` |
 | Unsigned integers      | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, `123`, `10_u16`           |
 | Floating point numbers | `f32`, `f64`                               | `3.14`, `-10.0e20`, `2_f32`    |
-| Strings                | `&str`                                     | `"foo"`, `"two\nlines"`        |
 | Unicode scalar values  | `char`                                     | `'a'`, `'α'`, `'∞'`            |
 | Booleans               | `bool`                                     | `true`, `false`                |
 
@@ -20,28 +25,6 @@ The types have widths as follows:
 
 There are a few syntaxes which are not shown above:
 
-- Raw strings allow you to create a `&str` value with escapes disabled: `r"\n"
-  == "\\\\n"`. You can embed double-quotes by using an equal amount of `#` on
-  either side of the quotes:
-
-  <!-- mdbook-xgettext: skip -->
-  ```rust,editable
-  fn main() {
-      println!(r#"<a href="link.html">link</a>"#);
-      println!("<a href=\"link.html\">link</a>");
-  }
-  ```
-
-- Byte strings allow you to create a `&[u8]` value directly:
-
-  <!-- mdbook-xgettext: skip -->
-  ```rust,editable
-  fn main() {
-      println!("{:?}", b"abc");
-      println!("{:?}", &[97, 98, 99]);
-  }
-  ```
-
 - All underscores in numbers can be left out, they are for legibility only.
   So `1_000` can be written as `1000` (or `10_00`), and `123_i64` can be written as `123i64`.
 
diff --git a/src/types-and-values/variables.md b/src/types-and-values/variables.md
new file mode 100644
index 00000000..1d1c0ccb
--- /dev/null
+++ b/src/types-and-values/variables.md
@@ -0,0 +1,28 @@
+---
+minutes: 5
+---
+
+# Variables
+
+Rust provides type safety via static typing. Variable bindings are made with
+`let`:
+
+```rust,editable
+fn main() {
+    let x: i32 = 10;
+    println!("x: {x}");
+    // x = 20;
+    // println!("x: {x}");
+}
+```
+
+<details>
+
+* Uncomment the `x = 20` to demonstrate that variables are immutable by default.
+  Add the `mut` keyword to allow changes.
+
+* The `i32` here is the type of the variable. This must be known at compile
+  time, but type inference (covered later) allows the programmer to omit it in
+  many cases.
+
+</details>
diff --git a/src/unsafe-rust.md b/src/unsafe-rust.md
new file mode 100644
index 00000000..f70912bb
--- /dev/null
+++ b/src/unsafe-rust.md
@@ -0,0 +1,3 @@
+# Unsafe Rust
+
+{{%segment outline}}
diff --git a/src/unsafe-rust/Cargo.toml b/src/unsafe-rust/Cargo.toml
new file mode 100644
index 00000000..d846404d
--- /dev/null
+++ b/src/unsafe-rust/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "unsafe-rust"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+tempfile = "*"
+
+[[bin]]
+name = "listdir"
+path = "exercise.rs"
diff --git a/src/unsafe/raw-pointers.md b/src/unsafe-rust/dereferencing.md
similarity index 72%
rename from src/unsafe/raw-pointers.md
rename to src/unsafe-rust/dereferencing.md
index f2175660..b9c2c9b5 100644
--- a/src/unsafe/raw-pointers.md
+++ b/src/unsafe-rust/dereferencing.md
@@ -1,13 +1,17 @@
+---
+minutes: 10
+---
+
 # Dereferencing Raw Pointers
 
 Creating pointers is safe, but dereferencing them requires `unsafe`:
 
 ```rust,editable
 fn main() {
-    let mut num = 5;
+    let mut s = String::from("careful!");
 
-    let r1 = &mut num as *mut i32;
-    let r2 = r1 as *const i32;
+    let r1 = &mut s as *mut String;
+    let r2 = r1 as *const String;
 
     // Safe because r1 and r2 were obtained from references and so are
     // guaranteed to be non-null and properly aligned, the objects underlying
@@ -16,9 +20,16 @@ fn main() {
     // references or concurrently through any other pointers.
     unsafe {
         println!("r1 is: {}", *r1);
-        *r1 = 10;
+        *r1 = String::from("uhoh");
         println!("r2 is: {}", *r2);
     }
+
+    // NOT SAFE. DO NOT DO THIS.
+    /*
+    let r3: &String = unsafe { &*r1 };
+    drop(s);
+    println!("r3 is: {}", *r3);
+    */
 }
 ```
 
@@ -40,4 +51,8 @@ In the case of pointer dereferences, this means that the pointers must be
 
 In most cases the pointer must also be properly aligned.
 
+The "NOT SAFE" sectoin gives an example of a common kind of UB bug: `*r1` has
+the `'static` lifetime, so `r3` has type `&'static String`, and thus outlives
+`s`. Creating a reference from a pointer requires _great care_.
+
 </details>
diff --git a/src/exercises/day-3/safe-ffi-wrapper.md b/src/unsafe-rust/exercise.md
similarity index 92%
rename from src/exercises/day-3/safe-ffi-wrapper.md
rename to src/unsafe-rust/exercise.md
index 5e317af7..028f41c6 100644
--- a/src/exercises/day-3/safe-ffi-wrapper.md
+++ b/src/unsafe-rust/exercise.md
@@ -1,3 +1,7 @@
+---
+minutes: 30
+---
+
 # Safe FFI Wrapper
 
 Rust has great support for calling functions through a _foreign function
@@ -49,22 +53,22 @@ functions and methods:
 // TODO: remove this when you're done with your implementation.
 #![allow(unused_imports, unused_variables, dead_code)]
 
-{{#include safe-ffi-wrapper.rs:ffi}}
+{{#include exercise.rs:ffi}}
 
-{{#include safe-ffi-wrapper.rs:DirectoryIterator}}
+{{#include exercise.rs:DirectoryIterator}}
         unimplemented!()
     }
 }
 
-{{#include safe-ffi-wrapper.rs:Iterator}}
+{{#include exercise.rs:Iterator}}
         unimplemented!()
     }
 }
 
-{{#include safe-ffi-wrapper.rs:Drop}}
+{{#include exercise.rs:Drop}}
         unimplemented!()
     }
 }
 
-{{#include safe-ffi-wrapper.rs:main}}
+{{#include exercise.rs:main}}
 ```
diff --git a/src/exercises/day-3/safe-ffi-wrapper.rs b/src/unsafe-rust/exercise.rs
similarity index 98%
rename from src/exercises/day-3/safe-ffi-wrapper.rs
rename to src/unsafe-rust/exercise.rs
index ee32719b..dce668cb 100644
--- a/src/exercises/day-3/safe-ffi-wrapper.rs
+++ b/src/unsafe-rust/exercise.rs
@@ -17,7 +17,7 @@
 mod ffi {
     use std::os::raw::{c_char, c_int};
     #[cfg(not(target_os = "macos"))]
-    use std::os::raw::{c_long, c_ulong, c_ushort, c_uchar};
+    use std::os::raw::{c_long, c_uchar, c_ulong, c_ushort};
 
     // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.
     #[repr(C)]
diff --git a/src/unsafe/mutable-static-variables.md b/src/unsafe-rust/mutable-static.md
similarity index 98%
rename from src/unsafe/mutable-static-variables.md
rename to src/unsafe-rust/mutable-static.md
index 6383a2f3..3ca06ed5 100644
--- a/src/unsafe/mutable-static-variables.md
+++ b/src/unsafe-rust/mutable-static.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Mutable Static Variables
 
 It is safe to read an immutable static variable:
diff --git a/src/unsafe-rust/solution.md b/src/unsafe-rust/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/unsafe-rust/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/unsafe/unions.md b/src/unsafe-rust/unions.md
similarity index 97%
rename from src/unsafe/unions.md
rename to src/unsafe-rust/unions.md
index 02f03e0f..d45a0d1d 100644
--- a/src/unsafe/unions.md
+++ b/src/unsafe-rust/unions.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Unions
 
 Unions are like enums, but you need to track the active field yourself:
diff --git a/src/unsafe-rust/unsafe-functions.md b/src/unsafe-rust/unsafe-functions.md
new file mode 100644
index 00000000..c5e7b149
--- /dev/null
+++ b/src/unsafe-rust/unsafe-functions.md
@@ -0,0 +1,98 @@
+---
+minutes: 5
+---
+
+# Unsafe Functions
+
+## Calling Unsafe Functions
+
+A function or method can be marked `unsafe` if it has extra preconditions you
+must uphold to avoid undefined behaviour:
+
+```rust,editable
+extern "C" {
+    fn abs(input: i32) -> i32;
+}
+
+fn main() {
+    let emojis = "🗻∈🌏";
+
+    // Safe because the indices are in the correct order, within the bounds of
+    // the string slice, and lie on UTF-8 sequence boundaries.
+    unsafe {
+        println!("emoji: {}", emojis.get_unchecked(0..4));
+        println!("emoji: {}", emojis.get_unchecked(4..7));
+        println!("emoji: {}", emojis.get_unchecked(7..11));
+    }
+
+    println!("char count: {}", count_chars(unsafe { emojis.get_unchecked(0..7) }));
+
+    unsafe {
+        // Undefined behavior if abs misbehaves.
+        println!("Absolute value of -3 according to C: {}", abs(-3));
+    }
+
+    // Not upholding the UTF-8 encoding requirement breaks memory safety!
+    // println!("emoji: {}", unsafe { emojis.get_unchecked(0..3) });
+    // println!("char count: {}", count_chars(unsafe { emojis.get_unchecked(0..3) }));
+}
+
+fn count_chars(s: &str) -> usize {
+    s.chars().count()
+}
+```
+
+## Writing Unsafe Functions
+
+You can mark your own functions as `unsafe` if they require particular conditions to avoid undefined
+behaviour.
+
+```rust,editable
+/// Swaps the values pointed to by the given pointers.
+///
+/// # Safety
+///
+/// The pointers must be valid and properly aligned.
+unsafe fn swap(a: *mut u8, b: *mut u8) {
+    let temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+fn main() {
+    let mut a = 42;
+    let mut b = 66;
+
+    // Safe because ...
+    unsafe {
+        swap(&mut a, &mut b);
+    }
+
+    println!("a = {}, b = {}", a, b);
+}
+```
+
+<details>
+
+## Calling Unsafe Functions
+
+`get_unchecked`, like most `_unchecked` functions, is unsafe, because it can
+create UB if the range is incorrect. `abs` is incorrect for a different reason:
+it is an external function (FFI).  Calling external functions is usually only a
+problem when those functions do things with pointers which might violate Rust's
+memory model, but in general any C function might have undefined behaviour
+under any arbitrary circumstances.
+
+The `"C"` in this example is the ABI;
+[other ABIs are available too](https://doc.rust-lang.org/reference/items/external-blocks.html).
+
+## Writing Unsafe Functions
+
+We wouldn't actually use pointers for a `swap` function - it can be done safely
+with references.
+
+Note that unsafe code is allowed within an unsafe function without an `unsafe`
+block. We can prohibit this with `#[deny(unsafe_op_in_unsafe_fn)]`. Try adding
+it and see what happens. This will likely change in a future Rust edition.
+
+</details>
diff --git a/src/unsafe/unsafe-traits.md b/src/unsafe-rust/unsafe-traits.md
similarity index 98%
rename from src/unsafe/unsafe-traits.md
rename to src/unsafe-rust/unsafe-traits.md
index 060b63bf..57c71c59 100644
--- a/src/unsafe/unsafe-traits.md
+++ b/src/unsafe-rust/unsafe-traits.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Implementing Unsafe Traits
 
 Like with functions, you can mark a trait as `unsafe` if the implementation must guarantee
diff --git a/src/unsafe.md b/src/unsafe-rust/unsafe.md
similarity index 86%
rename from src/unsafe.md
rename to src/unsafe-rust/unsafe.md
index bbbab83b..897e0c7c 100644
--- a/src/unsafe.md
+++ b/src/unsafe-rust/unsafe.md
@@ -1,3 +1,7 @@
+---
+minutes: 5
+---
+
 # Unsafe Rust
 
 The Rust language has two parts:
@@ -5,7 +9,7 @@ The Rust language has two parts:
 * **Safe Rust:** memory safe, no undefined behavior possible.
 * **Unsafe Rust:** can trigger undefined behavior if preconditions are violated.
 
-We will be seeing mostly safe Rust in this course, but it's important to know
+We saw mostly safe Rust in this course, but it's important to know
 what Unsafe Rust is.
 
 Unsafe code is usually small and isolated, and its correctness should be carefully
@@ -26,7 +30,7 @@ and the [Rustonomicon](https://doc.rust-lang.org/nomicon/).
 <details>
 
 Unsafe Rust does not mean the code is incorrect. It means that developers have
-turned off the compiler safety features and have to write correct code by
+turned off some compiler safety features and have to write correct code by
 themselves. It means the compiler no longer enforces Rust's memory-safety rules.
 
 </details>
diff --git a/src/unsafe/calling-unsafe-functions.md b/src/unsafe/calling-unsafe-functions.md
deleted file mode 100644
index 7400dc9f..00000000
--- a/src/unsafe/calling-unsafe-functions.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Calling Unsafe Functions
-
-A function or method can be marked `unsafe` if it has extra preconditions you
-must uphold to avoid undefined behaviour:
-
-```rust,editable
-fn main() {
-    let emojis = "🗻∈🌏";
-
-    // Safe because the indices are in the correct order, within the bounds of
-    // the string slice, and lie on UTF-8 sequence boundaries.
-    unsafe {
-        println!("emoji: {}", emojis.get_unchecked(0..4));
-        println!("emoji: {}", emojis.get_unchecked(4..7));
-        println!("emoji: {}", emojis.get_unchecked(7..11));
-    }
-
-    println!("char count: {}", count_chars(unsafe { emojis.get_unchecked(0..7) }));
-
-    // Not upholding the UTF-8 encoding requirement breaks memory safety!
-    // println!("emoji: {}", unsafe { emojis.get_unchecked(0..3) });
-    // println!("char count: {}", count_chars(unsafe { emojis.get_unchecked(0..3) }));
-}
-
-fn count_chars(s: &str) -> usize {
-    s.chars().count()
-}
-```
diff --git a/src/unsafe/extern-functions.md b/src/unsafe/extern-functions.md
deleted file mode 100644
index bc7f2eb6..00000000
--- a/src/unsafe/extern-functions.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Calling External Code
-
-Functions from other languages might violate the guarantees of Rust. Calling
-them is thus unsafe:
-
-```rust,editable
-extern "C" {
-    fn abs(input: i32) -> i32;
-}
-
-fn main() {
-    unsafe {
-        // Undefined behavior if abs misbehaves.
-        println!("Absolute value of -3 according to C: {}", abs(-3));
-    }
-}
-```
-
-<details>
-
-This is usually only a problem for extern functions which do things with pointers which might
-violate Rust's memory model, but in general any C function might have undefined behaviour under any
-arbitrary circumstances.
-
-The `"C"` in this example is the ABI;
-[other ABIs are available too](https://doc.rust-lang.org/reference/items/external-blocks.html).
-
-</details>
diff --git a/src/unsafe/writing-unsafe-functions.md b/src/unsafe/writing-unsafe-functions.md
deleted file mode 100644
index e1ea3f7d..00000000
--- a/src/unsafe/writing-unsafe-functions.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Writing Unsafe Functions
-
-You can mark your own functions as `unsafe` if they require particular conditions to avoid undefined
-behaviour.
-
-```rust,editable
-/// Swaps the values pointed to by the given pointers.
-///
-/// # Safety
-///
-/// The pointers must be valid and properly aligned.
-unsafe fn swap(a: *mut u8, b: *mut u8) {
-    let temp = *a;
-    *a = *b;
-    *b = temp;
-}
-
-fn main() {
-    let mut a = 42;
-    let mut b = 66;
-
-    // Safe because ...
-    unsafe {
-        swap(&mut a, &mut b);
-    }
-
-    println!("a = {}, b = {}", a, b);
-}
-```
-
-<details>
-
-We wouldn't actually use pointers for this because it can be done safely with references.
-
-Note that unsafe code is allowed within an unsafe function without an `unsafe` block. We can
-prohibit this with `#[deny(unsafe_op_in_unsafe_fn)]`. Try adding it and see what happens.
-
-</details>
diff --git a/src/user-defined-types.md b/src/user-defined-types.md
new file mode 100644
index 00000000..52ff6054
--- /dev/null
+++ b/src/user-defined-types.md
@@ -0,0 +1,3 @@
+# User-Defined Types
+
+{{%segment outline}}
diff --git a/src/user-defined-types/Cargo.toml b/src/user-defined-types/Cargo.toml
new file mode 100644
index 00000000..10655db3
--- /dev/null
+++ b/src/user-defined-types/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "user-defined-types"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "elevator"
+path = "exercise.rs"
diff --git a/src/user-defined-types/aliases.md b/src/user-defined-types/aliases.md
new file mode 100644
index 00000000..2709136b
--- /dev/null
+++ b/src/user-defined-types/aliases.md
@@ -0,0 +1,26 @@
+---
+minutes: 2
+---
+
+# Type Aliases
+
+A type alias creates a name for another type. The two types can be used interchangeably.
+
+```rust,editable
+enum CarryableConcreteItem {
+    Left,
+    Right,
+}
+
+type Item = CarryableConcreteItem;
+
+// Aliases are more useful with long, complex types:
+use std::{sync::{Arc, RwLock}, cell::RefCell};
+type PlayerInventory = RwLock<Vec<Arc<RefCell<Item>>>>;
+```
+
+<details>
+
+C programmers will recognize this as similar to a `typedef`.
+
+</details>
diff --git a/src/enums/sizes.md b/src/user-defined-types/enums.md
similarity index 69%
rename from src/enums/sizes.md
rename to src/user-defined-types/enums.md
index 7a1d7f80..7dd08ae3 100644
--- a/src/enums/sizes.md
+++ b/src/user-defined-types/enums.md
@@ -1,36 +1,50 @@
-# Enum Sizes
+---
+minutes: 5
+---
 
-Rust enums are packed tightly, taking constraints due to alignment into account:
+# Enums
+
+The `enum` keyword allows the creation of a type which has a few
+different variants:
 
 ```rust,editable
-use std::any::type_name;
-use std::mem::{align_of, size_of};
-
-fn dbg_size<T>() {
-    println!("{}: size {} bytes, align: {} bytes",
-        type_name::<T>(), size_of::<T>(), align_of::<T>());
+#[derive(Debug)]
+enum Direction {
+    Left,
+    Right,
 }
 
-enum Foo {
-    A,
-    B,
+#[derive(Debug)]
+enum PlayerMove {
+    Pass,                        // Simple variant
+    Run(Direction),              // Tuple variant
+    Teleport { x: u32, y: u32 }, // Struct variant
 }
 
 fn main() {
-    dbg_size::<Foo>();
+    let m = PlayerMove::Run(Direction::Left);
+    println!("On this turn: {:?}", m);
 }
 ```
 
-* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout.html).
-
 <details>
-    
+
 Key Points:
 
- * Internally Rust is using a field (discriminant) to keep track of the enum variant.
+* Enumerations allow you to collect a set of values under one type
+* Direction has two variants, `Left` and `Right`. These are referred to with the `Direction::..` namespace.
+* PlayerMove shows the three types of variants. Rust will also store a discriminant so that it can determine at runtime which variant is in a value.
+* This might be a good time to compare Structs and Enums:
+  * In both, you can have a simple version without fields (unit struct) or one with different types of fields (variant payloads).
+  * You could even implement the different variants of an enum with separate structs but then they wouldn’t be the same type as they would if they were all defined in an enum.
+* Rust uses minimal space to store the discriminant.
+  * If necessary, it stores an integer of the smallest required size
+  * If the allowed variant values do not cover all bit patterns, it will use
+    invalid bit patterns to encode the discriminant (the "niche optimization").
+    For example, `Option<&u8>` stores either a pointer to an integer or `NULL`
+    for the `None` variant.
+  * You can control the discriminant if needed (e.g., for compatibility with C):
 
- * You can control the discriminant if needed (e.g., for compatibility with C):
- 
      <!-- mdbook-xgettext: skip -->
      ```rust,editable
      #[repr(u32)]
@@ -39,7 +53,7 @@ Key Points:
          B = 10000,
          C,  // 10001
      }
-     
+
      fn main() {
          println!("A: {}", Bar::A as u32);
          println!("B: {}", Bar::B as u32);
@@ -47,16 +61,8 @@ Key Points:
      }
      ```
 
-    Without `repr`, the discriminant type takes 2 bytes, because 10001 fits 2
-    bytes.
-
-
- * Try out other types such as
- 
-     * `dbg_size!(bool)`: size 1 bytes, align: 1 bytes,
-     * `dbg_size!(Option<bool>)`: size 1 bytes, align: 1 bytes (niche optimization, see below),
-     * `dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (on a 64-bit machine),
-     * `dbg_size!(Option<&i32>)`: size 8 bytes, align: 8 bytes (null pointer optimization, see below).
+     Without `repr`, the discriminant type takes 2 bytes, because 10001 fits 2
+     bytes.
 
 ## More to Explore
 
@@ -113,7 +119,7 @@ Rust has several optimizations it can employ to make enums take up less space.
      #![recursion_limit = "1000"]
 
      use std::mem::transmute;
-     
+
      macro_rules! dbg_bits {
          ($e:expr, $bit_type:ty) => {
              println!("- {}: {:#x}", stringify!($e), transmute::<_, $bit_type>($e));
diff --git a/src/user-defined-types/exercise.md b/src/user-defined-types/exercise.md
new file mode 100644
index 00000000..902defaf
--- /dev/null
+++ b/src/user-defined-types/exercise.md
@@ -0,0 +1,36 @@
+---
+minutes: 15
+---
+
+# Exercise: Elevator Events
+
+We will create a data structure to represent an event in an elevator control
+system. It is up to you to define the types and functions to construct various
+events. Use `#[derive(Debug)]` to allow the types to be formatted with `{:?}`.
+
+```rust,compile_fail
+{{#include exercise.rs:car_arrived}}
+    todo!()
+}
+
+{{#include exercise.rs:car_door_opened}}
+    todo!()
+}
+
+{{#include exercise.rs:car_door_closed}}
+    todo!()
+}
+
+{{#include exercise.rs:lobby_call_button_pressed}}
+    todo!()
+}
+
+{{#include exercise.rs:car_floor_button_pressed}}
+    todo!()
+}
+
+{{#include exercise.rs:main}}
+```
+
+This exercise only requires creating data structures. The next part of the
+course will cover getting data out of these structures.
diff --git a/src/user-defined-types/exercise.rs b/src/user-defined-types/exercise.rs
new file mode 100644
index 00000000..fa085160
--- /dev/null
+++ b/src/user-defined-types/exercise.rs
@@ -0,0 +1,107 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![allow(dead_code)]
+
+// ANCHOR: solution
+#[derive(Debug)]
+/// An event in the elevator system that the controller must react to.
+enum Event {
+    /// A button was pressed.
+    ButtonPressed(Button),
+
+    /// The car has arrived at the given floor.
+    CarArrived(Floor),
+
+    /// The car's doors have opened.
+    CarDoorOpened,
+
+    /// The car's doors have closed.
+    CarDoorClosed,
+}
+
+/// A floor is represented as an integer.
+type Floor = i32;
+
+/// A direction of travel.
+#[derive(Debug)]
+enum Direction {
+    Up,
+    Down,
+}
+
+/// A user-accessible button.
+#[derive(Debug)]
+enum Button {
+    /// A button in the elevator lobby on the given floor.
+    LobbyCall(Direction, Floor),
+
+    /// A floor button within the car.
+    CarFloor(Floor),
+}
+
+// ANCHOR: car_arrived
+/// The car has arrived on the given floor.
+fn car_arrived(floor: i32) -> Event {
+    // END_ANCHOR: car_arrived
+    Event::CarArrived(floor)
+}
+
+// ANCHOR: car_door_opened
+/// The car doors have opened.
+fn car_door_opened() -> Event {
+    // END_ANCHOR: car_door_opened
+    Event::CarDoorOpened
+}
+
+// ANCHOR: car_door_closed
+/// The car doors have closed.
+fn car_door_closed() -> Event {
+    // END_ANCHOR: car_door_closed
+    Event::CarDoorClosed
+}
+
+// ANCHOR: lobby_call_button_pressed
+/// A directional button was pressed in an elevator lobby on the given floor.
+fn lobby_call_button_pressed(floor: i32, dir: Direction) -> Event {
+    // END_ANCHOR: lobby_call_button_pressed
+    Event::ButtonPressed(Button::LobbyCall(dir, floor))
+}
+
+// ANCHOR: car_floor_button_pressed
+/// A floor button was pressed in the elevator car.
+fn car_floor_button_pressed(floor: i32) -> Event {
+    // END_ANCHOR: car_floor_button_pressed
+    Event::ButtonPressed(Button::CarFloor(floor))
+}
+
+// ANCHOR: main
+fn main() {
+    println!(
+        "A ground floor passenger has pressed the up button: {:?}",
+        lobby_call_button_pressed(0, Direction::Up)
+    );
+    println!(
+        "The car has arrived on the ground floor: {:?}",
+        car_arrived(0)
+    );
+    println!("The car door opened: {:?}", car_door_opened());
+    println!(
+        "A passenger has pressed the 3rd floor button: {:?}",
+        car_floor_button_pressed(3)
+    );
+    println!("The car door closed: {:?}", car_door_closed());
+    println!("The car has arrived on the 3rd floor: {:?}", car_arrived(3));
+}
+// ANCHOR_END: main
diff --git a/src/structs.md b/src/user-defined-types/named-structs.md
similarity index 66%
rename from src/structs.md
rename to src/user-defined-types/named-structs.md
index 0d595186..fb5783ee 100644
--- a/src/structs.md
+++ b/src/user-defined-types/named-structs.md
@@ -1,4 +1,8 @@
-# Structs
+---
+minutes: 10
+---
+
+# Named Structs
 
 Like C and C++, Rust has support for custom structs:
 
@@ -8,21 +12,30 @@ struct Person {
     age: u8,
 }
 
+fn describe(person: &Person) {
+    println!("{} is {} years old", person.name, person.age);
+}
+
 fn main() {
     let mut peter = Person {
         name: String::from("Peter"),
         age: 27,
     };
-    println!("{} is {} years old", peter.name, peter.age);
-    
+    describe(&peter);
+
     peter.age = 28;
-    println!("{} is {} years old", peter.name, peter.age);
-    
+    describe(&peter);
+
+    let name = String::from("Avery");
+    let age = 39;
+    let avery = Person { name, age };
+    describe(&avery);
+
     let jackie = Person {
         name: String::from("Jackie"),
-        ..peter
+        ..avery
     };
-    println!("{} is {} years old", jackie.name, jackie.age);
+    describe(&jackie);
 }
 ```
 
@@ -33,10 +46,11 @@ Key Points:
 * Structs work like in C or C++.
   * Like in C++, and unlike in C, no typedef is needed to define a type.
   * Unlike in C++, there is no inheritance between structs.
-* Methods are defined in an `impl` block, which we will see in following slides.
-* This may be a good time to let people know there are different types of structs. 
-  * Zero-sized structs (e.g. `struct Foo;`) might be used when implementing a trait on some type but don’t have any data that you want to store in the value itself. 
+* This may be a good time to let people know there are different types of structs.
+  * Zero-sized structs (e.g. `struct Foo;`) might be used when implementing a trait on some type but don’t have any data that you want to store in the value itself.
   * The next slide will introduce Tuple structs, used when the field names are not important.
+* If you already have variables with the right names, then you can create the
+struct using a shorthand.
 * The syntax `..peter` allows us to copy the majority of the fields from the old struct without having to explicitly type it all out. It must always be the last element.
 
 </details>
diff --git a/src/user-defined-types/solution.md b/src/user-defined-types/solution.md
new file mode 100644
index 00000000..b4a4c92c
--- /dev/null
+++ b/src/user-defined-types/solution.md
@@ -0,0 +1,5 @@
+# Solution
+
+```rust,editable
+{{#include exercise.rs:solution}}
+```
diff --git a/src/basic-syntax/static-and-const.md b/src/user-defined-types/static-and-const.md
similarity index 86%
rename from src/basic-syntax/static-and-const.md
rename to src/user-defined-types/static-and-const.md
index 2fbd3f5c..904b6113 100644
--- a/src/basic-syntax/static-and-const.md
+++ b/src/user-defined-types/static-and-const.md
@@ -1,7 +1,11 @@
-# Static and Constant Variables
+---
+minutes: 5
+---
+
+# Static and Const
 
 Static and constant variables are two different ways to create globally-scoped values that
-cannot be moved or reallocated during the execution of the program. 
+cannot be moved or reallocated during the execution of the program.
 
 ## `const`
 
@@ -43,25 +47,18 @@ fn main() {
 }
 ```
 
-As noted in the [Rust RFC Book][1], these are not inlined upon use and have an actual associated memory location.  This is useful for unsafe and 
+As noted in the [Rust RFC Book][1], these are not inlined upon use and have an actual associated memory location.  This is useful for unsafe and
 embedded code, and the variable lives through the entirety of the program execution.
 When a globally-scoped value does not have a reason to need object identity, `const` is generally preferred.
 
-Because `static` variables are accessible from any thread, they must be `Sync`. Interior mutability
-is possible through a [`Mutex`](https://doc.rust-lang.org/std/sync/struct.Mutex.html), atomic or
-similar. It is also possible to have mutable statics, but they require manual synchronisation so any
-access to them requires `unsafe` code. We will look at
-[mutable statics](../unsafe/mutable-static-variables.md) in the chapter on Unsafe Rust.
-
 <details>
 
 * Mention that `const` behaves semantically similar to C++'s `constexpr`.
 * `static`, on the other hand, is much more similar to a `const` or mutable global variable in C++.
 * `static` provides object identity: an address in memory and state as required by types with interior mutability such as `Mutex<T>`.
 * It isn't super common that one would need a runtime evaluated constant, but it is helpful and safer than using a static.
-* `thread_local` data can be created with the macro `std::thread_local`.
 
-### Properties table: 
+### Properties table:
 
 | Property | Static | Constant |
 |---|---|---|
@@ -71,6 +68,13 @@ access to them requires `unsafe` code. We will look at
 | Evaluated at compile time | Yes (initialised at compile time) | Yes |
 | Inlined wherever it is used | No | Yes |
 
+# More to Explore
+
+Because `static` variables are accessible from any thread, they must be `Sync`. Interior mutability
+is possible through a [`Mutex`](https://doc.rust-lang.org/std/sync/struct.Mutex.html), atomic or
+similar.
+
+Thread-local data can be created with the macro `std::thread_local`.
 
 </details>
 
diff --git a/src/structs/tuple-structs.md b/src/user-defined-types/tuple-structs.md
similarity index 91%
rename from src/structs/tuple-structs.md
rename to src/user-defined-types/tuple-structs.md
index 4f52426e..41865a8e 100644
--- a/src/structs/tuple-structs.md
+++ b/src/user-defined-types/tuple-structs.md
@@ -1,3 +1,10 @@
+---
+minutes: 10
+---
+
+<!-- NOTES:
+Tuple structs, newtype wrappers, unit-like structs, including initialization syntax
+-->
 # Tuple Structs
 
 If the field names are unimportant, you can use a tuple struct:
@@ -41,4 +48,5 @@ fn main() {
   *  Rust generally doesn’t like inexplicit things, like automatic unwrapping or for instance using booleans as integers.
   *  Operator overloading is discussed on Day 3 (generics).
 * The example is a subtle reference to the [Mars Climate Orbiter](https://en.wikipedia.org/wiki/Mars_Climate_Orbiter) failure.
+
 </details>
diff --git a/src/welcome-day-1-afternoon.md b/src/welcome-day-1-afternoon.md
new file mode 100644
index 00000000..aa3d096b
--- /dev/null
+++ b/src/welcome-day-1-afternoon.md
@@ -0,0 +1,7 @@
+---
+session: Day 1 Afternoon
+---
+
+# Welcome Back
+
+{{%session outline}}
diff --git a/src/welcome-day-1.md b/src/welcome-day-1.md
index 39cea21b..feac267c 100644
--- a/src/welcome-day-1.md
+++ b/src/welcome-day-1.md
@@ -1,3 +1,9 @@
+---
+minutes: 5
+course: Fundamentals
+session: Day 1 Morning
+---
+
 # Welcome to Day 1
 
 This is the first day of Rust Fundamentals. We will cover a lot of ground
@@ -5,12 +11,15 @@ today:
 
 * Basic Rust syntax: variables, scalar and compound types, enums, structs,
   references, functions, and methods.
-
-* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, and
-  `continue`.
-
+* Types and type inference.
+* Control flow constructs: loops, conditionals, and so on.
+* User-defined types: structs and enums.
 * Pattern matching: destructuring enums, structs, and arrays.
 
+## Schedule
+
+{{%session outline}}
+
 <details>
 
 Please remind the students that:
@@ -18,25 +27,22 @@ Please remind the students that:
 * They should ask questions when they get them, don't save them to the end.
 * The class is meant to be interactive and discussions are very much encouraged!
   * As an instructor, you should try to keep the discussions relevant, i.e.,
-    keep the discussions related to how Rust does things vs some other language. 
-    It can be hard to find the right balance, but err on the side of allowing 
+    keep the discussions related to how Rust does things vs some other language.
+    It can be hard to find the right balance, but err on the side of allowing
     discussions since they engage people much more than one-way communication.
 * The questions will likely mean that we talk about things ahead of the slides.
   * This is perfectly okay! Repetition is an important part of learning. Remember
     that the slides are just a support and you are free to skip them as you
     like.
 
-The idea for the first day is to show _just enough_ of Rust to be able to speak
-about the famous borrow checker. The way Rust handles memory is a major feature
-and we should show students this right away.
+The idea for the first day is to show the "basic" things in Rust that should
+have immediate parallels in other languages. The more advanced parts of Rust
+come on the subsequent days.
 
 If you're teaching this in a classroom, this is a good place to go over the
-schedule. We suggest splitting the day into two parts (following the slides):
-
-* Morning: 9:00 to 12:00,
-* Afternoon: 13:00 to 16:00.
-
-You can of course adjust this as necessary. Please make sure to include breaks,
-we recommend a break every hour!
+schedule. Note that there is an exercise at the end of each segment, followed by
+a break. Plan to cover the exercise solution after the break. The times listed
+here are a suggestion in order to keep the course on schedule. Feel free to
+be flexible and adjust as necessary!
 
 </details>
diff --git a/src/welcome-day-2-afternoon.md b/src/welcome-day-2-afternoon.md
new file mode 100644
index 00000000..f0816800
--- /dev/null
+++ b/src/welcome-day-2-afternoon.md
@@ -0,0 +1,7 @@
+---
+session: Day 2 Afternoon
+---
+
+# Welcome Back
+
+{{%session outline}}
diff --git a/src/welcome-day-2.md b/src/welcome-day-2.md
index a86e6dbe..939823b4 100644
--- a/src/welcome-day-2.md
+++ b/src/welcome-day-2.md
@@ -1,15 +1,20 @@
+---
+minutes: 3
+course: Fundamentals
+session: Day 2 Morning
+---
+
 # Welcome to Day 2
 
-Now that we have seen a fair amount of Rust, we will continue with:
+Now that we have seen a fair amount of Rust, today will focus on Rust's type
+system:
 
-* Memory management: stack vs heap, manual memory management, scope-based memory
-  management, and garbage collection.
+ * Pattern matching: extracting data from structures.
+ * Methods: associating functions with types.
+ * Traits: behaviors shared by multiple types.
+ * Generics: parameterizing types on other types.
+ * Standard library types and traits: a tour of Rust's rich standard library.
 
-* Ownership: move semantics, copying and cloning, borrowing, and lifetimes.
+## Schedule
 
-* Structs and methods.
-
-* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, `Rc`
-  and `Arc`.
-
-* Modules: visibility, paths, and filesystem hierarchy.
+{{%session outline}}
diff --git a/src/welcome-day-3-afternoon.md b/src/welcome-day-3-afternoon.md
new file mode 100644
index 00000000..1e106e8e
--- /dev/null
+++ b/src/welcome-day-3-afternoon.md
@@ -0,0 +1,7 @@
+---
+session: Day 3 Afternoon
+---
+
+# Welcome Back
+
+{{%session outline}}
diff --git a/src/welcome-day-3.md b/src/welcome-day-3.md
index 8e2fcf68..f15bf895 100644
--- a/src/welcome-day-3.md
+++ b/src/welcome-day-3.md
@@ -1,16 +1,16 @@
+---
+minutes: 3
+course: Fundamentals
+session: Day 3 Morning
+---
+
 # Welcome to Day 3
 
-Today, we will cover some more advanced topics of Rust:
+Today, we will cover:
 
-* Traits: deriving traits, default methods, and important standard library
-  traits.
+* Memory management, lifetimes, and the borrow checker: how Rust ensures memory safety.
+* Smart pointers: standard library pointer types.
 
-* Generics: generic data types, generic methods, monomorphization, and trait
-  objects.
+## Schedule
 
-* Error handling: panics, `Result`, and the try operator `?`.
-
-* Testing: unit tests, documentation tests, and integration tests.
-
-* Unsafe Rust: raw pointers, static variables, unsafe functions, and extern
-  functions.
+{{%session outline}}
diff --git a/src/welcome-day-4-afternoon.md b/src/welcome-day-4-afternoon.md
new file mode 100644
index 00000000..7f952909
--- /dev/null
+++ b/src/welcome-day-4-afternoon.md
@@ -0,0 +1,7 @@
+---
+session: Day 4 Afternoon
+---
+
+# Welcome Back
+
+{{%session outline}}
diff --git a/src/welcome-day-4.md b/src/welcome-day-4.md
new file mode 100644
index 00000000..81acd1f1
--- /dev/null
+++ b/src/welcome-day-4.md
@@ -0,0 +1,19 @@
+---
+minutes: 3
+course: Fundamentals
+session: Day 4 Morning
+---
+
+# Welcome to Day 4
+
+Today we will cover topics relating to building large-scale software in Rust:
+
+* Iterators: a deep dive on the `Iterator` trait.
+* Modules and visibility.
+* Testing.
+* Error handling: panics, `Result`, and the try operator `?`.
+* Unsafe Rust: the escape hatch when you can't express yourself in safe Rust.
+
+## Schedule
+
+{{%session outline}}
diff --git a/src/why-rust.md b/src/why-rust.md
deleted file mode 100644
index 3a16eafc..00000000
--- a/src/why-rust.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# Why Rust?
-
-Some unique selling points of Rust:
-
-* Compile time memory safety.
-* Lack of undefined runtime behavior.
-* Modern language features.
-
-<details>
-
-Make sure to ask the class which languages they have experience with. Depending
-on the answer you can highlight different features of Rust:
-
-* Experience with C or C++: Rust eliminates a whole class of _runtime errors_
-  via the borrow checker. You get performance like in C and C++, but you don't
-  have the memory unsafety issues. In addition, you get a modern language with
-  constructs like pattern matching and built-in dependency management.
-
-* Experience with Java, Go, Python, JavaScript...: You get the same memory safety
-  as in those languages, plus a similar high-level language feeling. In addition
-  you get fast and predictable performance like C and C++ (no garbage collector)
-  as well as access to low-level hardware (should you need it)
-
-</details>
diff --git a/src/why-rust/compile-time.md b/src/why-rust/compile-time.md
deleted file mode 100644
index a3418721..00000000
--- a/src/why-rust/compile-time.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Compile Time Guarantees
-
-Static memory management at compile time:
-
-* No uninitialized variables.
-* No memory leaks (_mostly_, see notes).
-* No double-frees.
-* No use-after-free.
-* No `NULL` pointers.
-* No forgotten locked mutexes.
-* No data races between threads.
-* No iterator invalidation.
-
-<details>
-
-It is possible to produce memory leaks in (safe) Rust. Some examples
-are:
-
-* You can use [`Box::leak`] to leak a pointer. A use of this could
-  be to get runtime-initialized and runtime-sized static variables
-* You can use [`std::mem::forget`] to make the compiler "forget" about
-  a value (meaning the destructor is never run).
-* You can also accidentally create a [reference cycle] with `Rc` or
-  `Arc`.
-* In fact, some will consider infinitely populating a collection a memory
-  leak and Rust does not protect from those.
-
-For the purpose of this course, "No memory leaks" should be understood
-as "Pretty much no *accidental* memory leaks".
-
-[`Box::leak`]: https://doc.rust-lang.org/std/boxed/struct.Box.html#method.leak
-[`std::mem::forget`]: https://doc.rust-lang.org/std/mem/fn.forget.html
-[reference cycle]: https://doc.rust-lang.org/book/ch15-06-reference-cycles.html
-
-</details>
diff --git a/src/why-rust/modern.md b/src/why-rust/modern.md
deleted file mode 100644
index c8761333..00000000
--- a/src/why-rust/modern.md
+++ /dev/null
@@ -1,66 +0,0 @@
-# Modern Features
-
-Rust is built with all the experience gained in the last decades.
-
-## Language Features
-
-* Enums and pattern matching.
-* Generics.
-* No overhead FFI.
-* Zero-cost abstractions.
-
-## Tooling
-
-* Great compiler errors.
-* Built-in dependency manager.
-* Built-in support for testing.
-* Excellent Language Server Protocol support.
-
-<details>
-
-Key points:
-
-* Zero-cost abstractions, similar to C++, means that you don't have to 'pay'
-  for higher-level programming constructs with memory or CPU. For example,
-  writing a loop using `for` should result in roughly the same low level
-  instructions as using the `.iter().fold()` construct.
-
-* It may be worth mentioning that Rust enums are 'Algebraic Data Types', also
-  known as 'sum types', which allow the type system to express things like
-  `Option<T>` and `Result<T, E>`.
-
-* Remind people to read the errors --- many developers have gotten used to
-  ignore lengthy compiler output. The Rust compiler is significantly more
-  talkative than other compilers. It will often provide you with _actionable_
-  feedback, ready to copy-paste into your code.
-
-* The Rust standard library is small compared to languages like Java, Python,
-  and Go. Rust does not come with several things you might consider standard and
-  essential:
-
-  * a random number generator, but see [rand].
-  * support for SSL or TLS, but see [rusttls].
-  * support for JSON, but see [serde_json].
-
-  The reasoning behind this is that functionality in the standard library cannot
-  go away, so it has to be very stable. For the examples above, the Rust
-  community is still working on finding the best solution --- and perhaps there
-  isn't a single "best solution" for some of these things.
-
-  Rust comes with a built-in package manager in the form of Cargo and this makes
-  it trivial to download and compile third-party crates. A consequence of this
-  is that the standard library can be smaller.
-
-  Discovering good third-party crates can be a problem. Sites like
-  <https://lib.rs/> help with this by letting you compare health metrics for
-  crates to find a good and trusted one.
-  
-* [rust-analyzer] is a well supported LSP implementation used in major
-  IDEs and text editors.
-
-[rand]: https://docs.rs/rand/
-[rusttls]: https://docs.rs/rustls/
-[serde_json]: https://docs.rs/serde_json/
-[rust-analyzer]: https://rust-analyzer.github.io/
-
-</details>
diff --git a/src/why-rust/runtime.md b/src/why-rust/runtime.md
deleted file mode 100644
index efabc3d2..00000000
--- a/src/why-rust/runtime.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Runtime Guarantees
-
-No undefined behavior at runtime:
-
-* Array access is bounds checked.
-* Integer overflow is defined (panic or wrap-around).
-
-<details>
-
-Key points:
-
-* Integer overflow is defined via the [`overflow-checks`](https://doc.rust-lang.org/rustc/codegen-options/index.html#overflow-checks)
-  compile-time flag. If enabled, the program will panic (a controlled
-  crash of the program), otherwise you get wrap-around
-  semantics. By default, you get panics in debug mode (`cargo build`)
-  and wrap-around in release mode (`cargo build --release`).
-
-* Bounds checking cannot be disabled with a compiler flag. It can also
-  not be disabled directly with the `unsafe` keyword. However,
-  `unsafe` allows you to call functions such as `slice::get_unchecked`
-  which does not do bounds checking.
-
-</details>
diff --git a/theme/css/frontmatter.css b/theme/css/frontmatter.css
deleted file mode 100644
index ab367ad4..00000000
--- a/theme/css/frontmatter.css
+++ /dev/null
@@ -1,7 +0,0 @@
-pre.frontmatter {
-  float: right;
-  font-size: 80%;
-  width: 40%;
-  background: var(--sidebar-bg);
-  padding: 0.25em;
-}
diff --git a/third_party/rust-on-exercism/health-statistics.rs b/third_party/rust-on-exercism/health-statistics.rs
index 70b8249a..e94c0972 100644
--- a/third_party/rust-on-exercism/health-statistics.rs
+++ b/third_party/rust-on-exercism/health-statistics.rs
@@ -1,5 +1,7 @@
 // ANCHOR: solution
 // ANCHOR: setup
+
+#![allow(dead_code)]
 pub struct User {
     name: String,
     age: u32,
@@ -21,10 +23,7 @@ pub struct HealthReport<'a> {
 }
 
 impl User {
-    // ANCHOR_END: setup
-    // ANCHOR: User_new
     pub fn new(name: String, age: u32, height: f32) -> Self {
-        // ANCHOR_END: User_new
         Self {
             name,
             age,
@@ -33,42 +32,7 @@ impl User {
             last_blood_pressure: None,
         }
     }
-
-    // ANCHOR: User_name
-    pub fn name(&self) -> &str {
-        // ANCHOR_END: User_name
-        &self.name
-    }
-
-    // ANCHOR: User_age
-    pub fn age(&self) -> u32 {
-        // ANCHOR_END: User_age
-        self.age
-    }
-
-    // ANCHOR: User_height
-    pub fn height(&self) -> f32 {
-        // ANCHOR_END: User_height
-        self.height
-    }
-
-    // ANCHOR: User_doctor_visits
-    pub fn doctor_visits(&self) -> u32 {
-        // ANCHOR_END: User_doctor_visits
-        self.visit_count as u32
-    }
-
-    // ANCHOR: User_set_age
-    pub fn set_age(&mut self, new_age: u32) {
-        // ANCHOR_END: User_set_age
-        self.age = new_age
-    }
-
-    // ANCHOR: User_set_height
-    pub fn set_height(&mut self, new_height: f32) {
-        // ANCHOR_END: User_set_height
-        self.height = new_height
-    }
+    // ANCHOR_END: setup
 
     // ANCHOR: User_visit_doctor
     pub fn visit_doctor(&mut self, measurements: Measurements) -> HealthReport {
@@ -80,12 +44,11 @@ impl User {
             visit_count: self.visit_count as u32,
             height_change: measurements.height - self.height,
             blood_pressure_change: match self.last_blood_pressure {
-                Some(lbp) => Some((
-                    bp.0 as i32 - lbp.0 as i32,
-                    bp.1 as i32 - lbp.1 as i32
-                )),
+                Some(lbp) => {
+                    Some((bp.0 as i32 - lbp.0 as i32, bp.1 as i32 - lbp.1 as i32))
+                }
                 None => None,
-            }
+            },
         };
         self.height = measurements.height;
         self.last_blood_pressure = Some(bp);
@@ -96,29 +59,15 @@ impl User {
 // ANCHOR: main
 fn main() {
     let bob = User::new(String::from("Bob"), 32, 155.2);
-    println!("I'm {} and my age is {}", bob.name(), bob.age());
+    println!("I'm {} and my age is {}", bob.name, bob.age);
 }
 // ANCHOR_END: main
 
 // ANCHOR: tests
-#[test]
-fn test_height() {
-    let bob = User::new(String::from("Bob"), 32, 155.2);
-    assert_eq!(bob.height(), 155.2);
-}
-
-#[test]
-fn test_set_age() {
-    let mut bob = User::new(String::from("Bob"), 32, 155.2);
-    assert_eq!(bob.age(), 32);
-    bob.set_age(33);
-    assert_eq!(bob.age(), 33);
-}
-
 #[test]
 fn test_visit() {
     let mut bob = User::new(String::from("Bob"), 32, 155.2);
-    assert_eq!(bob.doctor_visits(), 0);
+    assert_eq!(bob.visit_count, 0);
     let report = bob.visit_doctor(Measurements {
         height: 156.1,
         blood_pressure: (120, 80),