Programming Scala, 3rd Edition

Chapter 23. Application Design

Until now, we have mostly discussed language features. Most of the examples we’ve studied have been small, although I tried to make them realistic and useful. Actually, small is a very good thing. Drastic reduction in code size means all the problems of software development diminish in significance.

Not all applications can be small, however. This chapter considers the concerns of large, evolving APIs and applications. We’ll discuss a few Scala language and API features that we haven’t covered yet, consider a few design patterns and idioms, discuss architecture concepts, and balance object-oriented versus functional design techniques.

Recap of What We Already Know

Let’s recap a few of the concepts we’ve covered already that make small design problems easier to solve and thereby provide a stable foundation for applications.

Functional composition

Most of the book examples have been tiny in large part because we’ve used the concise, powerful combinators provided by collections and other containers. They allow us to compose logic with a minimum amount of code.

Types, especially parametric polymorphism

Types enforce constraints. Ideally, they express as much information as possible about the behavior of our programs. For example, using Option[T] can eliminate the use of nulls. Parameterized types and abstract type members are tools for abstraction and code reuse.

Mixin traits

Traits enable modularized and composable behaviors.

for comprehensions ...