Ownership
Ownership is a programming-language model that assigns responsibility for controlling a value or resource, including its lifetime and eventual cleanup.
Learn Rust in a Month of Lunches
Ownership is Rust's rule-based model in which each value has a responsible binding that controls the value's lifetime and access.
- How it is used
- Guides decisions about passing, borrowing, and changing values in Rust functions.
- How deep it goes
- Works through moves, borrowing fixes, Copy types, and compiler errors for moved values and invalid returned references.
- Examples
- Contrasts a String moved into repeated function calls with borrowed Strings, copied integers, and a rejected reference to a local String.
- What you can do after
- Diagnose/debug with it when a function call moves a String or a returned reference points to a local value.
Read how Learn Rust in a Month of Lunches explains ownership →
Refactoring to Rust
The association in which a designated handle controls when a piece of memory is allocated and deallocated.
- How it is used
- Uses ownership to make memory responsibilities explicit during incremental Rust refactoring, including across FFI boundaries.
- How deep it goes
- Defines the one-owner rules and works through a function-argument move and rejected reuse, without detailing ownership implementation.
- Examples
- Demonstrates an artwork passed twice to a function and greeting code whose free(name) call changes deallocation responsibility.
- What you can do after
- Diagnose/debug with it by recognizing a moved-value error and identifying why a former owner cannot reuse the value.
Rust in Action: Systems programming concepts and techniques
An owner is the binding or program entity responsible for cleaning up a value when its lifetime ends.
- How it is used
- Uses ownership to explain cleanup, compiler move errors, and design choices when functions need shared access to values.
- How deep it goes
- Explains moves across assignments and function calls, destructor cleanup, and practical remedies without developing unsafe allocation details.
- Examples
- Traces repeated satellite status checks that fail after a move, then succeed when the function returns the satellite.
- What you can do after
- Diagnose/debug with it by locating moves behind use-after-move errors and choosing references, duplication, or shorter-lived values.
Read how Rust in Action: Systems programming concepts and techniques explains ownership →
Rust Servers, Services, and Apps
An ownership model assigns each value a responsible owner and determines when that value may be accessed or destroyed.
- How it is used
- Frames Rust resource management around explicit ownership, borrowing, and compile-time memory safety.
- How deep it goes
- Explains ownership transfer, scope-based destruction, reference types, and borrow-checking constraints, without implementation internals.
- Examples
- Uses ownership transfer, scope exit, immutable references, and mutable references as concrete rule examples.
- What you can do after
- Apply Rust ownership and borrowing rules while understanding the compiler guarantees against invalid memory access.
Read how Rust Servers, Services, and Apps explains ownership →
Digital Twins in Action
Ownership is the assignment of responsibility and authority for the operation, maintenance, and outcomes of a system or capability.
- How it is used
- Assigns accountability for the components and data decisions needed to operate a production digital twin.
- How deep it goes
- Names components requiring owners and explains conflict-resolution authority, but does not prescribe an assignment workflow.
- Examples
- Contrasts one person owning home data sources with contractors, vendors, and teams reporting conflicting industrial asset states.
- What you can do after
- Practice assigning component owners and evaluate whether responsibilities are clear enough for production decisions.
Introduction to Generative AI, Second Edition
Ownership is the legally recognized control or entitlement associated with property or rights in a creative work.
- How it is used
- Frames ownership as a central governance question for generative media and the creative economy.
- How deep it goes
- Connects ownership to copyright, authorship, consent, compensation, attribution, and creative control without resolving their legal boundaries.
- Examples
- Uses prompt-generated songs from Suno and Udio alongside concerns about unauthorized artist work.
- What you can do after
- Evaluate ownership disputes by separating control, benefits, attribution, authorization, and consent.
Read how Introduction to Generative AI, Second Edition explains ownership →
Related concepts
- moveused by · Move semantics describe the transfer of a value or its resources to another binding or object rather than duplicating them.
- data meshpart of · A data mesh is a decentralized data architecture and operating model in which domain teams provide data as products through shared self-service infrastructure and federated governance.
- Rustpart of · Rust is a statically typed systems programming language designed for performance, concurrency, and memory safety without requiring garbage collection.
- borrow checkeruses · A borrow checker is a compile-time mechanism that verifies ownership, borrowing, and reference rules to prevent invalid memory access.
- pipelineconfigures · A pipeline is an ordered or coordinated sequence of connected processing stages or tasks that passes data, work, or results toward an outcome.
- language modelconfigures · A language model is a computational model that represents patterns in linguistic tokens to estimate sequence probabilities and predict or generate language from context.
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.