What this book covers

Chapter 1, Getting Started with Scala Programming, introduces you to programming paradigms and explains why choosing Scala gives you an edge over other languages. This chapter ends with demonstrating our first Scala program.

Chapter 2, Building Blocks of Scala, explains the basic constructs required to write a simple program. We'll discuss data types, variables, and literals, with a little bit on type inference.

Chapter 3, Shaping our Scala Program, takes you through looping constructs, control structures, and, most importantly, pattern matching.

Chapter 4, Give Meaning to Programs with Functions, discusses the important functions, function literals, and function call mechanisms. We'll end the chapter with a discussion on partial functions.

Chapter 5, Getting Familiar with Scala Collections, introduces you to Scala's rich collections. We'll discuss mutable and immutable collections, and talk about choosing the most suitable collection.

Chapter 6, Object-Oriented Scala Basics, introduces you to object-oriented Scala. We'll talk about objects, classes, and case classes.

Chapter 7, Next Steps in Object-Oriented Scala, talks about default and parameterized constructors. We will also be introduced to class fields, inheritance, and traits.

Chapter 8, More on Functions, differentiates between functions and methods. We'll talk about partially applied functions, closures, and higher-order functions.

Chapter 9, Using Powerful Functional Constructs, covers some of the important topics in Scala, such as tail-call optimization and currying. Then, we'll discuss combinators and end the chapter with an introduction to parameterized types.

Chapter 10, Advanced Functional Programming, takes you into depth of variance and types. We'll also discuss abstract versus parameterized types.

Chapter 11, Working with Implicits and Exceptions, discusses these two important topics, though they are not related, but are essential to the language. An introduction to implicits and understanding how they work will be the key points of this chapter. We'll also discuss the way we handle exceptions in Scala.

Chapter 12, Introduction to Akka, discusses one of the most talked about toolkits the Scala ecosystem provides. Akka is based on the Actor Model, and that's the main attraction of this chapter.

Chapter 13, Concurrent programming in Scala, takes you deeper into concurrent programming. We'll also cover asynchronous programming using Futures and Promises.

Chapter 14, Programming with Reactive Extensions, talks about reactive programming and the API available in Scala for reactive programming. We'll discuss RxScala, a reactive extension, with a few examples.

Chapter 15, Testing in Scala, covers testing. Our approach will be test-driven. We'll use ScalaTest and try out the library to write test cases for our Scala programs.