Book · Editorial review
Functional Programming in Scala
A rigorous tutorial that teaches functional programming through exercises, rewarding active practice and careful separation of concepts from edition-specific language details.
A source-based editorial guide. Read the sources and review basis.
What you can learn
Paul Chiusano and Rúnar Bjarnason introduce functional programming through Scala, progressing from basic techniques toward more advanced abstractions with exercises and examples. The original edition emphasizes functions that can be understood without relying on changing program state. A later second edition adds another author and updates coverage for Scala 3. [1][2]
The practical strength is a way of reasoning about software. When a small transformation has explicit inputs and outputs, a programmer can examine its behavior more easily and combine it with other parts. The exercises matter because understanding the terminology is different from being able to design working code.
Read critically
This is a demanding programming tutorial, not a general introduction to using computers. Some experience with programming is helpful, and code should be checked against the edition and language version being used. The library's two-author credit points toward the original edition; it should not be silently described as the newer three-author revision.
This is best for programmers willing to work through problems rather than only listen. Functional techniques are useful tools, but the aim should be clearer, dependable software rather than adopting abstractions for their own sake.
A seven-day value experiment
Choose a small non-sensitive data task, such as turning a public list of event names into a consistently sorted list. Implement one transformation with explicit input and output, then write a few meaningful examples covering ordinary and empty input.
Use a local practice project and the publisher's edition-matched resources. Avoid changing production systems or processing private data. Ask another programmer whether the function's behavior is clear from its interface. The observable benefit is one working component you can explain, check, and reuse without hidden assumptions.
Discuss: When does an abstraction make a program easier to reason about, and when does it merely make it harder to read?
Sources and review basis
Author or publisher information and available excerpts; original critical appraisal and practical application. Full-text access is not claimed.
The practical experiment and discussion questions are Môle FM editorial suggestions. The source links help you examine the book and the claims for yourself.