What do you think?
Rate this book
Functional and Concurrent Programming: Core Concepts and Features
Leverage Modern Language Constructs to Write High-Quality Code Faster The functional and concurrent programming language features supported by modern languages can be challenging, even for experienced developers. These features may appear intimidating to OOP programmers because of a misunderstanding of how they work. Programmers first need to become familiar with the abstract concepts that underlie these powerful features.
In Functional and Concurrent Programming , Michel Charpentier introduces a core set of programming language constructs that will help you be productive in a variety of programming languages--now and in the future. Charpentier illustrates key concepts with numerous small, focused code examples, written in Scala, and with case studies that provide a thorough grounding in functional and concurrent programming skills. These skills will carry from language to language--including the most recent incarnations of Java. Using these features will enable developers and programmers to write high-quality code that is easier to understand, debug, optimize, and evolve.
Key topics covered include: Recursion and tail recursion Pattern matching and algebraic datatypes Persistent structures and immutability Higher-order functions and lambda expressions Lazy evaluation and streams Threads and thread pools Atomicity and locking Synchronization and thread-safe objects Lock-free, non-blocking patterns Futures, promises, and functional-concurrent programming
As a bonus, the book includes a discussion of common typing strategies used in modern programming languages, including type inference, subtyping, polymorphism, type classes, type bounds, and type variance.
Most of the code examples are in Scala, which includes many of the standard features of functional and concurrent programming; however, no prior knowledge of Scala is assumed. You should be familiar with concepts such as classes, methods, objects, types, variables, loops, and conditionals and have enough programming experience to not be distracted by simple matters of syntax.
In Functional and Concurrent Programming , Michel Charpentier introduces a core set of programming language constructs that will help you be productive in a variety of programming languages--now and in the future. Charpentier illustrates key concepts with numerous small, focused code examples, written in Scala, and with case studies that provide a thorough grounding in functional and concurrent programming skills. These skills will carry from language to language--including the most recent incarnations of Java. Using these features will enable developers and programmers to write high-quality code that is easier to understand, debug, optimize, and evolve.
Key topics covered include: Recursion and tail recursion Pattern matching and algebraic datatypes Persistent structures and immutability Higher-order functions and lambda expressions Lazy evaluation and streams Threads and thread pools Atomicity and locking Synchronization and thread-safe objects Lock-free, non-blocking patterns Futures, promises, and functional-concurrent programming
As a bonus, the book includes a discussion of common typing strategies used in modern programming languages, including type inference, subtyping, polymorphism, type classes, type bounds, and type variance.
Most of the code examples are in Scala, which includes many of the standard features of functional and concurrent programming; however, no prior knowledge of Scala is assumed. You should be familiar with concepts such as classes, methods, objects, types, variables, loops, and conditionals and have enough programming experience to not be distracted by simple matters of syntax.
528 pages, Paperback
Published November 28, 2022
About the author
Michel Charpentier
1 book1 followerMichel Charpentier is an associate professor with the Computer Science department at the University of New Hampshire (UNH). His interests over the years have ranged from distributed systems to formal verification and mobile sensor networks. He has been with UNH since 1999 and currently teaches courses in programming languages, concur- rency, formal verification, and model-checking.
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 of 1 review
May 22, 2026
When this book came out (in late 2022, it seems), my marketing contact at Pearson asked me whether I would be interested in a copy in exchange for a review. I responded that I read books at my own pace, and according to my interests, and that I wouldn't promise anything, but that I always write a review if I finish a book. She sent me the book anyway.
I've been slowly going through it since then, mainly using it as backup reading material whenever I ran out of something else. Why has it taken so long, given that I rate it favourably?
A bit of context would help: I tentatively started functional programming in F# around 2010, and in Haskell around 2015. I don't need a book about functional programming (FP). I did, however, toy with a writing project related to FP, and was interested in 'scoping out the competition', as it were. Additionally, people sometimes ask me if I can recommend any books for people who wish to learn FP. So I've been mostly reading the book with an eye to how well it introduces concepts, as well as whether it would have any good points that I could use (with proper attribution, of course).
Given the reservation that I don't have a beginner's perspective, but only attempted to emulate such a mindset, it seems to me that the book does an admirable job of presenting FP in a clear and coherent manner. Topics are presented in an orderly sequence so as to not confuse you by something that only comes later.
The code examples are mostly in Scala, which is a language I've never used, and hardly even knew how to read. You should not let that scare you away. Michel Charpentier does not assume that you already know Scala. Syntax is introduced as you need it, and I had no problems following the code with the language tuition provided in the book. Granted, I've written professional og serious hobby code in nine languages, and toyed with another 12, so I may not be the most representative yardstick for the average reader.
As the title advertises, the book is both about FP and concurrent programming, and when I got to the second part, I initially wondered at the juxtaposition (even though I should have known better). The first many chapters about concurrent programming basically go over old ground related to threading, fork/join patterns, synchronisation, locking, deadlocks, etc. This perspective on concurrency was never enjoyable to me: Like imperative programming, it's too close to the metal to offer much abstraction. It ends up too finicky to my tastes, depending too much on details and circumstances.
It's not that I don't understand how deadlocks arise. My problem with lock-based concurrent programming is more that, as far as I can tell, there's no mental model, no abstraction, that enables you to avoid them.
Of course, once we reach task-based programming, it helps, and that's ultimately why the book is about both FP and concurrency. As anyone who has programmed with F#'s async and task abstractions will know, asynchrony is just another monad, and it all comes together beautifully.
Even so, I enjoyed part 2 less than part 1.
Ultimately, this seems like a more-than-decent introduction to FP, and a useful enough guide to concurrent programming leveraging FP constructs to make parallelism safer.
I've been slowly going through it since then, mainly using it as backup reading material whenever I ran out of something else. Why has it taken so long, given that I rate it favourably?
A bit of context would help: I tentatively started functional programming in F# around 2010, and in Haskell around 2015. I don't need a book about functional programming (FP). I did, however, toy with a writing project related to FP, and was interested in 'scoping out the competition', as it were. Additionally, people sometimes ask me if I can recommend any books for people who wish to learn FP. So I've been mostly reading the book with an eye to how well it introduces concepts, as well as whether it would have any good points that I could use (with proper attribution, of course).
Given the reservation that I don't have a beginner's perspective, but only attempted to emulate such a mindset, it seems to me that the book does an admirable job of presenting FP in a clear and coherent manner. Topics are presented in an orderly sequence so as to not confuse you by something that only comes later.
The code examples are mostly in Scala, which is a language I've never used, and hardly even knew how to read. You should not let that scare you away. Michel Charpentier does not assume that you already know Scala. Syntax is introduced as you need it, and I had no problems following the code with the language tuition provided in the book. Granted, I've written professional og serious hobby code in nine languages, and toyed with another 12, so I may not be the most representative yardstick for the average reader.
As the title advertises, the book is both about FP and concurrent programming, and when I got to the second part, I initially wondered at the juxtaposition (even though I should have known better). The first many chapters about concurrent programming basically go over old ground related to threading, fork/join patterns, synchronisation, locking, deadlocks, etc. This perspective on concurrency was never enjoyable to me: Like imperative programming, it's too close to the metal to offer much abstraction. It ends up too finicky to my tastes, depending too much on details and circumstances.
It's not that I don't understand how deadlocks arise. My problem with lock-based concurrent programming is more that, as far as I can tell, there's no mental model, no abstraction, that enables you to avoid them.
Of course, once we reach task-based programming, it helps, and that's ultimately why the book is about both FP and concurrency. As anyone who has programmed with F#'s async and task abstractions will know, asynchrony is just another monad, and it all comes together beautifully.
Even so, I enjoyed part 2 less than part 1.
Ultimately, this seems like a more-than-decent introduction to FP, and a useful enough guide to concurrent programming leveraging FP constructs to make parallelism safer.
Displaying 1 of 1 review