liveBook · Manning

Functional programming

Also called functional style, FP, functional paradigm

Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.

How 22 Manning books explain it

Functional Programming in JavaScript

A programming paradigm that builds software by composing and transforming functions, typically emphasizing pure functions and immutable data over mutable state and side effects.

How it is used
Reframes JavaScript application design around functions to control growing shared-state complexity.
How deep it goes
Defines the style, contrasts imperative rewrites, and introduces decomposition, chains, composition, and reactive events without fully developing each technique.
Examples
Uses Hello World DOM output, counters, student display and SSN validation, enrollment grades, and collection transformations.
What you can do after
Apply functional techniques in JavaScript by decomposing tasks, composing functions, and chaining data transformations.

Read how Functional Programming in JavaScript explains functional programming →

Grokking Simplicity

A programming paradigm that emphasizes composing computations as evaluations of functions while minimizing mutable state and side effects.

How it is used
Organizes software by separating time-sensitive actions from stable calculations and inert data.
How deep it goes
Explains definitions, tradeoffs, and classification of code, then stops short of language-specific implementation details.
Examples
Uses a task-management service, email notifications, and distinctions among task data, notification calculations, and sending actions.
What you can do after
Diagnose/debug bugs by identifying actions, then apply extraction of calculations to improve testing, reuse, and understanding.

Read how Grokking Simplicity explains functional programming →

The Joy of JavaScript

A programming paradigm that models computation as the evaluation of functions, often emphasizing immutability and function composition.

How it is used
Recasts application calculations as pure transformations instead of loops that update shared state.
How deep it goes
Defines purity and works through a wallet-balance refactoring, while leaving broader functional programming beyond this treatment.
Examples
Uses block validation with filter, map, and reduce, then refactors a wallet-balance calculation from nested loops into an array pipeline.
What you can do after
Practice/perform a refactoring that extracts a pure balance calculation while retaining a delegating Wallet method.

Read how The Joy of JavaScript explains functional programming →

Functional Design and Architecture: Examples in Haskell

A programming approach that represents computation primarily through the evaluation and composition of functions, favoring immutable data and minimized side effects.

How it is used
Uses functional design to control complexity and reason about correctness, parallelism, and application architecture.
How deep it goes
Explains purity, immutable bindings, composition, and effect separation with examples, while comparing functional and object-oriented design principles.
Examples
Illustrates pure maximum calculation with separate output, and maps string lengths over lists.
What you can do after
Evaluate design choices using purity, immutability, and explicit effect handling to reason about predictability and complexity.

Read how Functional Design and Architecture: Examples in Haskell explains functional programming →

Unit Testing Principles, Practices, and Patterns

Functional programming is a programming paradigm that expresses computation through mathematical functions and minimizes hidden inputs, hidden outputs, and mutable state.

How it is used
Supports output-based unit testing by making computation explicit and minimizing hidden behavior.
How deep it goes
Defines pure functions and functional architecture, but stops short of a deep functional-programming treatment.
Examples
Uses CalculateDiscount, Increment, and AddComment to contrast explicit computation with internal state and side effects.
What you can do after
Apply functional principles to separate business decisions from side effects and write more output-based tests.

Read how Unit Testing Principles, Practices, and Patterns explains functional programming →

The Art of Code

A programming style that combines function-oriented composition with declarations of desired results rather than procedural commands.

How it is used
Uses functional composition to make transformations visible and reduce risks from hidden state and side effects.
How deep it goes
Defines purity and referential transparency, then works through pipelines, absence handling, and readability and performance tradeoffs.
Examples
Compares word-filtering loops and streams, chains Optional price retrieval, and analyzes youngest and oldest people alongside sorted names.
What you can do after
Apply functional composition via Java streams and Optional while evaluating readability, side effects, and traversal costs.

Read how The Art of Code explains functional programming →

Functional Programming in C#, Second Edition

Functional programming is a programming paradigm that builds programs by composing functions and favors functions whose behavior depends only on their inputs.

How it is used
Introduces functional programming as a practical alternative to imperative state mutation in C# development.
How deep it goes
Explains first-class functions and mutation avoidance through sequence operations and concurrency contrasts, then extends the approach to immutable state snapshots.
Examples
Uses LINQ filtering, sorting, and mapping alongside concurrent array summation and sorting.
What you can do after
Apply it via LINQ to compose sequence transformations without mutating the input.

Read how Functional Programming in C#, Second Edition explains functional programming →

Functional Programming in Scala, Second Edition

Functional design is the practice of structuring software around pure functions, immutable data, composition, and explicit effects.

How it is used
Organizes programs around pure cores while isolating I/O, errors, and other effects at their boundaries.
How deep it goes
Defines purity and side effects, explains substitution and explicit state, then extends the approach through library and I/O design.
Examples
Uses coffee charges, random number generation, integer summation, property-based testing, parser libraries, and stream processing.
What you can do after
Apply it by separating effects from pure calculations, modeling state explicitly, and composing small reusable functions.

