List of Figures

Chapter 1. Why Scala?

Figure 1.1. A pure function that maps values of X to exactly one value of Y

Chapter 2. Getting started

Figure 2.1. The syntax of the Scala function declaration

Figure 2.2. The syntax of a for-comprehension

Chapter 3. OOP in Scala

Figure 3.1. Class hierarchy of UpdatableCollection before class linearization

Figure 3.2. Class linearization of UpdatableCollection

Figure 3.3. Class hierarchy of Scala with subtypes and views

Chapter 4. Having fun with functional data structures

Figure 4.1. Scala collection hierarchy with three main types of collections: Set, Seq, and Map

Figure 4.2. Parallel collections implemented in terms of split and combine operations using the Fork/Join framework

Figure 4.3. Scala parallel collection hierarchy

Chapter 5. Functional programming

Figure 5.1. A pure function where each value of X is mapped to exactly one value of Y

Figure 5.2. Separating pure and side-effecting (impure) code. The side-effecting code should form a thin layer around the application.

Figure 5.3. A partial function that’s only defined for a subset of parameter values, in this case only for 1 and 3. Compare this figure with figure 5.1.

Chapter 6. Building web applications in functional style

Figure 6.1. Kanban board with four phases.

Figure 6.2. SBT project structure

Figure 6.3. WeKanban project structure

Figure 6.4. The way HTTP requests are handled by Scalaz

Chapter 7. Connecting to a database

Figure 7.1. The H2 console

Figure 7.2. The Create a new Story screen

Figure 7.3. The weKanban project with JavaScript files for drag-and-drop

Figure 7.4. Kanban board with stories in ready phase

Chapter 8. Building scalable and extensible components

Figure 8.1. Ordering system with three components: order, inventory, and shipping

Figure 8.2. Types classify values, and kinds classify types.

Chapter 9. Concurrency programming in Scala

Figure 9.1. A concurrent application running in a single CPU core with two threads

Figure 9.2. A concurrent and parallel application running in a two-CPU core with two threads. Both threads are running at the same time.

Figure 9.3. Actor system with hierarchy of actors

Figure 9.4. Showing step by step how a new actor is started and how an already running actor bides its time

Figure 9.5. WordCountMaster and WordCountWorker actors are communicating by sending messages. The main program in the figure starts the word count process.

Figure 9.6. Supervisor hierarchy in Akka

Figure 9.7. One-for-One restart strategy

Figure 9.8. All-for-One strategy

Chapter 10. Building confidence with testing

Figure 10.1. The output from running ScalaCheck from the SBT prompt

Figure 10.2. Test-driven development cycle

Figure 10.3. CalculatePriceService and its calculators

Figure 10.4. Specs output of running a specification

Chapter 12. Scalable and distributed applications using Akka

Figure 12.1. Akka core modules

Figure 12.2. Two actor systems running in two different nodes

Figure 12.3. State represented in imperative programming

Figure 12.4. State represented in STM

Figure 12.4. Homepage of the Akkaoogle application

Figure 12.5. Akkaoogle architecture

Figure 12.6. Akkaoogle project structure