diff --git a/content/moretypes.article b/content/moretypes.article
index a410fb5..bfae74f 100644
--- a/content/moretypes.article
+++ b/content/moretypes.article
@@ -64,6 +64,7 @@
 
 .play moretypes/struct-literals.go
 
+
 * Arrays
 
 The type `[n]T` is an array of `n` values of type `T`.
@@ -80,45 +81,110 @@
 
 .play moretypes/array.go
 
+
 * Slices
 
-A slice points to an array of values and also includes a length.
+An array has a fixed size.
+A slice, on the other hand, is a dynamically-sized,
+flexible view into the elements of an array.
+In practice, slices are much more common than arrays.
 
-`[]T` is a slice with elements of type `T`.
+The type `[]T` is a slice with elements of type `T`.
 
-`len(primes)` returns the length of slice `primes`.
+This expression creates a slice of the first five elements of the array `a`:
+
+	a[0:5]
+
 
 .play moretypes/slices.go
 
-* Slices of Slices
 
-Slices can contain any type, including other slices.
+* Slices are like references to arrays
 
-.play moretypes/slices-of-slice.go
+A slice does not store any data,
+it just describes a section of an underlying array.
 
-* Slicing slices
+Changing the elements of a slice modifies the
+corresponding elements of its underlying array.
 
-Slices can be re-sliced, creating a new slice value that points to the same array.
+Other slices that share the same underlying array will see those changes.
 
-The expression
+.play moretypes/slices-pointers.go
 
-	s[lo:hi]
 
-evaluates to a slice of the elements from `lo` through `hi-1`, inclusive. Thus
+* Slice literals
 
-	s[lo:lo]
+A slice literal is like an array literal without the length.
 
-is empty and
+This is an array literal:
 
-	s[lo:lo+1]
+	[3]bool{true, true, false}
 
-has one element.
+And this creates the same array as above,
+then builds a slice that references it:
 
-.play moretypes/slicing-slices.go
+	[]bool{true, true, false}
 
-* Making slices
+.play moretypes/slice-literals.go
 
-Slices are created with the `make` function. It works by allocating a zeroed array and returning a slice that refers to that array:
+
+* Slice defaults
+
+When slicing, you may omit the high or low bounds to use their defaults instead.
+
+The default is zero for the low bound and the length of the slice for the high bound.
+
+For the array
+
+	var a [10]int
+
+these slice expressions are equivalent:
+
+	a[0:10]
+	a[:10]
+	a[0:]
+	a[:]
+
+.play moretypes/slice-bounds.go
+
+
+* Slice length and capacity
+
+A slice has both a _length_ and a _capacity_.
+
+The length of a slice is the number of elements it contains.
+
+The capacity of a slice is the number of elements in the underlying array,
+counting from the first element in the slice.
+
+The length and capacity of a slice `s` can be obtained using the expressions
+`len(s)` and `cap(s)`.
+
+You can extend a slice's length by re-slicing it,
+provided it has sufficient capacity.
+Try changing one of the slice operations in the example program to extend it
+beyond its capacity and see what happens.
+
+.play moretypes/slice-len-cap.go
+
+
+* Nil slices
+
+The zero value of a slice is `nil`.
+
+A nil slice has a length and capacity of 0
+and has no underlying array.
+
+.play moretypes/nil-slices.go
+
+
+* Creating a slice with make
+
+Slices can be created with the built-in `make` function;
+this is how you create dynamically-sized arrays.
+
+The `make` function allocates a zeroed array
+and returns a slice that refers to that array:
 
 	a := make([]int, 5)  // len(a)=5
 
@@ -131,15 +197,15 @@
 
 .play moretypes/making-slices.go
 
-* Nil slices
 
-The zero value of a slice is `nil`.
+* Slices of slices
 
-A nil slice has a length and capacity of 0.
+Slices can contain any type, including other slices.
 
-.play moretypes/nil-slices.go
+.play moretypes/slices-of-slice.go
 
