Books & Videos

Table of Contents

  1. Chapter 1 Zero to Sixty: Introducing Scala

    1. Why Scala?

    2. Installing Scala

    3. A Taste of Scala

    4. A Taste of Concurrency

    5. Recap and What’s Next

  2. Chapter 2 Type Less, Do More

    1. Semicolons

    2. Variable Declarations

    3. Ranges

    4. Partial Functions

    5. Method Declarations

    6. Inferring Type Information

    7. Reserved Words

    8. Literal Values

    9. Option, Some, and None: Avoiding nulls

    10. Sealed Class Hierarchies

    11. Organizing Code in Files and Namespaces

    12. Importing Types and Their Members

    13. Abstract Types Versus Parameterized Types

    14. Recap and What’s Next

  3. Chapter 3 Rounding Out the Basics

    1. Operator Overloading?

    2. Methods with Empty Argument Lists

    3. Precedence Rules

    4. Domain-Specific Languages

    5. Scala if Statements

    6. Scala for Comprehensions

    7. Other Looping Constructs

    8. Conditional Operators

    9. Using try, catch, and finally Clauses

    10. Call by Name, Call by Value

    11. lazy val

    12. Enumerations

    13. Interpolated Strings

    14. Traits: Interfaces and “Mixins” in Scala

    15. Recap and What’s Next

  4. Chapter 4 Pattern Matching

    1. A Simple Match

    2. Values, Variables, and Types in Matches

    3. Matching on Sequences

    4. Matching on Tuples

    5. Guards in case Clauses

    6. Matching on case Classes

    7. Matching on Variable Argument Lists

    8. Matching on Regular Expressions

    9. More on Binding Variables in case Clauses

    10. More on Type Matching

    11. Sealed Hierarchies and Exhaustive Matches

    12. Other Uses of Pattern Matching

    13. Concluding Remarks on Pattern Matching

    14. Recap and What’s Next

  5. Chapter 5 Implicits

    1. Implicit Arguments

    2. Scenarios for Implicit Arguments

    3. Implicit Conversions

    4. Type Class Pattern

    5. Technical Issues with Implicits

    6. Implicit Resolution Rules

    7. Scala’s Built-in Implicits

    8. Wise Use of Implicits

    9. Recap and What’s Next

  6. Chapter 6 Functional Programming in Scala

    1. What Is Functional Programming?

    2. Functional Programming in Scala

    3. Recursion

    4. Tail Calls and Tail-Call Optimization

    5. Partially Applied Functions Versus Partial Functions

    6. Currying and Other Transformations on Functions

    7. Functional Data Structures

    8. Traversing, Mapping, Filtering, Folding, and Reducing

    9. Left Versus Right Traversals

    10. Combinators: Software’s Best Component Abstractions

    11. What About Making Copies?

    12. Recap and What’s Next

  7. Chapter 7 for Comprehensions in Depth

    1. Recap: The Elements of for Comprehensions

    2. for Comprehensions: Under the Hood

    3. Translation Rules of for Comprehensions

    4. Options and Other Container Types

    5. Recap and What’s Next

  8. Chapter 8 Object-Oriented Programming in Scala

    1. Class and Object Basics

    2. Reference Versus Value Types

    3. Value Classes

    4. Parent Types

    5. Constructors in Scala

    6. Fields in Classes

    7. Validating Input

    8. Calling Parent Class Constructors (and Good Object-Oriented Design)

    9. Nested Types

    10. Recap and What’s Next

  9. Chapter 9 Traits

    1. Interfaces in Java 8

    2. Traits as Mixins

    3. Stackable Traits

    4. Constructing Traits

    5. Class or Trait?

    6. Recap and What’s Next

  10. Chapter 10 The Scala Object System, Part I

    1. Parameterized Types: Variance Under Inheritance

    2. The Scala Type Hierarchy

    3. Much Ado About Nothing (and Null)

    4. Products, Case Classes, and Tuples

    5. The Predef Object

    6. Equality of Objects

    7. Recap and What’s Next

  11. Chapter 11 The Scala Object System, Part II

    1. Overriding Members of Classes and Traits

    2. Linearization of an Object’s Hierarchy

    3. Recap and What’s Next

  12. Chapter 12 The Scala Collections Library

    1. Generic, Mutable, Immutable, Concurrent, and Parallel Collections, Oh My!

    2. Choosing a Collection

    3. Design Idioms in the Collections Library

    4. Specialization for Value Types

    5. Recap and What’s Next

  13. Chapter 13 Visibility Rules

    1. Public Visibility: The Default

    2. Visibility Keywords

    3. Public Visibility

    4. Protected Visibility

    5. Private Visibility

    6. Scoped Private and Protected Visibility

    7. Final Thoughts on Visibility

    8. Recap and What’s Next

  14. Chapter 14 Scala’s Type System, Part I

    1. Parameterized Types

    2. Type Bounds

    3. Context Bounds

    4. View Bounds

    5. Understanding Abstract Types

    6. Self-Type Annotations

    7. Structural Types

    8. Compound Types

    9. Existential Types

    10. Recap and What’s Next

  15. Chapter 15 Scala’s Type System, Part II

    1. Path-Dependent Types

    2. Dependent Method Types

    3. Type Projections

    4. Types for Values

    5. Higher-Kinded Types

    6. Type Lambdas

    7. Self-Recursive Types: F-Bounded Polymorphism

    8. Recap and What’s Next

  16. Chapter 16 Advanced Functional Programming

    1. Algebraic Data Types

    2. Category Theory

    3. Recap and What’s Next

  17. Chapter 17 Tools for Concurrency

    1. The scala.sys.process Package

    2. Futures

    3. Robust, Scalable Concurrency with Actors

    4. Akka: Actors for Scala

    5. Pickling and Spores

    6. Reactive Programming

    7. Recap and What’s Next

  18. Chapter 18 Scala for Big Data

    1. Big Data: A Brief History

    2. Improving MapReduce with Scala

    3. Moving Beyond MapReduce

    4. Categories for Mathematics

    5. A List of Scala-Based Data Tools

    6. Recap and What’s Next

  19. Chapter 19 Dynamic Invocation in Scala

    1. A Motivating Example: ActiveRecord in Ruby on Rails

    2. Dynamic Invocation in Scala with the Dynamic Trait

    3. DSL Considerations

    4. Recap and What’s Next

  20. Chapter 20 Domain-Specific Languages in Scala

    1. Examples: XML and JSON DSLs for Scala

    2. Internal DSLs

    3. External DSLs with Parser Combinators

    4. Internal Versus External DSLs: Final Thoughts

    5. Recap and What’s Next

  21. Chapter 21 Scala Tools and Libraries

    1. Command-Line Tools

    2. Build Tools

    3. Integration with IDEs and Text Editors

    4. Test-Driven Development in Scala

    5. Third-Party Libraries

    6. Recap and What’s Next

  22. Chapter 22 Java Interoperability

    1. Using Java Names in Scala Code

    2. Java and Scala Generics

    3. JavaBean Properties

    4. AnyVal Types and Java Primitives

    5. Scala Names in Java Code

    6. Recap and What’s Next

  23. Chapter 23 Application Design

    1. Recap of What We Already Know

    2. Annotations

    3. Traits as Modules

    4. Design Patterns

    5. Better Design with Design by Contract

    6. The Parthenon Architecture

    7. Recap and What’s Next

  24. Chapter 24 Metaprogramming: Macros and Reflection

    1. Tools for Understanding Types

    2. Runtime Reflection

    3. Scala’s Advanced Runtime Reflection API

    4. Macros

    5. Wrapping Up and Looking Ahead

  25. Appendix References