liveBook · Manning

Mutable object

A mutable object is an object whose state can be changed after it is created.

How 6 Manning books explain it

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

Mutability is the property of data whose state can be changed after creation.

How it is used
Contrasts in-place state changes with returning updated data when modeling application behavior.
How deep it goes
Explains object updates and hidden side effects, then works through mutable and immutable gas-tank state; does not detail object internals.
Examples
Uses a gas-tank simulation, hard-to-reproduce bugs, and locally scoped StringBuilder updates.
What you can do after
Evaluate/understand when changing shared state obscures behavior and when returned values or tightly scoped mutation make code easier to test.

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

The Art of Code

Mutability is the property of a value or data structure whose contents can change after creation.

How it is used
Uses mutable data to illustrate hidden side effects in data modeling and imperative programming.
How deep it goes
Defines mutability and traces a shared-reference bug through copying and non-destructive filtering alternatives.
Examples
Uses country-coded product counts and an imperative word-filtering loop to demonstrate mutation.
What you can do after
Diagnose unintended list changes caused by shared references and replace destructive filtering with a non-destructive count.

Read how The Art of Code explains mutable object →

Refactoring to Rust

Mutability is the property of a value or data structure that permits its contents to be changed after creation.

How it is used
Uses explicit mutability to control reassignment, in-place updates, and growing string buffers.
How deep it goes
Explains annotations, mutable references, scope-based reference dropping, String capacity, and reallocation without covering concurrent Rust details.
Examples
Uses integer variables, an artwork view counter, repeated string appends, and preallocated string capacity.
What you can do after
Apply it by declaring mutable Rust variables, passing mutable references, and choosing string capacity for repeated appends.

Read how Refactoring to Rust explains mutable object →

Julia as a Second Language

A mutable type is a Julia type whose instances can have their fields modified after creation.

How it is used
Uses mutable objects to represent changing simulation state and support linked collection operations.
How deep it goes
Explains mutable declarations, field assignments, mutation naming conventions, REPL-friendly returns, and the need to restart after changing a type definition.
Examples
Demonstrates archers spending arrows and rocket stages being added to or removed from a vehicle.
What you can do after
Apply it in Julia to implement state-changing methods and linked-stage collection operations.

Read how Julia as a Second Language explains mutable object →

Data-Oriented Programming in Java

Mutability is the property of a value or object whose state can change after it is created.

How it is used
Clarifies why value objects need immutable constituents and why mutable boundaries require deliberate containment.
How deep it goes
Descends from value semantics to nested references, collection behavior, constructor sanitization, and pragmatic wrapper boundaries.
Examples
Uses mutable Date fields, HashSet membership, compact-constructor normalization, and a PastDue wrapper around Invoice.
What you can do after
Diagnose/debug with it: identify hidden mutation that undermines equality, hashing, value semantics, or record-based domain models.

Read how Data-Oriented Programming in Java explains mutable object →

Fabulous Adventures in Data Structures and Algorithms

A mutable data structure is a data structure whose contents can be changed after it is created.

How it is used
Uses mutation for convenient construction and direct updates when preserving multiple historical states is unnecessary.
How deep it goes
Defines mutation, contrasts copying costs, and demonstrates encapsulated C# trie-node operations without developing a general mutation theory.
Examples
Uses integer arrays, mutable trie nodes, and command-based undo-redo state as concrete examples.
What you can do after
Evaluate when direct mutation is simpler than version sharing, and build encapsulated mutable trie nodes in C#.

Read how Fabulous Adventures in Data Structures and Algorithms explains mutable object →

Also covered in

What to know first

Related concepts

Questions about mutable object

What is mutable object?

A mutable object is an object whose state can be changed after it is created.

Which Manning books explain mutable object?

F# in Action: A Revised Edition of Get Programming with F#, The Art of Code, Refactoring to Rust, Julia as a Second Language, Data-Oriented Programming in Java and Fabulous Adventures in Data Structures and Algorithms.

What should I know before learning mutable object?

Manning books that teach mutable object usually introduce side effect, attribute, final and constructor method first.

What is the difference between mutable object and immutable collection?

A mutable object is an object whose state can be changed after it is created. An immutable collection is a collection whose contents cannot be changed after it is created.

What kinds of mutable object are there?

Kinds of mutable object include HttpContext, Map and StringBuilder.

What is mutable object a kind of?

Mutable object is a kind of object. An object is a runtime entity that combines state with operations that act on that 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.