Books & Videos

Table of Contents

  1. Chapter 1 Zero to Sixty: Introducing Scala

    1. Why Scala?

    2. Installing Scala

    3. For More Information

    4. A Taste of Scala

    5. A Taste of Concurrency

    6. Recap and What’s Next

  2. Chapter 2 Type Less, Do More

    1. In This Chapter

    2. Semicolons

    3. Variable Declarations

    4. Method Declarations

    5. Inferring Type Information

    6. Literals

    7. Tuples

    8. Option, Some, and None: Avoiding nulls

    9. Organizing Code in Files and Namespaces

    10. Importing Types and Their Members

    11. Abstract Types And Parameterized Types

    12. Reserved Words

    13. Recap and What’s Next

  3. Chapter 3 Rounding Out the Essentials

    1. Operator? Operator?

    2. Methods Without Parentheses and Dots

    3. Domain-Specific Languages

    4. Scala if Statements

    5. Scala for Comprehensions

    6. Other Looping Constructs

    7. Conditional Operators

    8. Pattern Matching

    9. Enumerations

    10. Recap and What’s Next

  4. Chapter 4 Traits

    1. Introducing Traits

    2. Stackable Traits

    3. Constructing Traits

    4. Recap and What’s Next

  5. Chapter 5 Basic Object-Oriented Programming in Scala

    1. Class and Object Basics

    2. Parent Classes

    3. Constructors in Scala

    4. Nested Classes

    5. Visibility Rules

    6. Recap and What’s Next

  6. Chapter 6 Advanced Object-Oriented Programming In Scala

    1. Overriding Members of Classes and Traits

    2. Companion Objects

    3. Case Classes

    4. Equality of Objects

    5. Recap and What’s Next

  7. Chapter 7 The Scala Object System

    1. The Predef Object

    2. Classes and Objects: Where Are the Statics?

    3. Sealed Class Hierarchies

    4. The Scala Type Hierarchy

    5. Linearization of an Object’s Hierarchy

    6. Recap and What’s Next

  8. Chapter 8 Functional Programming in Scala

    1. What Is Functional Programming?

    2. Functional Programming in Scala

    3. Recursion

    4. Tail Calls and Tail-Call Optimization

    5. Functional Data Structures

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

    7. Pattern Matching

    8. Partial Functions

    9. Currying

    10. Implicits

    11. Implicit Function Parameters

    12. Call by Name, Call by Value

    13. Lazy Vals

    14. Recap: Functional Component Abstractions

  9. Chapter 9 Robust, Scalable Concurrency with Actors

    1. The Problems of Shared, Synchronized State

    2. Actors

    3. Actors in Scala

    4. Traditional Concurrency in Scala: Threading and Events

    5. Recap and What’s Next

  10. Chapter 10 Herding XML in Scala

    1. Reading XML

    2. Writing XML

    3. Recap and What’s Next

  11. Chapter 11 Domain-Specific Languages in Scala

    1. Internal DSLs

    2. External DSLs with Parser Combinators

    3. Recap and What’s Next

  12. Chapter 12 The Scala Type System

    1. Reflecting on Types

    2. Understanding Parameterized Types

    3. Variance Under Inheritance

    4. Type Bounds

    5. Nothing and Null

    6. Understanding Abstract Types

    7. Path-Dependent Types

    8. Value Types

    9. Self-Type Annotations

    10. Structural Types

    11. Existential Types

    12. Infinite Data Structures and Laziness

    13. Recap and What’s Next

  13. Chapter 13 Application Design

    1. Annotations

    2. Enumerations Versus Pattern Matching

    3. Thoughts On Annotations and Enumerations

    4. Using Nulls Versus Options

    5. Exceptions and the Alternatives

    6. Scalable Abstractions

    7. Effective Design of Traits

    8. Design Patterns

    9. Better Design with Design By Contract

    10. Recap and What’s Next

  14. Chapter 14 Scala Tools, Libraries, and IDE Support

    1. Command-Line Tools

    2. Build Tools

    3. Integration with IDEs

    4. Test-Driven Development in Scala

    5. Other Notable Scala Libraries and Tools

    6. Java Interoperability

    7. Java Library Interoperability

    8. Recap and What’s Next

  1. Appendix References

  2. Glossary

  3. Colophon