diff --git a/src/basic-syntax/compound-types.md b/src/basic-syntax/compound-types.md
index 7cb2faf2..5a2cfc76 100644
--- a/src/basic-syntax/compound-types.md
+++ b/src/basic-syntax/compound-types.md
@@ -26,16 +26,21 @@ fn main() {
 ```
 
 <details>
-    
+
 Key points:
-    
+
 Arrays:
-    
+
 * Arrays have elements of the same type, `T`, and length, `N`, which is a compile-time constant.
+  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.
 
 * We can use literals to assign values to arrays.
 
-* In the main function, the print statement asks for the debug implementation with the `?` format parameter: `{a}` gives the default output, `{a:?}` gives the debug output.
+* In the main function, the print statement asks for the debug implementation with the `?` format
+  parameter: `{}` gives the default output, `{:?}` gives the debug output. We
+  could also have used `{a}` and `{a:?}` without specifying the value after the
+  format string.
 
 * Adding `#`, eg `{a:#?}`, invokes a "pretty printing" format, which can be easier to read.
 
@@ -45,6 +50,11 @@ Tuples:
 
 * Tuples group together values of different types into a compound type.
 
-* Fields that can be accessed by the period and the index of the value, e.g. `t.0`, `t.1`.
+* Fields of a tuple can be accessed by the period and the index of the value, e.g. `t.0`, `t.1`.
+
+* 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.
 
 </details>
diff --git a/src/basic-syntax/references.md b/src/basic-syntax/references.md
index 02ebc553..0bb64fdf 100644
--- a/src/basic-syntax/references.md
+++ b/src/basic-syntax/references.md
@@ -11,9 +11,18 @@ fn main() {
 }
 ```
 
-Some differences from C++:
+Some notes:
 
-* We must dereference `ref_x` when assigning to it, similar to C pointers,
+* 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 `count_ones`).
+  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/why-rust/modern.md b/src/why-rust/modern.md
index 2ed58096..85375e6c 100644
--- a/src/why-rust/modern.md
+++ b/src/why-rust/modern.md
@@ -7,6 +7,7 @@ Rust is built with all the experience gained in the last 40 years.
 * Enums and pattern matching.
 * Generics.
 * No overhead FFI.
+* Zero-cost abstractions.
 
 ## Tooling
 
@@ -18,6 +19,15 @@ Rust is built with all the experience gained in the last 40 years.
 
 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 lengthly compiler output. The Rust compiler is significantly more
   talkative than other compilers. It will often provide you with _actionable_