Read how Functional Programming in Scala, Second Edition explains functional programming →

Learn Haskell by Example

Functional programming is a programming paradigm that treats computation primarily as the evaluation of functions and the transformation of values.

How it is used
Frames Haskell development as composing immutable transformations for safe, reusable, and reliable software.
How deep it goes
Defines declarative, immutable, and pure programming; enumerates forbidden effects while deferring their control through monadic programming.
Examples
Uses contrasting chocolate-cake recipes and later beginner tools, including word-ladder AI and CSV formatting, to ground the approach.
What you can do after
Evaluate/understand programs as value transformations and recognize when mutable state or direct effects conflict with purity.

Read how Learn Haskell by Example explains functional programming →

Deep Learning with JAX

A programming style centered on functions as values and minimal reliance on mutable state.

How it is used
Structures JAX machine-learning programs for explicit state, pure functions, and composable transformations.
How deep it goes
Explains purity, explicit state, immutability, and indexed updates, while deferring random-number details and control-flow habits.
Examples
Uses explicit neural-network state, JAX random state, and .at[] replacements for NumPy-style in-place updates.
What you can do after
Apply via JAX functions that pass parameters and state explicitly and replace mutation with functional array updates.

Read how Deep Learning with JAX explains functional programming →

F# in Action: A Revised Edition of Get Programming with F#

Functional programming is a programming paradigm that emphasizes composing computations as functions and minimizing mutable state and side effects.

How it is used
Organizes application behavior around functions acting on immutable data, including domain models and HTTP requests.
How deep it goes
Explains the approach through a basket comparison and identifies expressions and immutability as priorities without requiring pure functions.
Examples
Contrasts a stateful shopping basket with an immutable record and stateless functions, then compares HTTP requests with function calls.
What you can do after
Practice/perform it by rewriting a familiar module in F#, favoring immutable values and expressions over mutable variables and statements.

Read how F# in Action: A Revised Edition of Get Programming with F# explains functional programming →

The Art of Unit Testing 3e

A programming paradigm that emphasizes function composition, expressions, and minimizing mutable state and side effects.

How it is used
Uses functional design to replace dependencies in unit tests through function parameters.
How deep it goes
Works through adapter injection and a stubbed test, but does not establish that the whole design is stateless.
Examples
Tests a website-checking function with a supplied network stub and contrasts it with a directly imported adapter.
What you can do after
Build it from scratch by passing a network adapter into a function and supplying a stub during tests.

Read how The Art of Unit Testing 3e explains functional programming →

C++ Concurrency in Action, Second Edition

Functional programming is a programming style that emphasizes computing results from inputs while avoiding mutable external state.

How it is used
Structures concurrent tasks around their inputs and future-delivered results instead of direct shared-data exchange.
How deep it goes
Defines pure functions and relates them to concurrency, then demonstrates future-based Quicksort without developing a broad functional-programming toolkit.
Examples
Uses mathematical functions, basic arithmetic, and sequential and future-based Quicksort examples.
What you can do after
Apply via C++ futures to pass task results between threads without explicit shared-data access.

Read how C++ Concurrency in Action, Second Edition explains functional programming →

The Well-Grounded Rubyist, Fourth Edition

A functional language is a programming language that emphasizes computation through functions and minimizes mutable state and side effects.

How it is used
Frames functional programming as a style for writing predictable code and weighing design trade-offs alongside object-oriented programming.
How deep it goes
Defines pure functions and referential transparency, then illustrates mutation, exceptions, currying, and lazy sequences without deep mathematical treatment.
Examples
Contrasts reassigning an incremented variable with creating a new one, and demonstrates curried functions and lazy infinite sequences.
What you can do after
Apply currying and lazy enumerators to create reusable functions that process finite portions of infinite sequences.

Read how The Well-Grounded Rubyist, Fourth Edition explains functional programming →

Kotlin in Action, 2E

Functional programming treats computation primarily as the evaluation and composition of functions, often emphasizing immutable data and limited side effects.

How it is used
Uses functions, immutable values, and collection operations to make Kotlin code concise, reusable, testable, and safer for concurrent development.
How deep it goes
Defines first-class functions, immutability, and pure functions, then demonstrates lambdas and collection operations without descending into implementation internals.
Examples
Uses a button listener lambda and a message pipeline applying filter, map, distinct, and sortedBy.
What you can do after
Apply it via Kotlin lambdas and standard collection functions to compose behavior and express data transformations.

Read how Kotlin in Action, 2E explains functional programming →

Python Workout: 50 ten-minute exercises

Functional programming is a programming paradigm that emphasizes composing functions, minimizing mutable state, and transforming inputs into outputs.

