diff --git a/examples/slices/slices.go b/examples/slices/slices.go
index a30a9d0..c44cca0 100644
--- a/examples/slices/slices.go
+++ b/examples/slices/slices.go
@@ -10,15 +10,17 @@ func main() {
     // Unlike arrays, slices are typed only by the
     // elements they contain (not the number of elements).
     // To create an empty slice with non-zero length, use
-    // the builtin `make`. Here we make a slice of `int`s
-    // of length `5` (initially zero-valued).
-    s := make([]int, 5)
+    // the builtin `make`. Here we make a slice of
+    // `string`s of length `3` (initially zero-valued).
+    s := make([]string, 3)
     fmt.Println("emp:", s)
 
     // We can set and get just like with arrays.
-    s[4] = 100
+    s[0] = "a"
+    s[1] = "b"
+    s[2] = "c"
     fmt.Println("set:", s)
-    fmt.Println("get:", s[4])
+    fmt.Println("get:", s[2])
 
     // `len` returns the length of the slice as expected.
     fmt.Println("len:", len(s))
@@ -29,34 +31,34 @@ func main() {
     // returns a slice containing one or more new values.
     // Note that we need to accept a return value from
     // append as we may get a new slice value.
-    s = append(s, 6)
-    s = append(s, 7, 8)
+    s = append(s, "d")
+    s = append(s, "e", "f")
     fmt.Println("apd:", s)
 
     // Slices can also be `copy`'d. Here we create an
     // empty slice `c` of the same length as `s` and copy
     // into `c` from `s`.
-    c := make([]int, len(s))
+    c := make([]string, len(s))
     copy(c, s)
     fmt.Println("cpy:", c)
 
     // Slices support a "slice" operator with the syntax
     // `slice[low:high]`. For example, this gets a slice
-    // of the elements 4, 5, and 6.
-    l := s[4:7]
+    // of the elements `s[2]`, `s[3]`, and `s[4]`.
+    l := s[2:5]
     fmt.Println("sl1:", l)
 
-    // This slices up to the 7th index.
-    l = s[:7]
+    // This slices up to (but excluding) `s[5]`.
+    l = s[:5]
     fmt.Println("sl2:", l)
 
-    // And this slices from the 4th index upwards.
-    l = s[4:]
+    // And this slices up from (and including) `s[2]`.
+    l = s[2:]
     fmt.Println("sl3:", l)
 
     // We can declare and initialize a variable for slice
     // in a single line as well.
-    t := []int{1, 2, 3, 4, 5}
+    t := []string{"g", "h", "i"}
     fmt.Println("dcl:", t)
 
     // Slices can be composed into multi-dimensional data
diff --git a/examples/slices/slices.sh b/examples/slices/slices.sh
index dde66d7..9d40831 100644
--- a/examples/slices/slices.sh
+++ b/examples/slices/slices.sh
@@ -1,16 +1,16 @@
 # Note that while slices are different types than arrays,
 # they are rendered similarly by `fmt.Println`.
 $ go run slices.go
-emp: [0 0 0 0 0]
-set: [0 0 0 0 100]
-get: 100
-len: 5
-apd: [0 0 0 0 100 6 7 8]
-cpy: [0 0 0 0 100 6 7 8]
-sl1: [100 6 7]
-sl2: [0 0 0 0 100 6 7]
-sl3: [100 6 7 8]
-dcl: [1 2 3 4 5]
+emp: [  ]
+set: [a b c]
+get: c
+len: 3
+apd: [a b c d e f]
+cpy: [a b c d e f]
+sl1: [c d e]
+sl2: [a b c d e]
+sl3: [c d e f]
+dcl: [g h i]
 2d:  [[0] [1 2] [2 3 4]]
 
 # Check out this [great blog post](http://blog.golang.org/2011/01/go-slices-usage-and-internals.html)