Reference
A reference is an indirect value or relationship that identifies or provides access to another value, object, resource, or source.
Rust in Action: Systems programming concepts and techniques
A reference is a non-owning value that provides access to another value without transferring its ownership.
- How it is used
- Uses references to retain access to collections and values while loops or functions borrow them instead of taking ownership.
- How deep it goes
- Explains borrowing through loop syntax, function signatures, dereferencing, and memory addresses, then contrasts references with raw pointers.
- Examples
- Demonstrates array searching with dereferenced items and a satellite mailbox updated through a mutable reference.
- What you can do after
- Apply references in Rust loops and function arguments to read or change values without unnecessarily moving ownership.
Read how Rust in Action: Systems programming concepts and techniques explains reference →
Refactoring to Rust
A pointer is a value representing a memory address that can be used to access data indirectly.
- How it is used
- Uses borrowed references to access values without transferring ownership and raw pointers to exchange data across a C interface.
- How deep it goes
- Explains borrowing rules, invalid lifetimes, raw-pointer dereferencing, and lifetime annotations, while leaving raw-pointer validity checks to the programmer.
- Examples
- Uses repeated artwork borrows, a returned vector-element reference, and a C calculator’s output pointer.
- What you can do after
- Apply it via Rust borrowing and C FFI to reuse values, identify dangling references, and check pointers before dereferencing.
API Design Patterns
A reference is a pointer stored in a resource that identifies official data held elsewhere.
- How it is used
- Defines how API resources point to one another while balancing freshness, request cost, integrity, and compatibility.
- How deep it goes
- Explains field naming, dynamic targets, deletion behavior, cached values, and trade-offs, but stops short of prescribing one universal relationship policy.
- Examples
- Uses Message-User authorship, ChatRoom administration, Book-Author links, ChangeLogEntry dynamic targets, and deleted authors as examples.
- What you can do after
- Designs reference fields, compares references with in-line data, and diagnoses invalid or stale pointers.
Modern C
An object pointer is a pointer whose referenced entity is an object rather than a function.
- How it is used
- Enables functions to access and change caller-owned objects through object-pointer arguments.
- How deep it goes
- Works through address-of, dereference, validity, array access, structure members, aliasing, and `void*` conversions without specifying pointer bit representations.
- Examples
- Uses a two-object swap, array summation, structure-member access, and two pointers that may designate one object.
- What you can do after
- Build it from scratch: write pointer-taking C functions and check validity, referenced type, and array bounds before access.
Modern C, Third Edition
A pointer type is a C type whose values designate objects or functions in storage.
- How it is used
- Enables access to caller-owned objects, array elements, and dynamically structured data through pointer values.
- How deep it goes
- Develops declarations, validity, arithmetic, array-parameter rewriting, and type constraints while leaving pointer representation platform-dependent.
- Examples
- Uses a swap function, array-summing loops, one-past-array access, and multidimensional matrix parameters.
- What you can do after
- Apply pointer-based interfaces to modify objects and traverse arrays; diagnose null, out-of-bounds, and type-mismatched access.
Learn Rust in a Month of Lunches
Referencing is the operation of creating a Rust reference with the & operator.
- How it is used
- Uses references to let functions read or change data without taking ownership of it.
- How deep it goes
- Explains creation, borrowing rules, dereferencing, and invalid returned references through code and compiler errors.
- Examples
- Shows repeated function calls with `&String`, mutation through `&mut`, and a compiler error for returning a local reference.
- What you can do after
- Practice/perform borrowing with `&` and `&mut`, and recognize when a returned reference cannot remain valid.
Read how Learn Rust in a Month of Lunches explains reference →
100 Go Mistakes and How to Avoid Them
A pointer is a Go value that holds the memory address of another value or represents the absence of such an address.
- How it is used
- Uses pointers to distinguish omitted configuration from zero and to preserve a shared synchronization instance.
- How deep it goes
- Works through observable pointer mistakes and contextual fixes rather than pointer arithmetic or memory layout.
- Examples
- Shows map entries all referencing one customer and a copied mutex producing a data race.
- What you can do after
- Diagnose/debug with it: choose the intended slice element address and prevent mutex copies across calls.
Read how 100 Go Mistakes and How to Avoid Them explains reference →
Get Programming: Learn to code with Python
- How it is used
- Uses start and end positions to split a multiline word string before checking which words can be made with letter tiles.
- How deep it goes
- Works through initialization, newline detection, word slicing, and pointer resets in a string-scanning loop.
- Examples
- Uses a multiline list of art words and traces pointer movement across newline characters.
- What you can do after
- Build a loop that separates newline-delimited words using start and end indices.
Read how Get Programming: Learn to code with Python explains reference →
The Well-Grounded Rubyist, Fourth Edition
An object reference is a value that identifies a Ruby object rather than containing an independent copy of that object.
- How it is used
- Explains why assignment, in-place string changes, and method calls can affect what another variable observes.
- How deep it goes
- Works through reference copying, reassignment, and argument behavior, while noting immediate-value exceptions without detailing their implementation.
- Examples
- Contrasts `replace` with reassignment, then tests a method argument and a mutable string inside a frozen array.
- What you can do after
- Diagnose/debug with it when a mutation unexpectedly appears through another variable, and use `dup` or `freeze` to limit changes.
Read how The Well-Grounded Rubyist, Fourth Edition explains reference →
Troubleshooting Java, Second Edition
An object reference is a value that identifies an object and can keep that object reachable for memory-management purposes.
- How it is used
- Tracks why objects remain reachable during memory-leak and abnormal-resource investigations.
- How deep it goes
- Defines retention by references, then traces referrers and storage locations in heap dumps; it stops short of prescribing the code fix.
- Examples
- Uses Product instances retained through an ArrayList stored in a static Main variable.
- What you can do after
- Diagnose retained objects with VisualVM by locating referrers and the code-held reference.
Read how Troubleshooting Java, Second Edition explains reference →
Go by Example
A pointer is a Go value that contains the memory address of another value and permits indirect access to it.
- How it is used
- Uses pointers to let flag parsers mutate shared configuration and to let errors.As store matched error values.
- How deep it goes
- Explains pointer sharing, captured field pointers, value-copy trade-offs, and the pointer-to-pointer requirement of errors.As.
- Examples
- Demonstrates a CLI config parser, copied concurrent Result values, and SQLite primary-key error detection.
- What you can do after
- Apply it via Go pointers to update caller-owned fields and use errors.As correctly with pointer-typed errors.
Object-Oriented Software Design in C++
A C++ reference is an alias bound to an existing object or function and used to access it without storing a separate object value.
- How it is used
- Uses references to access existing objects while discussing C++ value semantics and vector-related performance surprises.
- How deep it goes
- Defines references briefly and demonstrates a const reference parameter, but does not develop reference internals or a broader usage guide.
- Examples
- Demonstrates const Appointments& in a tester and contrasts Date values with pointers in appointment storage.
- What you can do after
- Evaluate when accessing an existing object through a reference can avoid value-oriented copying in a vector example.
Read how Object-Oriented Software Design in C++ explains reference →
Grokking Data Structures
A reference is a language-level value that identifies or provides access to an object or memory location.
- How it is used
- Uses references to connect noncontiguous linked-list nodes and support traversal, insertion, and deletion.
- How deep it goes
- Defines links through singly and doubly linked lists, then works through pointer updates and deletion edge cases.
- Examples
- Demonstrates references through array indexing, linked-list traversal, pointer-based insertion, and predecessor-aware deletion.
- What you can do after
- Evaluate/understand how references affect linked-list reachability, memory use, traversal cost, and structural updates.
Idiomatic Rust
A raw pointer is a pointer value that can be manipulated and dereferenced without Rust's ordinary ownership and borrowing guarantees.
- How it is used
- Provides temporary access to caller-owned values, including mutation without ownership transfer.
- How deep it goes
- Explains borrowing syntax and lifetime validity through function and struct examples, without developing raw-pointer operations.
- Examples
- Demonstrates `reverse(&str)`, `reverse_inplace(&mut String)`, and a struct field typed `&'a str`.
- What you can do after
- Apply it via Rust borrowing syntax to choose read-only access, mutation, or ownership transfer for function arguments.
Learn Go with Pocket-Sized Projects
A pointer is a Go value that represents the memory address of another value.
- How it is used
- Connects command-line flag parsing and HTTP client design to passing addresses and controlling shared state.
- How deep it goes
- Defines addresses, &, *, copy semantics, and absent pointer arithmetic, then applies them to flags, clients, and timeout errors.
- Examples
- Uses flag.StringVar, http.DefaultClient, private HTTP clients, and *url.Error timeout checks.
- What you can do after
- Apply pointers via flag.StringVar and diagnose pointer-bearing timeout errors with errors.As.
Read how Learn Go with Pocket-Sized Projects explains reference →
The Quick Python Book, Fourth Edition
An object reference is a binding or pointer-like association through which a name identifies a runtime object.
- How it is used
- Explains Python assignment, aliasing, mutation, and argument behavior through references to runtime objects.
- How deep it goes
- Works through mutable and immutable assignment and function-parameter effects, but does not descend into interpreter implementation.
- Examples
- Uses aliased lists, reassigned integers, and a function that mutates one list while reassigning another parameter.
- What you can do after
- Diagnose whether assignment or mutation will affect other names and function callers.
Read how The Quick Python Book, Fourth Edition explains reference →
MongoDB 8.0 in Action, Third Edition
A data pointer is an index component that identifies the location of corresponding data within a database.
- How it is used
- Guides MongoDB schema choices between embedding related data and linking documents across collections.
- How deep it goes
- Explains relationship types and trade-offs, but stops short of command-level reference implementation.
- Examples
- Uses airline routes, airports, embedded flight data, movie runtime searches, and MongoDB’s immutable _id index.
- What you can do after
- Evaluate whether to embed related data or use references, and understand how indexed pointers support efficient retrieval.
Read how MongoDB 8.0 in Action, Third Edition explains reference →
Related concepts
- arraycontrasts with · An array is an indexed, ordered collection of elements arranged in one or more dimensions, with elements accessed by position.
- borrowingproduced by · Borrowing is Rust’s mechanism for accessing a value through a reference without transferring ownership, subject to rules governing reference validity and aliasing.
- array parameterequivalent to · An array parameter is a C function parameter declared with array syntax that is adjusted to a pointer to its element type.
- reborrowingproduced by · Reborrowing is the conversion of a raw pointer into a Rust reference after the pointer's validity conditions have been established.
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.