How it is used
Uses immutable data, short functions, and input-to-output transformations to make programs easier to test, debug, and maintain.
How deep it goes
Explains immutability, state avoidance, higher-order functions, map, filter, and comprehensions, but stops short of formal theory.
Examples
Demonstrates squared even numbers, word-length mapping, long-word filtering, and parallel letter-number multiplication.
What you can do after
Apply functional techniques through Python comprehensions, map, and filter to transform iterable data without direct mutation.

Read how Python Workout: 50 ten-minute exercises explains functional programming →

Go in Practice, Second Edition

Functional programming is a programming paradigm that emphasizes function composition, expressions, and controlled handling of state and side effects.

How it is used
Contrasts functional programming with Go’s intended state-passing concurrency and idiomatic style.
How deep it goes
Defines first-class functions and generic sequence operations, then stops at a pragmatic comparison rather than implementation guidance.
Examples
Uses generic sequence operations and Go’s pre-1.18 versus post-1.18 capabilities as contrastive examples.
What you can do after
Evaluate functional-style Go against idiomatic Go trade-offs.

Read how Go in Practice, Second Edition explains functional programming →

Julia as a Second Language

Functional programming is a programming paradigm that emphasizes expressions, function composition, and transformations of data with limited mutable state.

How it is used
Develops a functional mindset for Julia programming alongside object-oriented design.
How deep it goes
Defines core practices and explains a data-transformation pipeline, contrasting it with input mutation.
Examples
Uses a snake-case conversion pipeline and contrasting approaches to an encryption service.
What you can do after
Evaluate and understand functional and object-oriented approaches to the same programming problem.

Read how Julia as a Second Language explains functional programming →

Python Workout, Second Edition

Functional programming is a programming paradigm that emphasizes composing computations as functions and minimizing mutable state and side effects.

How it is used
Uses immutability, short functions, and function composition to make programs more reliable and maintainable.
How deep it goes
Explains the rationale for immutability and statelessness, then illustrates transformations with generator expressions and aggregation.
Examples
Uses an immutable Person replacement and Zoo queries that filter animals and sum their legs.
What you can do after
Apply functional techniques to write shorter functions with fewer state-dependent paths and easier testing.

Read how Python Workout, Second Edition explains functional programming →

Acing the Frontend Interview

Functional programming is a programming paradigm that emphasizes pure functions, immutable data, function composition, and minimized side effects.

How it is used
Positions functional programming as an interview-ready approach for writing clean, predictable, modular JavaScript.
How deep it goes
Defines pure functions and immutability, practices array transformations, and extends toward currying, pipelines, performance, and architecture.
Examples
Uses counter mutation, addition, map transformations, currying, logging wrappers, and functional data-processing pipelines.
What you can do after
Apply pure functions and array methods, refactor imperative code, and articulate functional trade-offs during technical interviews.

Read how Acing the Frontend Interview explains functional programming →

Microservices Patterns, Second Edition

Functional-style programming is a programming approach that emphasizes functions with limited side effects and minimizes dependencies on mutable state.

How it is used
Supports design for testability by making business logic easier to validate with automated tests.
How deep it goes
Connects dependency-free business logic to fast unit tests, without detailing implementation mechanics.
Examples
Uses business logic without dependencies and a mock DAO as examples of targets for fast unit tests.
What you can do after
Apply the style by isolating business logic from dependencies for fast in-memory unit testing.

Read how Microservices Patterns, Second Edition explains functional programming →

Idiomatic Rust

Functional programming is a programming paradigm that emphasizes composing computations as functions and minimizing mutable state and side effects.

How it is used
Frames functional programming as a way to compose declarative functions while minimizing mutation and side effects in Rust.
How deep it goes
Defines the paradigm and surveys Rust’s high-level support through closures and iterators, while deferring a deeper treatment.
Examples
Uses I/O and local mutation as examples of side effects, and cites JavaScript and TypeScript as common users of closures.
What you can do after
Understand how immutability and pure functions support reasoning, testing, reuse, and deterministic behavior.

Read how Idiomatic Rust explains functional programming →

Also covered in

What to know first

Related concepts

Questions about functional programming

What is functional programming?

Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.

Which Manning books explain functional programming?

Functional Programming in JavaScript, Grokking Simplicity, The Joy of JavaScript, Functional Design and Architecture: Examples in Haskell, Unit Testing Principles, Practices, and Patterns, The Art of Code, Functional Programming in C#, Second Edition, Functional Programming in Scala, Second Edition and 14 more.

What should I know before learning functional programming?

Manning books that teach functional programming usually introduce function, object-oriented programming, loop and state first.

What is the difference between functional programming and imperative programming?

Functional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects. Imperative programming is a programming paradigm that expresses computation as ordered commands or instructions that direct execution or change state.

What is functional programming also called?

Functional programming is also called functional style, FP or functional paradigm.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.