Chapter 1. Scala—a blended language
1.1. Functional programming meets object orientation
1.2. Static typing and expressiveness
1.2.3. Dropping verbose syntax
1.3. Transparently working with the JVM
2.1. Learn to use the Read Eval Print Loop (REPL)
2.1.1. Experiment-driven development
Chapter 3. Modicum of style—coding conventions
3.1. Avoid coding conventions from other languages
3.2. Dangling operators and parenthetical expressions
3.3. Use meaningful variable names
3.4. Always mark overridden methods
3.5. Annotate for expected optimizations
Chapter 4. Utilizing object orientation
4.1. Limit code inside an object or trait’s body to initialization logic
4.2. Provide empty implementations for abstract methods on traits
4.3. Composition can include inheritance
4.4. Promote abstract interface into its own trait
Chapter 5. Using implicits to write expressive code
5.1. Introduction to implicits
5.2. Enhancing existing classes with implicit views
5.3. Utilize implicit parameters with defaults
5.4. Limiting the scope of implicits
6.3. Type parameters and higher-kinded types
Chapter 7. Using implicits and types together
7.1. Context bounds and view bounds
7.2. Capturing types with implicits
7.4. Conditional execution using the type system
Chapter 8. Using the right collection
8.4. Changing evaluation with views and parallel collections
8.5. Writing methods to use with all collection types
9.2. Use typed, transparent references
9.4. Limit overload using scheduler zones
Chapter 10. Integrating Scala with Java
10.1. The language mismatch between Scala and Java
10.1.1. Differences in primitive boxing
10.2. Be wary of implicit conversions
10.3. Be wary of Java serialization
10.4. Annotate your annotations
Chapter 11. Patterns in functional programming
11.1. Category theory for computer science
11.2. Functors and monads, and how they relate to categories
11.3. Currying and applicative style