Functional, stateless philosophy
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.
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, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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
- Frames design choices that reduce complexity while improving reasoning about correctness, parallelism, and maintainability.
- How deep it goes
- Explains immutability, pure functions, effects, determinism, domain invariants, and functional interfaces through code examples.
- Examples
- Uses mapped name lists, nested Maybe values, pure calc and max functions, I/O routines, and FizzBuzz complexity contrasts.
- What you can do after
- Evaluate/understand when immutable, pure composition makes code more predictable, testable, and suitable for concurrent work.
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.
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 declarative transformations and pure functions to make data-flow intent visible and reduce hidden-state risks.
- How deep it goes
- Defines purity and referential transparency, then develops Java pipelines, laziness, and readability limits without treating functional style as universal.
- Examples
- Compares loops with stream pipelines, maps Optional values to a product price, and analyzes people under performance and memory constraints.
- What you can do after
- Apply it via Java streams, lambdas, Optional, and collectors to express clear transformations while judging when imperative code is clearer.
Read how The Art of Code explains functional, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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
- Frames F# application design around immutable data and stateless functions while retaining OO features for interop.
- How deep it goes
- Explains expressions, immutability, and data-behavior separation, while deferring pure functions, type classes, and higher-kinded types.
- Examples
- Uses an immutable retail basket, C# class consumption, HTTP request-response mapping, and a rewritten application slice.
- What you can do after
- Apply it by redesigning familiar modules around immutable values and expressions rather than mutable state and statements.
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 as one JavaScript approach for expressing unit-testing patterns.
- How deep it goes
- Contrasts functional and object-oriented choices, explaining benefits and learning costs without developing implementation internals.
- Examples
- Uses function-level dependency injection and mock injection as practical functional-design examples.
- What you can do after
- Apply functional or object-oriented designs selectively when breaking dependencies and injecting stubs or mocks.
Read how The Art of Unit Testing 3e explains functional, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
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
- Uses functional design to organize Julia programs around data transformations rather than state-changing object interactions.
- How deep it goes
- Defines functional programming pragmatically through concrete practices and data flow, without imposing a single strict definition.
- Examples
- Illustrates transformation with a snake-case-to-camel-case function and compares functional and object-oriented designs for an encryption service.
- What you can do after
- Evaluate/understand functional and object-oriented approaches to the same Julia problem, including when a functional approach may not fit.
Read how Julia as a Second Language explains functional, stateless philosophy →
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, stateless philosophy →
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, stateless philosophy →
Related concepts
- Erlangincludes · Erlang is a concurrent functional programming language designed for scalable, distributed, fault-tolerant, and highly available systems.
- Elixirincludes · Elixir is a functional, concurrent programming language that runs on the Erlang BEAM virtual machine and supports distributed, fault-tolerant software.
- hexagonal architecturekind of · Hexagonal architecture is a software architecture pattern that isolates an application’s core logic from external systems through ports and adapters.
- mathematical functionuses · A mathematical function is a mapping that assigns exactly one output to each permitted input in its domain.
- immutable collectionuses · An immutable collection is a collection whose membership and contents cannot be changed after creation.
- imperative programmingcontrasts with · Imperative programming is a programming paradigm that expresses computation as an ordered sequence of instructions specifying operations, control flow, or changes to state.
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.