diff --git a/src/effectivejava/chapter11/item83/Initialization.java b/src/effectivejava/chapter11/item83/Initialization.java
index 15f40bff..83f05e0c 100644
--- a/src/effectivejava/chapter11/item83/Initialization.java
+++ b/src/effectivejava/chapter11/item83/Initialization.java
@@ -25,6 +25,7 @@ private static class FieldHolder {
     // Double-check idiom for lazy initialization of instance fields - Page 334
     private volatile FieldType field4;
 
+    // NOTE: The code for this method in the first printing had a serious error (see errata for details)!
     private FieldType getField4() {
         FieldType result = field4;
         if (result != null)    // First check (no locking)
@@ -38,6 +39,7 @@ private FieldType getField4() {
     }
 
 
+
     // Single-check idiom - can cause repeated initialization! - Page 334
     private volatile FieldType field5;
 
diff --git a/src/effectivejava/chapter5/item28/Chooser.java b/src/effectivejava/chapter5/item28/Chooser.java
index 5eaa1903..259ab264 100644
--- a/src/effectivejava/chapter5/item28/Chooser.java
+++ b/src/effectivejava/chapter5/item28/Chooser.java
@@ -6,7 +6,7 @@
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
-// List-based Chooser - typesafe (Page 120)
+// List-based Chooser - typesafe (Page 129)
 public class Chooser<T> {
     private final List<T> choiceList;
 
@@ -18,4 +18,15 @@ public T choose() {
         Random rnd = ThreadLocalRandom.current();
         return choiceList.get(rnd.nextInt(choiceList.size()));
     }
+
+    public static void main(String[] args) {
+        List<Integer> intList = List.of(1, 2, 3, 4, 5, 6);
+
+        Chooser<Integer> chooser = new Chooser<>(intList);
+
+        for (int i = 0; i < 10; i++) {
+            Number choice = chooser.choose();
+            System.out.println(choice);
+        }
+    }
 }
diff --git a/src/effectivejava/chapter5/item29/technqiue1/Stack.java b/src/effectivejava/chapter5/item29/technqiue1/Stack.java
index 5d7b2930..fbaa60b7 100644
--- a/src/effectivejava/chapter5/item29/technqiue1/Stack.java
+++ b/src/effectivejava/chapter5/item29/technqiue1/Stack.java
@@ -3,7 +3,7 @@
 
 import java.util.Arrays;
 
-// Generic stack using E[] - Pages 130-133
+// Generic stack using E[] (Pages 130-3)
 public class Stack<E> {
     private E[] elements;
     private int size = 0;
diff --git a/src/effectivejava/chapter5/item29/technqiue2/Stack.java b/src/effectivejava/chapter5/item29/technqiue2/Stack.java
index f7e62cc2..bf1632d3 100644
--- a/src/effectivejava/chapter5/item29/technqiue2/Stack.java
+++ b/src/effectivejava/chapter5/item29/technqiue2/Stack.java
@@ -3,7 +3,7 @@
 import java.util.Arrays;
 import effectivejava.chapter5.item29.EmptyStackException;
 
-// Generic stack using Object[] - Pages 130-133
+// Generic stack using Object[] (Pages 130-3)
 public class Stack<E> {
     private Object[] elements;
     private int size = 0;
diff --git a/src/effectivejava/chapter5/item30/GenericSingletonFactory.java b/src/effectivejava/chapter5/item30/GenericSingletonFactory.java
index 40cd9cf8..6f27af8b 100644
--- a/src/effectivejava/chapter5/item30/GenericSingletonFactory.java
+++ b/src/effectivejava/chapter5/item30/GenericSingletonFactory.java
@@ -1,10 +1,8 @@
 package effectivejava.chapter5.item30;
 
-// Generic singleton factory staticfactory - Pages 131-132
-
 import java.util.function.UnaryOperator;
 
-// Generic singleton factory pattern (Page 136)
+// Generic singleton factory pattern (Page 136-7)
 public class GenericSingletonFactory {
     // Generic singleton factory pattern
     private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;
diff --git a/src/effectivejava/chapter5/item30/RecursiveTypeBound.java b/src/effectivejava/chapter5/item30/RecursiveTypeBound.java
index 0b9e97b1..e3419dfc 100644
--- a/src/effectivejava/chapter5/item30/RecursiveTypeBound.java
+++ b/src/effectivejava/chapter5/item30/RecursiveTypeBound.java
@@ -1,7 +1,7 @@
 package effectivejava.chapter5.item30;
 import java.util.*;
 
-// Using a recursive type bound to express mutual comparability - Pages 136-137
+// Using a recursive type bound to express mutual comparability (Pages 137-8)
 public class RecursiveTypeBound {
     // Returns max value in a collection - uses recursive type bound
     public static <E extends Comparable<E>> E max(Collection<E> c) {
diff --git a/src/effectivejava/chapter5/item30/Union.java b/src/effectivejava/chapter5/item30/Union.java
index 47f595fc..5ecb202f 100644
--- a/src/effectivejava/chapter5/item30/Union.java
+++ b/src/effectivejava/chapter5/item30/Union.java
@@ -1,7 +1,7 @@
 package effectivejava.chapter5.item30;
 import java.util.*;
 
-// Generic union method and program to exercise it - pages 135-6
+// Generic union method and program to exercise it  (Pages 135-6)
 public class Union {
 
     // Generic method
diff --git a/src/effectivejava/chapter5/item32/Chooser.java b/src/effectivejava/chapter5/item31/Chooser.java
similarity index 86%
rename from src/effectivejava/chapter5/item32/Chooser.java
rename to src/effectivejava/chapter5/item31/Chooser.java
index fe3e2aed..bb8443d0 100644
--- a/src/effectivejava/chapter5/item32/Chooser.java
+++ b/src/effectivejava/chapter5/item31/Chooser.java
@@ -1,10 +1,11 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Random;
 
+// Wildcard type for parameter that serves as an T producer (page 141)
 public class Chooser<T> {
     private final List<T> choiceList;
     private final Random rnd = new Random();
diff --git a/src/effectivejava/chapter5/item32/EmptyStackException.java b/src/effectivejava/chapter5/item31/EmptyStackException.java
similarity index 61%
rename from src/effectivejava/chapter5/item32/EmptyStackException.java
rename to src/effectivejava/chapter5/item31/EmptyStackException.java
index 7af3c4c2..d5a8219b 100644
--- a/src/effectivejava/chapter5/item32/EmptyStackException.java
+++ b/src/effectivejava/chapter5/item31/EmptyStackException.java
@@ -1,4 +1,4 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 
 public class EmptyStackException extends RuntimeException {
 }
diff --git a/src/effectivejava/chapter5/item32/RecursiveTypeBound.java b/src/effectivejava/chapter5/item31/RecursiveTypeBound.java
similarity index 84%
rename from src/effectivejava/chapter5/item32/RecursiveTypeBound.java
rename to src/effectivejava/chapter5/item31/RecursiveTypeBound.java
index 7870961b..d50aa1cf 100644
--- a/src/effectivejava/chapter5/item32/RecursiveTypeBound.java
+++ b/src/effectivejava/chapter5/item31/RecursiveTypeBound.java
@@ -1,7 +1,7 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Using a recursive type bound with wildcards - Page 138-139
+// Using a recursive type bound with wildcards (Page 143)
 public class RecursiveTypeBound {
     public static <E extends Comparable<? super E>> E max(
         List<? extends E> list) {
diff --git a/src/effectivejava/chapter5/item32/Stack.java b/src/effectivejava/chapter5/item31/Stack.java
similarity index 89%
rename from src/effectivejava/chapter5/item32/Stack.java
rename to src/effectivejava/chapter5/item31/Stack.java
index 7bc47d6b..a5abe59d 100644
--- a/src/effectivejava/chapter5/item32/Stack.java
+++ b/src/effectivejava/chapter5/item31/Stack.java
@@ -1,7 +1,7 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Generic stack with bulk methods using wildcard types - Pages 138-140
+// Generic stack with bulk methods using wildcard types (Pages 139-41)
 public class Stack<E> {
     private E[] elements;
     private int size = 0;
@@ -63,11 +63,11 @@ public void popAll(Collection<? super E> dst) {
 
     // Little program to exercise our generic Stack
     public static void main(String[] args) {
-        Stack<Number> numberStack = new Stack<Number>();
+        Stack<Number> numberStack = new Stack<>();
         Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
         numberStack.pushAll(integers);
 
-        Collection<Object> objects = new ArrayList<Object>();
+        Collection<Object> objects = new ArrayList<>();
         numberStack.popAll(objects);
 
         System.out.println(objects);
diff --git a/src/effectivejava/chapter5/item32/Swap.java b/src/effectivejava/chapter5/item31/Swap.java
similarity index 75%
rename from src/effectivejava/chapter5/item32/Swap.java
rename to src/effectivejava/chapter5/item31/Swap.java
index 171d5cbc..776f886f 100644
--- a/src/effectivejava/chapter5/item32/Swap.java
+++ b/src/effectivejava/chapter5/item31/Swap.java
@@ -1,13 +1,13 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Private helper staticfactory for wildcard capture - Pages 139-140
+// Private helper method for wildcard capture (Page 145)
 public class Swap {
     public static void swap(List<?> list, int i, int j) {
         swapHelper(list, i, j);
     }
 
-    // Private helper staticfactory for wildcard capture
+    // Private helper method for wildcard capture
     private static <E> void swapHelper(List<E> list, int i, int j) {
         list.set(i, list.set(j, list.get(i)));
     }
diff --git a/src/effectivejava/chapter5/item32/Union.java b/src/effectivejava/chapter5/item31/Union.java
similarity index 74%
rename from src/effectivejava/chapter5/item32/Union.java
rename to src/effectivejava/chapter5/item31/Union.java
index 79fb4009..71cc58b8 100644
--- a/src/effectivejava/chapter5/item32/Union.java
+++ b/src/effectivejava/chapter5/item31/Union.java
@@ -1,9 +1,8 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Generic union staticfactory with wildcard types - Pages 137-138
+// Generic union method with wildcard types for enhanced flexibility (Pages 142-3)
 public class Union {
-
     public static <E> Set<E> union(Set<? extends E> s1,
                                    Set<? extends E> s2) {
         Set<E> result = new HashSet<E>(s1);
@@ -25,6 +24,9 @@ public static void main(String[] args) {
 
         Set<Number> numbers = union(integers, doubles);
 
+//      // Explicit type parameter - required prior to Java 8
+//      Set<Number> numbers = Union.<Number>union(integers, doubles);
+
         System.out.println(numbers);
     }
 }
diff --git a/src/effectivejava/chapter5/item32/Dangerous.java b/src/effectivejava/chapter5/item32/Dangerous.java
new file mode 100644
index 00000000..fdd1a499
--- /dev/null
+++ b/src/effectivejava/chapter5/item32/Dangerous.java
@@ -0,0 +1,18 @@
+package effectivejava.chapter5.item32;
+
+import java.util.List;
+
+// It is unsafe to store a value in a generic varargs array parameter (Page 146)
+public class Dangerous {
+    // Mixing generics and varargs can violate type safety!
+    static void dangerous(List<String>... stringLists) {
+        List<Integer> intList = List.of(42);
+        Object[] objects = stringLists;
+        objects[0] = intList; // Heap pollution
+        String s = stringLists[0].get(0); // ClassCastException
+    }
+
+    public static void main(String[] args) {
+        dangerous(List.of("There be dragons!"));
+    }
+}
diff --git a/src/effectivejava/chapter5/item32/FlattenWithList.java b/src/effectivejava/chapter5/item32/FlattenWithList.java
new file mode 100644
index 00000000..b9cbaa71
--- /dev/null
+++ b/src/effectivejava/chapter5/item32/FlattenWithList.java
@@ -0,0 +1,20 @@
+package effectivejava.chapter5.item32;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// List as a typesafe alternative to a generic varargs parameter (page 149)
+public class FlattenWithList {
+    static <T> List<T> flatten(List<List<? extends T>> lists) {
+        List<T> result = new ArrayList<>();
+        for (List<? extends T> list : lists)
+            result.addAll(list);
+        return result;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> flatList = flatten(List.of(
+                List.of(1, 2), List.of(3, 4, 5), List.of(6,7)));
+        System.out.println(flatList);
+    }
+}
diff --git a/src/effectivejava/chapter5/item32/FlattenWithVarargs.java b/src/effectivejava/chapter5/item32/FlattenWithVarargs.java
new file mode 100644
index 00000000..e33f4472
--- /dev/null
+++ b/src/effectivejava/chapter5/item32/FlattenWithVarargs.java
@@ -0,0 +1,21 @@
+package effectivejava.chapter5.item32;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// Safe method with a generic varargs parameter (page 149)
+public class FlattenWithVarargs {
+    @SafeVarargs
+    static <T> List<T> flatten(List<? extends T>... lists) {
+        List<T> result = new ArrayList<>();
+        for (List<? extends T> list : lists)
+            result.addAll(list);
+        return result;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> flatList = flatten(
+                List.of(1, 2), List.of(3, 4, 5), List.of(6,7));
+        System.out.println(flatList);
+    }
+}
diff --git a/src/effectivejava/chapter5/item32/Function.java b/src/effectivejava/chapter5/item32/Function.java
deleted file mode 100644
index a75bb0ad..00000000
--- a/src/effectivejava/chapter5/item32/Function.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package effectivejava.chapter5.item32;
-
-// Generic Function interface - Page 122
-interface Function<T> {
-    T apply(T arg1, T arg2);
-}
diff --git a/src/effectivejava/chapter5/item32/PickTwo.java b/src/effectivejava/chapter5/item32/PickTwo.java
new file mode 100644
index 00000000..297bea62
--- /dev/null
+++ b/src/effectivejava/chapter5/item32/PickTwo.java
@@ -0,0 +1,26 @@
+package effectivejava.chapter5.item32;
+
+import java.util.Arrays;
+import java.util.concurrent.ThreadLocalRandom;
+
+// Subtle heap pollution (Pages 147-8)
+public class PickTwo {
+    // UNSAFE - Exposes a reference to its generic parameter array!
+    static <T> T[] toArray(T... args) {
+        return args;
+    }
+
+    static <T> T[] pickTwo(T a, T b, T c) {
+        switch(ThreadLocalRandom.current().nextInt(3)) {
+            case 0: return toArray(a, b);
+            case 1: return toArray(a, c);
+            case 2: return toArray(b, c);
+        }
+        throw new AssertionError(); // Can't get here
+    }
+
+    public static void main(String[] args) {
+        String[] attributes = pickTwo("Good", "Fast", "Cheap");
+        System.out.println(Arrays.toString(attributes));
+    }
+}
diff --git a/src/effectivejava/chapter5/item32/Reduction.java b/src/effectivejava/chapter5/item32/Reduction.java
deleted file mode 100644
index bb1bb9d9..00000000
--- a/src/effectivejava/chapter5/item32/Reduction.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package effectivejava.chapter5.item32;
-import java.util.*;
-
-// List-based generic reduction with wildcard type - Page 136
-public class Reduction {
-    // Wildcard type for parameter that serves as an E producer
-    static <E> E reduce(List<? extends E> list, Function<E> f,
-                        E initVal) {
-        List<E> snapshot;
-        synchronized(list) {
-            snapshot = new ArrayList<E>(list);
-        }
-        E result = initVal;
-        for (E e : snapshot)
-            result = f.apply(result, e);
-        return result;
-    }
-
-    private static final Function<Number> MAX = new Function<Number>(){
-        public Number apply(Number n1, Number n2) {
-            return Double.compare(n1.doubleValue(), n2.doubleValue()) > 0 ?
-                   n1 : n2;
-        }
-    };
-
-    public static void main(String[] args) {
-        // We can use a Number functionto reduce a list of Integer or Double
-        List<Integer> intList = Arrays.asList(
-            2, 7, 1, 8, 2, 8, 1, 8, 2, 8);
-        System.out.println(reduce(intList, MAX, Integer.MIN_VALUE));
-
-        List<Double> doubleList = Arrays.asList(
-            2.718281828, 3.141592654, 1.61803399);
-        System.out.println(reduce(doubleList, MAX, Double.NEGATIVE_INFINITY));
-    }
-}
diff --git a/src/effectivejava/chapter5/item32/SafePickTwo.java b/src/effectivejava/chapter5/item32/SafePickTwo.java
new file mode 100644
index 00000000..b8d864bf
--- /dev/null
+++ b/src/effectivejava/chapter5/item32/SafePickTwo.java
@@ -0,0 +1,22 @@
+package effectivejava.chapter5.item32;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+// Safe version of PickTwo using lists instead of arrays (Page 150)
+public class SafePickTwo {
+    static <T> List<T> pickTwo(T a, T b, T c) {
+        switch(ThreadLocalRandom.current().nextInt(3)) {
+            case 0: return List.of(a, b);
+            case 1: return List.of(a, c);
+            case 2: return List.of(b, c);
+        }
+        throw new AssertionError();
+    }
+
+    public static void main(String[] args) {
+        List<String> attributes = pickTwo("Good", "Fast", "Cheap");
+        System.out.println(attributes);
+    }
+}
diff --git a/src/effectivejava/chapter5/item33/Favorites.java b/src/effectivejava/chapter5/item33/Favorites.java
index 1d58204f..4e3385f7 100644
--- a/src/effectivejava/chapter5/item33/Favorites.java
+++ b/src/effectivejava/chapter5/item33/Favorites.java
@@ -1,34 +1,32 @@
 package effectivejava.chapter5.item33;
 import java.util.*;
 
-// Typesafe heterogeneous container - Pages 142-145
+// Typesafe heterogeneous container pattern (Pages 151-4)
 public class Favorites {
-    // Typesafe heterogeneous container pattern - implementation
-    private Map<Class<?>, Object> favorites = 
-        new HashMap<Class<?>, Object>();
+    private Map<Class<?>, Object> favorites = new HashMap<>();
 
     public <T> void putFavorite(Class<T> type, T instance) {
-        if (type == null)
-            throw new NullPointerException("LifeCycle is null");
-        favorites.put(type, instance);
+        favorites.put(Objects.requireNonNull(type), instance);
     }
 
     public <T> T getFavorite(Class<T> type) {
         return type.cast(favorites.get(type));
     }
 
+//    // Achieving runtime type safety with a dynamic cast
+//    public <T> void putFavorite(Class<T> type, T instance) {
+//        favorites.put(Objects.requireNonNull(type), type.cast(instance));
+//    }
 
-    // Typesafe heterogeneous container pattern - client
     public static void main(String[] args) {
         Favorites f = new Favorites();
         f.putFavorite(String.class, "Java");
         f.putFavorite(Integer.class, 0xcafebabe);
         f.putFavorite(Class.class, Favorites.class);
-
         String favoriteString = f.getFavorite(String.class);
         int favoriteInteger = f.getFavorite(Integer.class);
         Class<?> favoriteClass = f.getFavorite(Class.class);
         System.out.printf("%s %x %s%n", favoriteString,
-                          favoriteInteger, favoriteClass.getName());
+                favoriteInteger, favoriteClass.getName());
     }
 }
\ No newline at end of file
diff --git a/src/effectivejava/chapter5/item33/PrintAnnotation.java b/src/effectivejava/chapter5/item33/PrintAnnotation.java
index 80134843..bbd3d13c 100644
--- a/src/effectivejava/chapter5/item33/PrintAnnotation.java
+++ b/src/effectivejava/chapter5/item33/PrintAnnotation.java
@@ -2,9 +2,8 @@
 import java.lang.annotation.*;
 import java.lang.reflect.*;
 
-// Use of asSubclass to safely cast to a bounded type token - Page 146
+// Use of asSubclass to safely cast to a bounded type token (Page 155)
 public class PrintAnnotation {
-    // Use of asSubclass to safely cast to a bounded type token
     static Annotation getAnnotation(AnnotatedElement element,
                                     String annotationTypeName) {
         Class<?> annotationType = null; // Unbounded type token
@@ -14,7 +13,7 @@ static Annotation getAnnotation(AnnotatedElement element,
             throw new IllegalArgumentException(ex);
         }
         return element.getAnnotation(
-            annotationType.asSubclass(Annotation.class));
+                annotationType.asSubclass(Annotation.class));
     }
 
     // Test program to print named annotation of named class
diff --git a/src/effectivejava/chapter6/item34/Inverse.java b/src/effectivejava/chapter6/item34/Inverse.java
new file mode 100644
index 00000000..cced1080
--- /dev/null
+++ b/src/effectivejava/chapter6/item34/Inverse.java
@@ -0,0 +1,25 @@
+package effectivejava.chapter6.item34;
+
+// Switch on an enum to simulate a missing method (Page 167)
+public class Inverse {
+    public static Operation inverse(Operation op) {
+        switch(op) {
+            case PLUS:   return Operation.MINUS;
+            case MINUS:  return Operation.PLUS;
+            case TIMES:  return Operation.DIVIDE;
+            case DIVIDE: return Operation.TIMES;
+
+            default:  throw new AssertionError("Unknown op: " + op);
+        }
+    }
+
+    public static void main(String[] args) {
+        double x = Double.parseDouble(args[0]);
+        double y = Double.parseDouble(args[1]);
+        for (Operation op : Operation.values()) {
+            Operation invOp = inverse(op);
+            System.out.printf("%f %s %f %s %f = %f%n",
+                    x, op, y, invOp, y, invOp.apply(op.apply(x, y), y));
+        }
+    }
+}
diff --git a/src/effectivejava/chapter6/item34/Operation.java b/src/effectivejava/chapter6/item34/Operation.java
index 6b88fc3a..ba89c8f9 100644
--- a/src/effectivejava/chapter6/item34/Operation.java
+++ b/src/effectivejava/chapter6/item34/Operation.java
@@ -4,7 +4,7 @@
 
 import static java.util.stream.Collectors.toMap;
 
-// Enum type with constant-specific class bodies and data  (Page 161)
+// Enum type with constant-specific class bodies and data (Pages 163-4)
 public enum Operation {
     PLUS("+") {
         public double apply(double x, double y) { return x + y; }
@@ -27,7 +27,7 @@ public enum Operation {
 
     public abstract double apply(double x, double y);
 
-    // Implementing a fromString method on an enum type
+    // Implementing a fromString method on an enum type (Page 164)
     private static final Map<String, Operation> stringToEnum =
             Stream.of(values()).collect(
                     toMap(Object::toString, e -> e));
diff --git a/src/effectivejava/chapter6/item34/PayrollDay.java b/src/effectivejava/chapter6/item34/PayrollDay.java
index 0dc831ab..54a89c12 100644
--- a/src/effectivejava/chapter6/item34/PayrollDay.java
+++ b/src/effectivejava/chapter6/item34/PayrollDay.java
@@ -1,21 +1,23 @@
 package effectivejava.chapter6.item34;
 
-// The strategy enum pattern
+import static effectivejava.chapter6.item34.PayrollDay.PayType.*;
+
+// The strategy enum pattern (Page 166)
 enum PayrollDay {
-    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
-    SATURDAY(PayType.WEEKEND), SUNDAY(PayType.WEEKEND);
+    MONDAY(WEEKDAY), TUESDAY(WEEKDAY), WEDNESDAY(WEEKDAY),
+    THURSDAY(WEEKDAY), FRIDAY(WEEKDAY),
+    SATURDAY(WEEKEND), SUNDAY(WEEKEND);
 
     private final PayType payType;
 
     PayrollDay(PayType payType) { this.payType = payType; }
-    PayrollDay() { this(PayType.WEEKDAY); }  // Default
 
     int pay(int minutesWorked, int payRate) {
         return payType.pay(minutesWorked, payRate);
     }
 
     // The strategy enum type
-    private enum PayType {
+    enum PayType {
         WEEKDAY {
             int overtimePay(int minsWorked, int payRate) {
                 return minsWorked <= MINS_PER_SHIFT ? 0 :
@@ -36,4 +38,9 @@ int pay(int minsWorked, int payRate) {
             return basePay + overtimePay(minsWorked, payRate);
         }
     }
+
+    public static void main(String[] args) {
+        for (PayrollDay day : values())
+            System.out.printf("%-10s%d%n", day, day.pay(8 * 60, 1));
+    }
 }
diff --git a/src/effectivejava/chapter6/item34/Planet.java b/src/effectivejava/chapter6/item34/Planet.java
index 833cf8c8..af74c405 100644
--- a/src/effectivejava/chapter6/item34/Planet.java
+++ b/src/effectivejava/chapter6/item34/Planet.java
@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item34;
 
-// Enum type with data and behavior  (157-158)
+// Enum type with data and behavior  (159-160)
 public enum Planet {
     MERCURY(3.302e+23, 2.439e6),
     VENUS  (4.869e+24, 6.052e6),
@@ -14,6 +14,7 @@ public enum Planet {
     private final double mass;           // In kilograms
     private final double radius;         // In meters
     private final double surfaceGravity; // In m / s^2
+
     // Universal gravitational constant in m^3 / kg s^2
     private static final double G = 6.67300E-11;
 
diff --git a/src/effectivejava/chapter6/item34/WeightTable.java b/src/effectivejava/chapter6/item34/WeightTable.java
index 8569a739..948c2e37 100644
--- a/src/effectivejava/chapter6/item34/WeightTable.java
+++ b/src/effectivejava/chapter6/item34/WeightTable.java
@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item34;
 
-// Takes earth-weight and prints table of weights on all planets - Page 158
+// Takes earth-weight and prints table of weights on all planets (Page 160)
 public class WeightTable {
    public static void main(String[] args) {
       double earthWeight = Double.parseDouble(args[0]);
diff --git a/src/effectivejava/chapter6/item35/Ensemble.java b/src/effectivejava/chapter6/item35/Ensemble.java
index 3b6b1e6c..51e21a32 100644
--- a/src/effectivejava/chapter6/item35/Ensemble.java
+++ b/src/effectivejava/chapter6/item35/Ensemble.java
@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item35;
 
-// Enum with integer data stored in an instance field (Page 166)
+// Enum with integer data stored in an instance field (Page 168)
 public enum Ensemble {
     SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5),
     SEXTET(6), SEPTET(7), OCTET(8), DOUBLE_QUARTET(8),
diff --git a/src/effectivejava/chapter6/item36/Text.java b/src/effectivejava/chapter6/item36/Text.java
index b552643e..9f8aa6cd 100644
--- a/src/effectivejava/chapter6/item36/Text.java
+++ b/src/effectivejava/chapter6/item36/Text.java
@@ -1,16 +1,20 @@
 package effectivejava.chapter6.item36;
+
 import java.util.*;
 
-// EnumSet - a modern replacement for bit fields (Page 168)
+// EnumSet - a modern replacement for bit fields (Page 170)
 public class Text {
-    public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }
+    public enum Style {BOLD, ITALIC, UNDERLINE, STRIKETHROUGH}
 
     // Any Set could be passed in, but EnumSet is clearly best
-    public void applyStyles(Set<Style> styles) {   }
+    public void applyStyles(Set<Style> styles) {
+        System.out.printf("Applying styles %s to text%n",
+                Objects.requireNonNull(styles));
+    }
 
     // Sample use
     public static void main(String[] args) {
         Text text = new Text();
         text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
     }
-}
+}
\ No newline at end of file
diff --git a/src/effectivejava/chapter6/item37/Phase.java b/src/effectivejava/chapter6/item37/Phase.java
index 7be869ec..5eccaba0 100644
--- a/src/effectivejava/chapter6/item37/Phase.java
+++ b/src/effectivejava/chapter6/item37/Phase.java
@@ -4,7 +4,7 @@
 
 import static java.util.stream.Collectors.*;
 
-// Using a nested EnumMap to associate data with enum pairs - (Pages 172-3)
+// Using a nested EnumMap to associate data with enum pairs - (Pages 174-5)
 public enum Phase {
     SOLID, LIQUID, GAS;
     public enum Transition {
@@ -12,7 +12,7 @@ public enum Transition {
         BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
         SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);
 
- // Adding a new phase (Page 173)
+//        // Adding a new phase (Page 175)
 //        SOLID, LIQUID, GAS, PLASMA;
 //        public enum Transition {
 //            MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
@@ -33,6 +33,7 @@ public enum Transition {
                 () -> new EnumMap<>(Phase.class),
                 toMap(t -> t.to, t -> t,
                         (x, y) -> y, () -> new EnumMap<>(Phase.class))));
+        
         public static Transition from(Phase from, Phase to) {
             return m.get(from).get(to);
         }
@@ -40,10 +41,12 @@ public static Transition from(Phase from, Phase to) {
 
     // Simple demo program - prints a sloppy table
     public static void main(String[] args) {
-        for (Phase src : Phase.values())
-            for (Phase dst : Phase.values())
-                if (src != dst)
-                    System.out.printf("%s to %s : %s %n", src, dst,
-                            Transition.from(src, dst));
+        for (Phase src : Phase.values()) {
+            for (Phase dst : Phase.values()) {
+                Transition transition = Transition.from(src, dst);
+                if (transition != null)
+                    System.out.printf("%s to %s : %s %n", src, dst, transition);
+            }
+        }
     }
 }
diff --git a/src/effectivejava/chapter6/item37/Plant.java b/src/effectivejava/chapter6/item37/Plant.java
index 0f4e5735..8e8fc1cf 100644
--- a/src/effectivejava/chapter6/item37/Plant.java
+++ b/src/effectivejava/chapter6/item37/Plant.java
@@ -3,9 +3,9 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.toSet;
 
-// Using an EnumMap to associate data with an enum - Pages 169-171
+// Using an EnumMap to associate data with an enum (Pages 171-3)
 
-// Simplistic class representing a plant - Page 169
+// Simplistic class representing a plant (Page 171)
 class Plant {
     enum LifeCycle { ANNUAL, PERENNIAL, BIENNIAL }
 
@@ -31,7 +31,7 @@ public static void main(String[] args) {
             new Plant("Rosemary", LifeCycle.PERENNIAL)
         };
 
-        // Using ordinal() to index into an array - DON'T DO THIS!  (Page 170)
+        // Using ordinal() to index into an array - DON'T DO THIS!  (Page 171)
         Set<Plant>[] plantsByLifeCycleArr =
                 (Set<Plant>[]) new Set[Plant.LifeCycle.values().length];
         for (int i = 0; i < plantsByLifeCycleArr.length; i++)
@@ -44,7 +44,7 @@ public static void main(String[] args) {
                     Plant.LifeCycle.values()[i], plantsByLifeCycleArr[i]);
         }
 
-        // Using an EnumMap to associate data with an enum (P. 170)
+        // Using an EnumMap to associate data with an enum (Page 172)
         Map<Plant.LifeCycle, Set<Plant>> plantsByLifeCycle =
                 new EnumMap<>(Plant.LifeCycle.class);
         for (Plant.LifeCycle lc : Plant.LifeCycle.values())
@@ -53,11 +53,11 @@ public static void main(String[] args) {
             plantsByLifeCycle.get(p.lifeCycle).add(p);
         System.out.println(plantsByLifeCycle);
 
-        // Naive stream-based approach - unlikely to produce an EnumMap!  (Page 171)
+        // Naive stream-based approach - unlikely to produce an EnumMap!  (Page 172)
         System.out.println(Arrays.stream(garden)
                 .collect(groupingBy(p -> p.lifeCycle)));
 
-        // Using a stream and an EnumMap to associate data with an enum (Page 171)
+        // Using a stream and an EnumMap to associate data with an enum (Page 173)
         System.out.println(Arrays.stream(garden)
                 .collect(groupingBy(p -> p.lifeCycle,
                         () -> new EnumMap<>(LifeCycle.class), toSet())));
diff --git a/src/effectivejava/chapter6/item38/BasicOperation.java b/src/effectivejava/chapter6/item38/BasicOperation.java
index dd49d331..bca5a38d 100644
--- a/src/effectivejava/chapter6/item38/BasicOperation.java
+++ b/src/effectivejava/chapter6/item38/BasicOperation.java
@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item38;
 
-// Emulated extensible enum using an interface - Basic implementation - Page 174
+// Emulated extensible enum using an interface - Basic implementation (Page 176)
 public enum BasicOperation implements Operation {
     PLUS("+") {
         public double apply(double x, double y) { return x + y; }
diff --git a/src/effectivejava/chapter6/item38/ExtendedOperation.java b/src/effectivejava/chapter6/item38/ExtendedOperation.java
index fa42fa96..86a019fb 100644
--- a/src/effectivejava/chapter6/item38/ExtendedOperation.java
+++ b/src/effectivejava/chapter6/item38/ExtendedOperation.java
@@ -1,7 +1,7 @@
 package effectivejava.chapter6.item38;
 import java.util.*;
 
-// Emulated extension enum - (Pages 175-7)
+// Emulated extensible enum (Pages 176-9)
 public enum ExtendedOperation implements Operation {
     EXP("^") {
         public double apply(double x, double y) {
@@ -21,7 +21,7 @@ public double apply(double x, double y) {
         return symbol;
     }
 
-     // WRITE DESCR ***
+//    // Using an enum class object to represent a collection of extended enums (page 178)
 //    public static void main(String[] args) {
 //        double x = Double.parseDouble(args[0]);
 //        double y = Double.parseDouble(args[1]);
@@ -34,7 +34,7 @@ public double apply(double x, double y) {
 //                    x, op, y, op.apply(x, y));
 //    }
 
-    // WRITE DESCR ***
+    // Using a collection instance to represent a collection of extended enums (page 178)
     public static void main(String[] args) {
         double x = Double.parseDouble(args[0]);
         double y = Double.parseDouble(args[1]);
diff --git a/src/effectivejava/chapter6/item38/Operation.java b/src/effectivejava/chapter6/item38/Operation.java
index 0e2a25ed..cd136af2 100644
--- a/src/effectivejava/chapter6/item38/Operation.java
+++ b/src/effectivejava/chapter6/item38/Operation.java
@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item38;
 
-// Emulated extensible enum using an interface  (Page 174)
+// Emulated extensible enum using an interface (Page 176)
 public interface Operation {
     double apply(double x, double y);
 }
diff --git a/src/effectivejava/chapter6/item39/annotationwitharrayparameter/ExceptionTest.java b/src/effectivejava/chapter6/item39/annotationwitharrayparameter/ExceptionTest.java
new file mode 100644
index 00000000..49a1758c
--- /dev/null
+++ b/src/effectivejava/chapter6/item39/annotationwitharrayparameter/ExceptionTest.java
@@ -0,0 +1,9 @@
+package effectivejava.chapter6.item39.annotationwitharrayparameter;
+import java.lang.annotation.*;
+
+// Annotation type with an array parameter  (Page 184)
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface ExceptionTest {
+    Class<? extends Exception>[] value();
+}
\ No newline at end of file
diff --git a/src/effectivejava/chapter6/item39/regularannotation/RunTests.java b/src/effectivejava/chapter6/item39/annotationwitharrayparameter/RunTests.java
similarity index 85%
rename from src/effectivejava/chapter6/item39/regularannotation/RunTests.java
rename to src/effectivejava/chapter6/item39/annotationwitharrayparameter/RunTests.java
index eb6d2bd3..91855d8c 100644
--- a/src/effectivejava/chapter6/item39/regularannotation/RunTests.java
+++ b/src/effectivejava/chapter6/item39/annotationwitharrayparameter/RunTests.java
@@ -1,7 +1,9 @@
-package effectivejava.chapter6.item39.regularannotation;
+package effectivejava.chapter6.item39.annotationwitharrayparameter;
+import effectivejava.chapter6.item39.markerannotation.Test;
+
 import java.lang.reflect.*;
 
-// Program to process marker annotations - Page 171
+// Program to process marker annotations and annotations with array parameter (Page 185)
 public class RunTests {
     public static void main(String[] args) throws Exception {
         int tests = 0;
@@ -20,7 +22,8 @@ public static void main(String[] args) throws Exception {
                     System.out.println("Invalid @Test: " + m);
                 }
             }
-            
+
+            // Code to process annotations with array parameter (Page 185)
             if (m.isAnnotationPresent(ExceptionTest.class)) {
                 tests++;
                 try {
diff --git a/src/effectivejava/chapter6/item39/regularannotation/Sample2.java b/src/effectivejava/chapter6/item39/annotationwitharrayparameter/Sample3.java
similarity index 60%
rename from src/effectivejava/chapter6/item39/regularannotation/Sample2.java
rename to src/effectivejava/chapter6/item39/annotationwitharrayparameter/Sample3.java
index 08fbea6f..be217082 100644
--- a/src/effectivejava/chapter6/item39/regularannotation/Sample2.java
+++ b/src/effectivejava/chapter6/item39/annotationwitharrayparameter/Sample3.java
@@ -1,8 +1,10 @@
-package effectivejava.chapter6.item39.regularannotation;
+package effectivejava.chapter6.item39.annotationwitharrayparameter;
+
 import java.util.*;
 
-// Program containing annotations with a parameter - Page 172
-public class Sample2 {
+// Program containing an annotation with an array parameter (Page 185)
+public class Sample3 {
+    // This variant can process annotations whose parameter is a single element (identical to those on page 183)
     @ExceptionTest(ArithmeticException.class)
     public static void m1() {  // Test should pass
         int i = 0;
@@ -16,10 +18,10 @@ public static void m2() {  // Should fail (wrong exception)
     @ExceptionTest(ArithmeticException.class)
     public static void m3() { }  // Should fail (no exception)
 
-    // Code containing an annotation with an array parameter
+    // Code containing an annotation with an array parameter (Page 185)
     @ExceptionTest({ IndexOutOfBoundsException.class,
-            NullPointerException.class })
-    public static void doublyBad() {
+                     NullPointerException.class })
+    public static void doublyBad() {   // Should pass
         List<String> list = new ArrayList<>();
 
         // The spec permits this method to throw either
diff --git a/src/effectivejava/chapter6/item39/annotationwithparameter/ExceptionTest.java b/src/effectivejava/chapter6/item39/annotationwithparameter/ExceptionTest.java
new file mode 100644
index 00000000..3384304d
--- /dev/null
+++ b/src/effectivejava/chapter6/item39/annotationwithparameter/ExceptionTest.java
@@ -0,0 +1,13 @@
+package effectivejava.chapter6.item39.annotationwithparameter;
+
+// Annotation type with a parameter (Page 183)
+import java.lang.annotation.*;
+/**
+ * Indicates that the annotated method is a test method that
+ * must throw the designated exception to succeed.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface ExceptionTest {
+    Class<? extends Throwable> value();
+}
diff --git a/src/effectivejava/chapter6/item39/annotationwithparameter/RunTests.java b/src/effectivejava/chapter6/item39/annotationwithparameter/RunTests.java
new file mode 100644
index 00000000..867f7dcf
--- /dev/null
+++ b/src/effectivejava/chapter6/item39/annotationwithparameter/RunTests.java
@@ -0,0 +1,51 @@
+package effectivejava.chapter6.item39.annotationwithparameter;
+
+import effectivejava.chapter6.item39.markerannotation.Test;
+import java.lang.reflect.*;
+
+// Program to process marker annotations and annotations with a parameter (Page 184)
+public class RunTests {
+    public static void main(String[] args) throws Exception {
+        int tests = 0;
+        int passed = 0;
+        Class<?> testClass = Class.forName(args[0]);
+        for (Method m : testClass.getDeclaredMethods()) {
+            if (m.isAnnotationPresent(Test.class)) {
+                tests++;
+                try {
+                    m.invoke(null);
+                    passed++;
+                } catch (InvocationTargetException wrappedExc) {
+                    Throwable exc = wrappedExc.getCause();
+                    System.out.println(m + " failed: " + exc);
+                } catch (Exception exc) {
+                    System.out.println("Invalid @Test: " + m);
+                }
+            }
+
+            if (m.isAnnotationPresent(ExceptionTest.class)) {
+                tests++;
+                try {
+                    m.invoke(null);
+                    System.out.printf("Test %s failed: no exception%n", m);
+                } catch (InvocationTargetException wrappedEx) {
+                    Throwable exc = wrappedEx.getCause();
+                    Class<? extends Throwable> excType =
+                            m.getAnnotation(ExceptionTest.class).value();
+                    if (excType.isInstance(exc)) {
+                        passed++;
+                    } else {
+                        System.out.printf(
+                                "Test %s failed: expected %s, got %s%n",
+                                m, excType.getName(), exc);
+                    }
+                } catch (Exception exc) {
+                    System.out.println("Invalid @ExceptionTest: " + m);
+                }
+            }
+        }
+
+        System.out.printf("Passed: %d, Failed: %d%n",
+                passed, tests - passed);
+    }
+}
diff --git a/src/effectivejava/chapter6/item39/annotationwithparameter/Sample2.java b/src/effectivejava/chapter6/item39/annotationwithparameter/Sample2.java
new file mode 100644
index 00000000..a3f83146
--- /dev/null
+++ b/src/effectivejava/chapter6/item39/annotationwithparameter/Sample2.java
@@ -0,0 +1,20 @@
+package effectivejava.chapter6.item39.annotationwithparameter;
+import effectivejava.chapter6.item39.annotationwithparameter.ExceptionTest;
+
+import java.util.*;
+
+// Program containing annotations with a parameter (Page 183)
+public class Sample2 {
+    @ExceptionTest(ArithmeticException.class)
+    public static void m1() {  // Test should pass
+        int i = 0;
+        i = i / i;
+    }
+    @ExceptionTest(ArithmeticException.class)
+    public static void m2() {  // Should fail (wrong exception)
+        int[] a = new int[0];
+        int i = a[1];
+    }
+    @ExceptionTest(ArithmeticException.class)
+    public static void m3() { }  // Should fail (no exception)
+}
diff --git a/src/effectivejava/chapter6/item39/markerannotation/RunTests.java b/src/effectivejava/chapter6/item39/markerannotation/RunTests.java
new file mode 100644
index 00000000..7dd09961
--- /dev/null
+++ b/src/effectivejava/chapter6/item39/markerannotation/RunTests.java
@@ -0,0 +1,29 @@
+package effectivejava.chapter6.item39.markerannotation;
+
+// Program to process marker annotations (Page 182)
+
+import java.lang.reflect.*;
+
+public class RunTests {
+    public static void main(String[] args) throws Exception {
+        int tests = 0;
+        int passed = 0;
+        Class<?> testClass = Class.forName(args[0]);
+        for (Method m : testClass.getDeclaredMethods()) {
+            if (m.isAnnotationPresent(Test.class)) {
+                tests++;
+                try {
+                    m.invoke(null);
+                    passed++;
+                } catch (InvocationTargetException wrappedExc) {
+                    Throwable exc = wrappedExc.getCause();
+                    System.out.println(m + " failed: " + exc);
+                } catch (Exception exc) {
+                    System.out.println("Invalid @Test: " + m);
+                }
+            }
+        }
+        System.out.printf("Passed: %d, Failed: %d%n",
+                passed, tests - passed);
+    }
+}
diff --git a/src/effectivejava/chapter6/item39/regularannotation/Sample.java b/src/effectivejava/chapter6/item39/markerannotation/Sample.java
similarity index 53%
rename from src/effectivejava/chapter6/item39/regularannotation/Sample.java
rename to src/effectivejava/chapter6/item39/markerannotation/Sample.java
index 4131fe77..c278c172 100644
--- a/src/effectivejava/chapter6/item39/regularannotation/Sample.java
+++ b/src/effectivejava/chapter6/item39/markerannotation/Sample.java
@@ -1,14 +1,15 @@
-package effectivejava.chapter6.item39.regularannotation;
+package effectivejava.chapter6.item39.markerannotation;
 
-// Program containing marker annotations - Page 170
+// Program containing marker annotations (Page 181)
 public class Sample {
-    @Test public static void m1() { }  // Test should pass
+    @Test
+    public static void m1() { }        // Test should pass
     public static void m2() { }
     @Test public static void m3() {    // Test should fail
         throw new RuntimeException("Boom");
     }
-    public static void m4() { }
-    @Test public void m5() { } // INVALID USE: nonstatic method
+    public static void m4() { }  // Not a test
+    @Test public void m5() { }   // INVALID USE: nonstatic method
     public static void m6() { }
     @Test public static void m7() {    // Test should fail
         throw new RuntimeException("Crash");
diff --git a/src/effectivejava/chapter6/item39/regularannotation/Test.java b/src/effectivejava/chapter6/item39/markerannotation/Test.java
similarity index 74%
rename from src/effectivejava/chapter6/item39/regularannotation/Test.java
rename to src/effectivejava/chapter6/item39/markerannotation/Test.java
index df46a97a..19ac57fe 100644
--- a/src/effectivejava/chapter6/item39/regularannotation/Test.java
+++ b/src/effectivejava/chapter6/item39/markerannotation/Test.java
@@ -1,9 +1,11 @@
-package effectivejava.chapter6.item39.regularannotation;
+package effectivejava.chapter6.item39.markerannotation;
 import java.lang.annotation.*;
 
 // Marker annotation type declaration - Page 180
 import java.lang.annotation.*;
 
+// Marker annotation type declaration (Page 180)
+
 /**
  * Indicates that the annotated method is a test method.
  * Use only on parameterless static methods.
diff --git a/src/effectivejava/chapter6/item39/regularannotation/ExceptionTest.java b/src/effectivejava/chapter6/item39/regularannotation/ExceptionTest.java
deleted file mode 100644
index f0b42f6e..00000000
--- a/src/effectivejava/chapter6/item39/regularannotation/ExceptionTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package effectivejava.chapter6.item39.regularannotation;
-import java.lang.annotation.*;
-
-// Annotation type with an array parameter -  Page 183
-
-/**
- * Indicates that the annotated method is a test method that
- * must throw the designated exception to succeed.
- */
-//@Retention(RetentionPolicy.RUNTIME)
-//@Target(ElementType.METHOD)
-//public @interface ExceptionTest {
-//    Class<? extends Throwable> value();
-//}
-
-// Annotation type with an array parameter
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-public @interface ExceptionTest {
-    Class<? extends Throwable>[] value();
-}
\ No newline at end of file
diff --git a/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTest.java b/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTest.java
index a27c579d..b4388027 100644
--- a/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTest.java
+++ b/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTest.java
@@ -2,12 +2,7 @@
 
 import java.lang.annotation.*;
 
-// Repeatable annotation type -  Page 186
-
-/**
- * Indicates that the annotated staticfactory is a test staticfactory that
- * must throw the any of the designated exceptions to succeed.
- */
+// Repeatable annotation type (Page 186)
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 @Repeatable(ExceptionTestContainer.class)
diff --git a/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTestContainer.java b/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTestContainer.java
index 9548bd50..b954a77d 100644
--- a/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTestContainer.java
+++ b/src/effectivejava/chapter6/item39/repeatableannotation/ExceptionTestContainer.java
@@ -5,9 +5,7 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-/**
- * Container annotation for the repeatable ExceptionTest annotation - page 186
- */
+//Container annotation for the repeatable ExceptionTest annotation (Page 186)
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 public @interface ExceptionTestContainer {
diff --git a/src/effectivejava/chapter6/item39/repeatableannotation/RunTests.java b/src/effectivejava/chapter6/item39/repeatableannotation/RunTests.java
index 11eb1cbc..e2ef183e 100644
--- a/src/effectivejava/chapter6/item39/repeatableannotation/RunTests.java
+++ b/src/effectivejava/chapter6/item39/repeatableannotation/RunTests.java
@@ -1,8 +1,11 @@
 package effectivejava.chapter6.item39.repeatableannotation;
 
+import effectivejava.chapter6.item39.markerannotation.Test;
+
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
+// Program to process marker annotations and repeatable annotations (Page 187)
 public class RunTests {
     public static void main(String[] args) throws Exception {
         int tests = 0;
@@ -22,7 +25,7 @@ public static void main(String[] args) throws Exception {
                 }
             }
 
-            // Processing repeatable annotations  (Page 187)
+            // Processing repeatable annotations (Page 187)
             if (m.isAnnotationPresent(ExceptionTest.class)
                     || m.isAnnotationPresent(ExceptionTestContainer.class)) {
                 tests++;
diff --git a/src/effectivejava/chapter6/item39/repeatableannotation/Sample2.java b/src/effectivejava/chapter6/item39/repeatableannotation/Sample4.java
similarity index 86%
rename from src/effectivejava/chapter6/item39/repeatableannotation/Sample2.java
rename to src/effectivejava/chapter6/item39/repeatableannotation/Sample4.java
index 2c93e883..b996d7ba 100644
--- a/src/effectivejava/chapter6/item39/repeatableannotation/Sample2.java
+++ b/src/effectivejava/chapter6/item39/repeatableannotation/Sample4.java
@@ -3,8 +3,8 @@
 import java.util.ArrayList;
 import java.util.List;
 
-// Program containing annotations with a parameter - Page 172
-public class Sample2 {
+// Program containing repeatable annotations (Page 186)
+public class Sample4 {
     @ExceptionTest(ArithmeticException.class)
     public static void m1() {  // Test should pass
         int i = 0;
@@ -20,7 +20,7 @@ public static void m2() {  // Should fail (wrong exception)
     @ExceptionTest(ArithmeticException.class)
     public static void m3() { }  // Should fail (no exception)
 
-    // Code containing a repeated annotation - Page 186
+    // Code containing a repeated annotation (Page 186)
     @ExceptionTest(IndexOutOfBoundsException.class)
     @ExceptionTest(NullPointerException.class)
     public static void doublyBad() {
diff --git a/src/effectivejava/chapter6/item39/repeatableannotation/Test.java b/src/effectivejava/chapter6/item39/repeatableannotation/Test.java
deleted file mode 100644
index 5ad1adf9..00000000
--- a/src/effectivejava/chapter6/item39/repeatableannotation/Test.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package effectivejava.chapter6.item39.repeatableannotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-// Marker annotation type declaration - Page 169
-
-/**
- * Indicates that the annotated staticfactory is a test staticfactory.
- * Use only on parameterless static methods.
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-public @interface Test {
-}
\ No newline at end of file
diff --git a/src/effectivejava/chapter6/item40/Bigram.java b/src/effectivejava/chapter6/item40/Bigram.java
index 0a9a33e6..f6fc865c 100644
--- a/src/effectivejava/chapter6/item40/Bigram.java
+++ b/src/effectivejava/chapter6/item40/Bigram.java
@@ -1,7 +1,7 @@
 package effectivejava.chapter6.item40;
 import java.util.*;
 
-// Can you spot the bug?  (Page 188)
+// Can you spot the bug? (Page 188)
 public class Bigram {
     private final char first;
     private final char second;
diff --git a/src/effectivejava/chapter6/item40/Bigram2.java b/src/effectivejava/chapter6/item40/Bigram2.java
new file mode 100644
index 00000000..d6074d57
--- /dev/null
+++ b/src/effectivejava/chapter6/item40/Bigram2.java
@@ -0,0 +1,34 @@
+package effectivejava.chapter6.item40;
+
+import java.util.HashSet;
+import java.util.Set;
+
+// Fixed Bigram class (Page 189)
+public class Bigram2 {
+    private final char first;
+    private final char second;
+
+    public Bigram2(char first, char second) {
+        this.first  = first;
+        this.second = second;
+    }
+
+    @Override public boolean equals(Object o) {
+        if (!(o instanceof Bigram2))
+            return false;
+        Bigram2 b = (Bigram2) o;
+        return b.first == first && b.second == second;
+    }
+
+    public int hashCode() {
+        return 31 * first + second;
+    }
+
+    public static void main(String[] args) {
+        Set<Bigram2> s = new HashSet<>();
+        for (int i = 0; i < 10; i++)
+            for (char ch = 'a'; ch <= 'z'; ch++)
+                s.add(new Bigram2(ch, ch));
+        System.out.println(s.size());
+    }
+}
diff --git a/src/effectivejava/chapter7/item42/Operation.java b/src/effectivejava/chapter7/item42/Operation.java
index 40424891..2a568812 100644
--- a/src/effectivejava/chapter7/item42/Operation.java
+++ b/src/effectivejava/chapter7/item42/Operation.java
@@ -2,7 +2,7 @@
 
 import java.util.function.DoubleBinaryOperator;
 
-// Enum with function object fields & constant-specific behavior
+// Enum with function object fields & constant-specific behavior (Page 195)
 public enum Operation {
     PLUS  ("+", (x, y) -> x + y),
     MINUS ("-", (x, y) -> x - y),
@@ -22,4 +22,13 @@ public enum Operation {
     public double apply(double x, double y) {
         return op.applyAsDouble(x, y);
     }
+
+    // Main method from Item 34 (Page 163)
+    public static void main(String[] args) {
+        double x = Double.parseDouble(args[0]);
+        double y = Double.parseDouble(args[1]);
+        for (Operation op : Operation.values())
+            System.out.printf("%f %s %f = %f%n",
+                    x, op, y, op.apply(x, y));
+    }
 }
diff --git a/src/effectivejava/chapter7/item42/SortFourWays.java b/src/effectivejava/chapter7/item42/SortFourWays.java
index b41c9437..84b77371 100644
--- a/src/effectivejava/chapter7/item42/SortFourWays.java
+++ b/src/effectivejava/chapter7/item42/SortFourWays.java
@@ -8,11 +8,12 @@
 
 import static java.util.Comparator.comparingInt;
 
+// Sorting with function objects (Pages 193-4)
 public class SortFourWays {
     public static void main(String[] args) {
         List<String> words = Arrays.asList(args);
 
-        // Anonymous class instance as a function object - obsolete!
+        // Anonymous class instance as a function object - obsolete! (Page 193)
         Collections.sort(words, new Comparator<String>() {
             public int compare(String s1, String s2) {
                 return Integer.compare(s1.length(), s2.length());
@@ -21,16 +22,18 @@ public int compare(String s1, String s2) {
         System.out.println(words);
         Collections.shuffle(words);
 
-        // Lambda expression as function object (replaces anonymous class)
+        // Lambda expression as function object (replaces anonymous class) (Page 194)
         Collections.sort(words,
                 (s1, s2) -> Integer.compare(s1.length(), s2.length()));
         System.out.println(words);
         Collections.shuffle(words);
 
+        // Comparator construction method (with method reference) in place of lambda (Page 194)
         Collections.sort(words, comparingInt(String::length));
         System.out.println(words);
         Collections.shuffle(words);
 
+        // Default method List.sort in conjunction with comparator construction method (Page 194)
         words.sort(comparingInt(String::length));
         System.out.println(words);
     }
diff --git a/src/effectivejava/chapter7/item43/Freq.java b/src/effectivejava/chapter7/item43/Freq.java
index b997da3f..fb949ad9 100644
--- a/src/effectivejava/chapter7/item43/Freq.java
+++ b/src/effectivejava/chapter7/item43/Freq.java
@@ -3,15 +3,19 @@
 import java.util.Map;
 import java.util.TreeMap;
 
-// p. 197
+// Frequency table implemented with map.merge, using lambda and method reference (Page 197)
 public class Freq {
     public static void main(String[] args) {
         Map<String, Integer> frequencyTable = new TreeMap<>();
-        for (String s : args) {
-//          map.merge(key, 1, (count, incr) -> count + incr);
-            frequencyTable.merge(s, 1, Integer::sum);
-        }
+        
+        for (String s : args)
+            frequencyTable.merge(s, 1, (count, incr) -> count + incr); // Lambda
+        System.out.println(frequencyTable);
 
+        frequencyTable.clear();
+        for (String s : args)
+            frequencyTable.merge(s, 1, Integer::sum); // Method reference
         System.out.println(frequencyTable);
+
     }
 }
diff --git a/src/effectivejava/chapter7/item45/Card.java b/src/effectivejava/chapter7/item45/Card.java
index 712916d8..c577355b 100644
--- a/src/effectivejava/chapter7/item45/Card.java
+++ b/src/effectivejava/chapter7/item45/Card.java
@@ -5,10 +5,11 @@
 import java.util.stream.Stream;
 import static java.util.stream.Collectors.*;
 
+// Generating the Cartesian product of two lists using iteration and streams (Page 209)
 public class Card {
     public enum Suit { SPADE, HEART, DIAMOND, CLUB }
     public enum Rank { ACE, DEUCE, THREE, FOUR, FIVE, SIX, SEVEN,
-        EIGHT, NINE, TEN, JACK, KING, QUEEN }
+                       EIGHT, NINE, TEN, JACK, QUEEN, KING }
 
     private final Suit suit;
     private final Rank rank;
diff --git a/src/effectivejava/chapter7/item45/CharStream.java b/src/effectivejava/chapter7/item45/CharStream.java
new file mode 100644
index 00000000..04a47d92
--- /dev/null
+++ b/src/effectivejava/chapter7/item45/CharStream.java
@@ -0,0 +1,14 @@
+package effectivejava.chapter7.item45;
+
+// Refrain from using streams to process char values (Page 206)
+public class CharStream {
+    public static void main(String[] args) {
+        // Does not produce the expected result
+        "Hello world!".chars().forEach(System.out::print);
+        System.out.println();
+
+        // Fixes the problem
+        "Hello world!".chars().forEach(x -> System.out.print((char) x));
+        System.out.println();
+    }
+}
diff --git a/src/effectivejava/chapter7/item45/MersennePrimes.java b/src/effectivejava/chapter7/item45/MersennePrimes.java
index 6019781a..5a4e4f89 100644
--- a/src/effectivejava/chapter7/item45/MersennePrimes.java
+++ b/src/effectivejava/chapter7/item45/MersennePrimes.java
@@ -5,7 +5,7 @@
 
 import static java.math.BigInteger.*;
 
-// P. 208
+// Generating the first twent Mersenne primes using streams (Page 208)
 public class MersennePrimes {
     static Stream<BigInteger> primes() {
         return Stream.iterate(TWO, BigInteger::nextProbablePrime);
diff --git a/src/effectivejava/chapter7/item45/anagrams/HybridAnagrams.java b/src/effectivejava/chapter7/item45/anagrams/HybridAnagrams.java
index b22e3932..dc302ebf 100644
--- a/src/effectivejava/chapter7/item45/anagrams/HybridAnagrams.java
+++ b/src/effectivejava/chapter7/item45/anagrams/HybridAnagrams.java
@@ -9,7 +9,7 @@
 
 import static java.util.stream.Collectors.groupingBy;
 
-// Tasteful use of streams enhances clarity and conciseness
+// Tasteful use of streams enhances clarity and conciseness (Page 205)
 public class HybridAnagrams {
     public static void main(String[] args) throws IOException {
         Path dictionary = Paths.get(args[0]);
diff --git a/src/effectivejava/chapter7/item45/anagrams/IterativeAnagrams.java b/src/effectivejava/chapter7/item45/anagrams/IterativeAnagrams.java
index 0e315039..9cb5b2d6 100644
--- a/src/effectivejava/chapter7/item45/anagrams/IterativeAnagrams.java
+++ b/src/effectivejava/chapter7/item45/anagrams/IterativeAnagrams.java
@@ -4,7 +4,7 @@
 import java.io.IOException;
 import java.util.*;
 
-// Prints all large anagram groups in a dictionary iteratively
+// Prints all large anagram groups in a dictionary iteratively (Page 204)
 public class IterativeAnagrams {
     public static void main(String[] args) throws IOException {
         File dictionary = new File(args[0]);
diff --git a/src/effectivejava/chapter7/item45/anagrams/StreamAnagrams.java b/src/effectivejava/chapter7/item45/anagrams/StreamAnagrams.java
index 92395e0c..8d81d8b4 100644
--- a/src/effectivejava/chapter7/item45/anagrams/StreamAnagrams.java
+++ b/src/effectivejava/chapter7/item45/anagrams/StreamAnagrams.java
@@ -8,7 +8,7 @@
 
 import static java.util.stream.Collectors.groupingBy;
 
-// Overuse of streams - don't do this! - (page 205)
+// Overuse of streams - don't do this! (page 205)
 public class StreamAnagrams {
     public static void main(String[] args) throws IOException {
         Path dictionary = Paths.get(args[0]);
diff --git a/src/effectivejava/chapter7/item45/Freq.java b/src/effectivejava/chapter7/item46/Freq.java
similarity index 86%
rename from src/effectivejava/chapter7/item45/Freq.java
rename to src/effectivejava/chapter7/item46/Freq.java
index 50ce3f2b..d2903298 100644
--- a/src/effectivejava/chapter7/item45/Freq.java
+++ b/src/effectivejava/chapter7/item46/Freq.java
@@ -1,4 +1,4 @@
-package effectivejava.chapter7.item45;
+package effectivejava.chapter7.item46;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -9,12 +9,12 @@
 import static java.util.stream.Collectors.*;
 import static java.util.stream.Collectors.*;
 
-// Page 210, 211
+// Frequency table examples showing improper and proper use of stream (Page 210-11)
 public class Freq {
     public static void main(String[] args) throws FileNotFoundException {
         File file = new File(args[0]);
 
-        // Uses the streams API but not the paradigm--Don't do this!
+//        // Uses the streams API but not the paradigm--Don't do this!
 //        Map<String, Long> freq = new HashMap<>();
 //        try (Stream<String> words = new Scanner(file).tokens()) {
 //            words.forEach(word -> {
@@ -22,7 +22,7 @@ public static void main(String[] args) throws FileNotFoundException {
 //            });
 //        }
 
-        // Proper use of streams to initialize a frequency table
+        // Proper use of streams to initialize a frequency table (
         Map<String, Long> freq;
         try (Stream<String> words = new Scanner(file).tokens()) {
             freq = words
diff --git a/src/effectivejava/chapter7/item47/Adapters.java b/src/effectivejava/chapter7/item47/Adapters.java
index 566168bd..e82a867c 100644
--- a/src/effectivejava/chapter7/item47/Adapters.java
+++ b/src/effectivejava/chapter7/item47/Adapters.java
@@ -3,8 +3,9 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+// Adapters from stream to iterable and vice-versa (Page 216)
 public class Adapters {
-    // Adapter from  Stream<E> to Iterable<E>
+    // Adapter from  Stream<E> to Iterable<E> (
     public static <E> Iterable<E> iterableOf(Stream<E> stream) {
         return stream::iterator;
     }
diff --git a/src/effectivejava/chapter7/item47/PowerSet.java b/src/effectivejava/chapter7/item47/PowerSet.java
index b09e78ad..62b092be 100644
--- a/src/effectivejava/chapter7/item47/PowerSet.java
+++ b/src/effectivejava/chapter7/item47/PowerSet.java
@@ -3,6 +3,7 @@
 import java.util.*;
 
 public class PowerSet {
+    // Returns the power set of an input set as custom collection (Page 218)
     public static final <E> Collection<Set<E>> of(Set<E> s) {
         List<E> src = new ArrayList<>(s);
         if (src.size() > 30)
diff --git a/src/effectivejava/chapter7/item47/SubLists.java b/src/effectivejava/chapter7/item47/SubLists.java
index 5ad32f2d..469c4d3a 100644
--- a/src/effectivejava/chapter7/item47/SubLists.java
+++ b/src/effectivejava/chapter7/item47/SubLists.java
@@ -4,32 +4,34 @@
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-// Returns a stream of all the sublists of its input list (Pages 219-220)
+// Two ways to generate a stream of all the sublists of a list (Pages 219-20)
 public class SubLists {
-//    public static <E> Stream<List<E>> of(List<E> list) {
-//        return Stream.concat(Stream.of(Collections.emptyList()),
-//                prefixes(list).flatMap(SubLists::suffixes));
-//    }
-//
-//    private static <E> Stream<List<E>> prefixes(List<E> list) {
-//        return IntStream.rangeClosed(1, list.size())
-//                .mapToObj(end -> list.subList(0, end));
-//    }
-//
-//    private static <E> Stream<List<E>> suffixes(List<E> list) {
-//        return IntStream.range(0, list.size())
-//                .mapToObj(start -> list.subList(start, list.size()));
-//    }
-
-    // Returns a stream of all the sublists of its input list
+    // Returns a stream of all the sublists of its input list (Page 219)
     public static <E> Stream<List<E>> of(List<E> list) {
+        return Stream.concat(Stream.of(Collections.emptyList()),
+                prefixes(list).flatMap(SubLists::suffixes));
+    }
+
+    private static <E> Stream<List<E>> prefixes(List<E> list) {
+        return IntStream.rangeClosed(1, list.size())
+                .mapToObj(end -> list.subList(0, end));
+    }
+
+    private static <E> Stream<List<E>> suffixes(List<E> list) {
         return IntStream.range(0, list.size())
-                .mapToObj(start ->
-                        IntStream.rangeClosed(start + 1, list.size())
-                                .mapToObj(end -> list.subList(start, end)))
-                .flatMap(x -> x);
+                .mapToObj(start -> list.subList(start, list.size()));
     }
 
+//    // Returns a stream of all the sublists of its input list, excluding the empty list
+//    // This version is derived from the obvious iterative code (Page 220)
+//    public static <E> Stream<List<E>> of(List<E> list) {
+//        return IntStream.range(0, list.size())
+//                .mapToObj(start ->
+//                        IntStream.rangeClosed(start + 1, list.size())
+//                                .mapToObj(end -> list.subList(start, end)))
+//                .flatMap(x -> x);
+//    }
+
     public static void main(String[] args) {
         List<String> list = Arrays.asList(args);
         SubLists.of(list).forEach(System.out::println);
diff --git a/src/effectivejava/chapter7/item48/ParallelMersennePrimes.java b/src/effectivejava/chapter7/item48/ParallelMersennePrimes.java
index 503e3171..039ae3af 100644
--- a/src/effectivejava/chapter7/item48/ParallelMersennePrimes.java
+++ b/src/effectivejava/chapter7/item48/ParallelMersennePrimes.java
@@ -5,7 +5,7 @@
 
 import static java.math.BigInteger.*;
 
-// Parallel stream-based program to generate the first 20 Mersenne primes - HANGS!!!
+// Parallel stream-based program to generate the first 20 Mersenne primes - HANGS!!! (Page 222)
 public class ParallelMersennePrimes {
     public static void main(String[] args) {
         primes().map(p -> TWO.pow(p.intValueExact()).subtract(ONE))
diff --git a/src/effectivejava/chapter7/item48/ParallelPrimeCounting.java b/src/effectivejava/chapter7/item48/ParallelPrimeCounting.java
index ebccf71b..992df07b 100644
--- a/src/effectivejava/chapter7/item48/ParallelPrimeCounting.java
+++ b/src/effectivejava/chapter7/item48/ParallelPrimeCounting.java
@@ -4,7 +4,7 @@
 import java.util.stream.LongStream;
 
 public class ParallelPrimeCounting {
-    // Prime-counting stream pipeline - parallel version
+    // Prime-counting stream pipeline - parallel version (Page 225)
     static long pi(long n) {
         return LongStream.rangeClosed(2, n)
                 .parallel()
diff --git a/src/effectivejava/chapter8/item50/Attack.java b/src/effectivejava/chapter8/item50/Attacks.java
similarity index 68%
rename from src/effectivejava/chapter8/item50/Attack.java
rename to src/effectivejava/chapter8/item50/Attacks.java
index ddc16eda..2acf8c41 100644
--- a/src/effectivejava/chapter8/item50/Attack.java
+++ b/src/effectivejava/chapter8/item50/Attacks.java
@@ -1,17 +1,17 @@
 package effectivejava.chapter8.item50;
 import java.util.*;
 
-// Two attacks on the internals of an "immutable" period
-public class Attack {
+// Two attacks on the internals of an "immutable" period (232-3)
+public class Attacks {
     public static void main(String[] args) {
-        // Attack the internals of a Period instance  (page 232)
+        // Attack the internals of a Period instance  (Page 232)
         Date start = new Date();
         Date end = new Date();
         Period p = new Period(start, end);
         end.setYear(78);  // Modifies internals of p!
         System.out.println(p);
 
-        // Second attack on the internals of a Period instance
+        // Second attack on the internals of a Period instance  (Page 233)
         start = new Date();
         end = new Date();
         p = new Period(start, end);
diff --git a/src/effectivejava/chapter8/item50/Period.java b/src/effectivejava/chapter8/item50/Period.java
index a02240d8..d3181d9f 100644
--- a/src/effectivejava/chapter8/item50/Period.java
+++ b/src/effectivejava/chapter8/item50/Period.java
@@ -1,7 +1,7 @@
 package effectivejava.chapter8.item50;
 import java.util.*;
 
-// Broken "immutable" time period class - Page 231-3
+// Broken "immutable" time period class (Pages 231-3)
 public final class Period {
     private final Date start;
     private final Date end;
@@ -31,7 +31,7 @@ public String toString() {
         return start + " - " + end;
     }
 
-//    // Repaired constructor - makes defensive copies of parameters
+//    // Repaired constructor - makes defensive copies of parameters (Page 232)
 //    public Period(Date start, Date end) {
 //        this.start = new Date(start.getTime());
 //        this.end   = new Date(end.getTime());
@@ -40,7 +40,7 @@ public String toString() {
 //            throw new IllegalArgumentException(
 //                    this.start + " after " + this.end);
 //    }
-
+//
 //    // Repaired accessors - make defensive copies of internal fields (Page 233)
 //    public Date start() {
 //        return new Date(start.getTime());
diff --git a/src/effectivejava/chapter8/item52/Champagne.java b/src/effectivejava/chapter8/item52/Champagne.java
index fd1c81ee..552a47e4 100644
--- a/src/effectivejava/chapter8/item52/Champagne.java
+++ b/src/effectivejava/chapter8/item52/Champagne.java
@@ -1,5 +1,6 @@
 package effectivejava.chapter8.item52;
 
+// Classification using method overrriding (Page 239)
 class Champagne extends SparklingWine {
     @Override String name() { return "champagne"; }
 }
diff --git a/src/effectivejava/chapter8/item52/CollectionClassifier.java b/src/effectivejava/chapter8/item52/CollectionClassifier.java
index fc92d2aa..64ec4182 100644
--- a/src/effectivejava/chapter8/item52/CollectionClassifier.java
+++ b/src/effectivejava/chapter8/item52/CollectionClassifier.java
@@ -26,9 +26,4 @@ public static void main(String[] args) {
         for (Collection<?> c : collections)
             System.out.println(classify(c));
     }
-       // Repaired  static classifier method. (Page 240)
-//    public static String classify(Collection<?> c) {
-//        return c instanceof Set  ? "Set" :
-//                c instanceof List ? "List" : "Unknown Collection";
-//    }
 }
diff --git a/src/effectivejava/chapter8/item52/FixedCollectionClassifier.java b/src/effectivejava/chapter8/item52/FixedCollectionClassifier.java
new file mode 100644
index 00000000..99b9c02c
--- /dev/null
+++ b/src/effectivejava/chapter8/item52/FixedCollectionClassifier.java
@@ -0,0 +1,23 @@
+package effectivejava.chapter8.item52;
+
+import java.math.BigInteger;
+import java.util.*;
+
+// Repaired  static classifier method. (Page 240)
+public class FixedCollectionClassifier {
+    public static String classify(Collection<?> c) {
+        return c instanceof Set  ? "Set" :
+                c instanceof List ? "List" : "Unknown Collection";
+    }
+
+    public static void main(String[] args) {
+        Collection<?>[] collections = {
+                new HashSet<String>(),
+                new ArrayList<BigInteger>(),
+                new HashMap<String, String>().values()
+        };
+
+        for (Collection<?> c : collections)
+            System.out.println(classify(c));
+    }
+}
diff --git a/src/effectivejava/chapter8/item52/Overriding.java b/src/effectivejava/chapter8/item52/Overriding.java
index 7f5b2e69..9c670a46 100644
--- a/src/effectivejava/chapter8/item52/Overriding.java
+++ b/src/effectivejava/chapter8/item52/Overriding.java
@@ -2,6 +2,7 @@
 
 import java.util.List;
 
+// Classification using method overrriding (Page 239)
 public class Overriding {
     public static void main(String[] args) {
         List<Wine> wineList = List.of(
diff --git a/src/effectivejava/chapter8/item52/SetList.java b/src/effectivejava/chapter8/item52/SetList.java
index 2a848f37..f54125d3 100644
--- a/src/effectivejava/chapter8/item52/SetList.java
+++ b/src/effectivejava/chapter8/item52/SetList.java
@@ -1,7 +1,7 @@
 package effectivejava.chapter8.item52;
 import java.util.*;
 
-// What does this program print? - Page 241
+// What does this program print? (Page 241)
 public class SetList {
     public static void main(String[] args) {
         Set<Integer> set = new TreeSet<>();
diff --git a/src/effectivejava/chapter8/item52/SparklingWine.java b/src/effectivejava/chapter8/item52/SparklingWine.java
index 6602b1dc..19fd9614 100644
--- a/src/effectivejava/chapter8/item52/SparklingWine.java
+++ b/src/effectivejava/chapter8/item52/SparklingWine.java
@@ -1,5 +1,6 @@
 package effectivejava.chapter8.item52;
 
+// Classification using method overrriding (Page 239)
 class SparklingWine extends Wine {
     @Override String name() { return "sparkling wine"; }
 }
diff --git a/src/effectivejava/chapter8/item52/Wine.java b/src/effectivejava/chapter8/item52/Wine.java
index 7e1506c0..8754d3ae 100644
--- a/src/effectivejava/chapter8/item52/Wine.java
+++ b/src/effectivejava/chapter8/item52/Wine.java
@@ -1,5 +1,6 @@
 package effectivejava.chapter8.item52;
 
+// Classification using method overrriding (Page 239)
 class Wine {
     String name() { return "wine"; }
 }
diff --git a/src/effectivejava/chapter8/item53/Varargs.java b/src/effectivejava/chapter8/item53/Varargs.java
index d427213d..89ea94f0 100644
--- a/src/effectivejava/chapter8/item53/Varargs.java
+++ b/src/effectivejava/chapter8/item53/Varargs.java
@@ -2,10 +2,9 @@
 
 import java.util.stream.IntStream;
 
-// Sample uses of varargs
+// Sample uses of varargs (Pages 245-6)
 public class Varargs {
-
-    // Simple use of varargs - Page 245
+    // Simple use of varargs (Page 245)
     static int sum(int... args) {
         int sum = 0;
         for (int arg : args)
@@ -13,12 +12,7 @@ static int sum(int... args) {
         return sum;
     }
 
-    // Simple use of varargs - Page 197
-    static int sum2(int... args) {
-        return IntStream.of(args).sum();
-    }
-
-//    // The WRONG way to use varargs to pass one or more arguments!  - Page 245
+//    // The WRONG way to use varargs to pass one or more arguments! (Page 245)
 //    static int min(int... args) {
 //        if (args.length == 0)
 //            throw new IllegalArgumentException("Too few arguments");
@@ -29,7 +23,7 @@ static int sum2(int... args) {
 //        return min;
 //    }
 
-    // The right way to use varargs to pass one or more arguments   - Page 246
+    // The right way to use varargs to pass one or more arguments (Page 246)
     static int min(int firstArg, int... remainingArgs) {
         int min = firstArg;
         for (int arg : remainingArgs)
@@ -38,7 +32,6 @@ static int min(int firstArg, int... remainingArgs) {
         return min;
     }
 
-
     public static void main(String[] args) {
         System.out.println(sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         System.out.println(min(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
diff --git a/src/effectivejava/chapter8/item55/Max.java b/src/effectivejava/chapter8/item55/Max.java
index 42f6181e..1455532f 100644
--- a/src/effectivejava/chapter8/item55/Max.java
+++ b/src/effectivejava/chapter8/item55/Max.java
@@ -2,9 +2,9 @@
 
 import java.util.*;
 
-// Optionals     (P. 248) OK (Checked)
+// Using Optional<T> as a return type (Pages 249-251)
 public class Max {
-//    // Returns maximum value in collection - throws exception if empty
+//    // Returns maximum value in collection - throws exception if empty (Page 249)
 //    public static <E extends Comparable<E>> E max(Collection<E> c) {
 //        if (c.isEmpty())
 //            throw new IllegalArgumentException("Empty collection");
@@ -17,7 +17,7 @@ public class Max {
 //        return result;
 //    }
 
-//    // Returns maximum value in collection as an Optional<E>
+//    // Returns maximum value in collection as an Optional<E> (Page 250)
 //    public static <E extends Comparable<E>>
 //    Optional<E> max(Collection<E> c) {
 //        if (c.isEmpty())
@@ -31,7 +31,7 @@ public class Max {
 //        return Optional.of(result);
 //    }
 
-    // Returns max val in collection as Optional<E> - uses stream
+    // Returns max val in collection as Optional<E> - uses stream (Page 250)
     public static <E extends Comparable<E>>
     Optional<E> max(Collection<E> c) {
         return c.stream().max(Comparator.naturalOrder());
@@ -40,7 +40,9 @@ Optional<E> max(Collection<E> c) {
     public static void main(String[] args) {
         List<String> words = Arrays.asList(args);
 
-        // Using an optional to provide a chosen default value
+        System.out.println(max(words));
+
+        // Using an optional to provide a chosen default value (Page 251)
         String lastWordInLexicon = max(words).orElse("No words...");
         System.out.println(lastWordInLexicon);
     }
diff --git a/src/effectivejava/chapter8/item55/ParentPid.java b/src/effectivejava/chapter8/item55/ParentPid.java
index f2c9054a..8b59519f 100644
--- a/src/effectivejava/chapter8/item55/ParentPid.java
+++ b/src/effectivejava/chapter8/item55/ParentPid.java
@@ -2,15 +2,17 @@
 
 import java.util.Optional;
 
-//    Page 250
+// Avoiding unnecessary use of Optional's isPresent method (Page 252)
 public class ParentPid {
     public static void main(String[] args) {
         ProcessHandle ph = ProcessHandle.current();
 
+        // Inappropriate use of isPresent
         Optional<ProcessHandle> parentProcess = ph.parent();
         System.out.println("Parent PID: " + (parentProcess.isPresent() ?
                 String.valueOf(parentProcess.get().pid()) : "N/A"));
 
+        // Equivalent (and superior) code using orElse
         System.out.println("Parent PID: " +
             ph.parent().map(h -> String.valueOf(h.pid())).orElse("N/A"));
     }
diff --git a/src/effectivejava/chapter8/item56/DocExamples.java b/src/effectivejava/chapter8/item56/DocExamples.java
new file mode 100644
index 00000000..24452f54
--- /dev/null
+++ b/src/effectivejava/chapter8/item56/DocExamples.java
@@ -0,0 +1,97 @@
+package effectivejava.chapter8.item56;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+
+// Documentation comment examples (Pages 255-9)
+public class DocExamples<E> {
+    // Method comment (Page 255)
+    /**
+     * Returns the element at the specified position in this list.
+     *
+     * <p>This method is <i>not</i> guaranteed to run in constant
+     * time. In some implementations it may run in time proportional
+     * to the element position.
+     *
+     * @param  index index of element to return; must be
+     *         non-negative and less than the size of this list
+     * @return the element at the specified position in this list
+     * @throws IndexOutOfBoundsException if the index is out of range
+     *         ({@code index < 0 || index >= this.size()})
+     */
+    E get(int index) {
+        return null;
+    }
+
+    // Use of @implSpec to describe self-use patterns & other visible implementation details. (Page 256)
+    /**
+     * Returns true if this collection is empty.
+     *
+     * @implSpec This implementation returns {@code this.size() == 0}.
+     *
+     * @return true if this collection is empty
+     */
+    public boolean isEmpty() {
+        return false;
+    }
+
+    // Use of the @literal tag to include HTML and javadoc metacharacters in javadoc comments. (Page 256)
+    /**
+     * A geometric series converges if {@literal |r| < 1}.
+     */
+    public void fragment() {
+    }
+
+    // Controlling summary description when there is a period in the first "sentence" of doc comment. (Page 257)
+    /**
+     * A suspect, such as Colonel Mustard or {@literal Mrs. Peacock}.
+     */
+    public enum FixedSuspect {
+        MISS_SCARLETT, PROFESSOR_PLUM, MRS_PEACOCK, MR_GREEN, COLONEL_MUSTARD, MRS_WHITE
+    }
+
+
+    // Generating a javadoc index entry in Java 9 and later releases. (Page 258)
+    /**
+     * This method complies with the {@index IEEE 754} standard.
+     */
+    public void fragment2() {
+    }
+
+    // Documenting enum constants (Page 258)
+    /**
+     * An instrument section of a symphony orchestra.
+     */
+    public enum OrchestraSection {
+        /** Woodwinds, such as flute, clarinet, and oboe. */
+        WOODWIND,
+
+        /** Brass instruments, such as french horn and trumpet. */
+        BRASS,
+
+        /** Percussion instruments, such as timpani and cymbals. */
+        PERCUSSION,
+
+        /** Stringed instruments, such as violin and cello. */
+        STRING;
+    }
+
+    // Documenting an annotation type (Page 259)
+    /**
+     * Indicates that the annotated method is a test method that
+     * must throw the designated exception to pass.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface ExceptionTest {
+        /**
+         * The exception that the annotated test method must throw
+         * in order to pass. (The test is permitted to throw any
+         * subtype of the type described by this class object.)
+         */
+        Class<? extends Throwable> value();
+    }
+}
+