-* Adding elements to a slice
+
+* Appending to a slice
 
 It is common to append new elements to a slice, and so Go provides a built-in
 `append` function. The [[https://golang.org/pkg/builtin/#append][documentation]]
@@ -161,6 +227,7 @@
 
 .play moretypes/append.go
 
+
 * Range
 
 The `range` form of the `for` loop iterates over a slice or map.
diff --git a/content/moretypes/array.go b/content/moretypes/array.go
index 8626743..8d73573 100644
--- a/content/moretypes/array.go
+++ b/content/moretypes/array.go
@@ -10,4 +10,7 @@
 	a[1] = "World"
 	fmt.Println(a[0], a[1])
 	fmt.Println(a)
+
+	primes := [6]int{2, 3, 5, 7, 11, 13}
+	fmt.Println(primes)
 }
diff --git a/content/moretypes/slice-bounds.go b/content/moretypes/slice-bounds.go
new file mode 100644
index 0000000..1ba3963
--- /dev/null
+++ b/content/moretypes/slice-bounds.go
@@ -0,0 +1,18 @@
+// +build OMIT
+
+package main
+
+import "fmt"
+
+func main() {
+	s := []int{2, 3, 5, 7, 11, 13}
+
+	s = s[1:4]
+	fmt.Println(s)
+
+	s = s[:2]
+	fmt.Println(s)
+
+	s = s[1:]
+	fmt.Println(s)
+}
diff --git a/content/moretypes/slice-len-cap.go b/content/moretypes/slice-len-cap.go
new file mode 100644
index 0000000..a1c5764
--- /dev/null
+++ b/content/moretypes/slice-len-cap.go
@@ -0,0 +1,26 @@
+// +build OMIT
+
+package main
+
+import "fmt"
+
+func main() {
+	s := []int{2, 3, 5, 7, 11, 13}
+	printSlice(s)
+
+	// Slice the slice to give it zero length.
+	s = s[:0]
+	printSlice(s)
+
+	// Extend its length.
+	s = s[:4]
+	printSlice(s)
+
+	// Drop its first two values.
+	s = s[2:]
+	printSlice(s)
+}
+
+func printSlice(s []int) {
+	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
+}
diff --git a/content/moretypes/slice-literals.go b/content/moretypes/slice-literals.go
new file mode 100644
index 0000000..5a98010
--- /dev/null
+++ b/content/moretypes/slice-literals.go
@@ -0,0 +1,26 @@
+// +build OMIT
+
+package main
+
+import "fmt"
+
+func main() {
+	q := []int{2, 3, 5, 7, 11, 13}
+	fmt.Println(q)
+
+	r := []bool{true, false, true, true, false, true}
+	fmt.Println(r)
+
+	s := []struct {
+		i int
+		b bool
+	}{
+		{2, true},
+		{3, false},
+		{5, true},
+		{7, true},
+		{11, false},
+		{13, true},
+	}
+	fmt.Println(s)
+}
diff --git a/content/moretypes/slices-pointers.go b/content/moretypes/slices-pointers.go
new file mode 100644
index 0000000..193b463
--- /dev/null
+++ b/content/moretypes/slices-pointers.go
@@ -0,0 +1,23 @@
+// +build OMIT
+
+package main
+
+import "fmt"
+
+func main() {
+	names := [4]string{
+		"John",
+		"Paul",
+		"George",
+		"Ringo",
+	}
+	fmt.Println(names)
+
+	a := names[0:2]
+	b := names[1:3]
+	fmt.Println(a, b)
+
+	b[0] = "XXX"
+	fmt.Println(a, b)
+	fmt.Println(names)
+}
diff --git a/content/moretypes/slices.go b/content/moretypes/slices.go
index 385283c..7720f84 100644
--- a/content/moretypes/slices.go
+++ b/content/moretypes/slices.go
@@ -5,10 +5,8 @@
 import "fmt"
 
 func main() {
-	primes := []int{2, 3, 5, 7, 11, 13}
-	fmt.Println("primes ==", primes)
+	primes := [6]int{2, 3, 5, 7, 11, 13}
 
-	for i := 0; i < len(primes); i++ {
-		fmt.Printf("primes[%d] == %d\n", i, primes[i])
-	}
+	var s []int = primes[1:4]
+	fmt.Println(s)
 }
diff --git a/content/moretypes/slicing-slices.go b/content/moretypes/slicing-slices.go
deleted file mode 100644
index 27e1aef..0000000
--- a/content/moretypes/slicing-slices.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// +build OMIT
-
-package main
-
-import "fmt"
-
-func main() {
-	s := []int{2, 3, 5, 7, 11, 13}
-	fmt.Println("s ==", s)
-	fmt.Println("s[1:4] ==", s[1:4])
-
-	// missing low index implies 0
-	fmt.Println("s[:3] ==", s[:3])
-
-	// missing high index implies len(s)
-	fmt.Println("s[4:] ==", s[4:])
-}