liveBook · Manning

Reference

A reference is an indirect value, binding, or relationship that identifies or provides access to another object, value, resource, or source.

How 18 Manning books explain it

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 access values without transferring ownership, including during iteration and function calls.
How deep it goes
Explains reference and dereference syntax, mutable borrowing, and memory addresses, then contrasts references with raw pointers.
Examples
Uses an integer addition, collection iteration, and a satellite mailbox to demonstrate references.
What you can do after
Apply references in Rust loops and functions to read or modify values while retaining ownership.

Read how Rust in Action: Systems programming concepts and techniques explains reference →

100 C++ Mistakes and How to Avoid Them

A pointer is a C++ value or object that refers to another object or function through an address and can represent no object with a null value.

How it is used
Uses pointers and references to access objects while addressing ownership, copying, lifetime, and polymorphism.
How deep it goes
Explains ownership and lifetime failures through examples and corrections, including double deletion and returns referring to local objects.
Examples
Demonstrates a double-deleted Buffer, a concatenation function returning a local reference, and a reference-returning assignment operator.
What you can do after
Diagnose/debug dangling returns and duplicate deletion, and apply reference returns and unique_ptr ownership in C++ code.

Read how 100 C++ Mistakes and How to Avoid Them 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 borrowing to reuse values without transferring ownership and raw pointers to exchange data across a C interface.
How deep it goes
Explains borrowing rules, lifetime inference and annotations, then contrasts reference validity with unsafe raw-pointer dereferencing.
Examples
Uses repeated artwork access, a vector element returned by reference, and a C calculator with pointer arguments.
What you can do after
Diagnose/debug borrowing and lifetime errors, and apply pointer checks when working with a C interface.

Read how Refactoring to Rust explains reference →

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.

Read how API Design Patterns explains reference →

Modern C

An object pointer is a pointer whose referenced entity is an object rather than a function.

How it is used
Uses object pointers to access and modify objects across function boundaries and navigate arrays and structures.
How deep it goes
Explains pointer operations, validity, array access, aliasing, and generic conversions, while treating platform pointer representation as opaque.
Examples
Demonstrates swapping two doubles, summing array elements, and accessing structure members through pointers.
What you can do after
Apply object pointers in C to modify caller-owned objects, traverse arrays, and recognize invalid dereferences.

Read how Modern C explains reference →

Modern C, Third Edition

A pointer type is a C type whose values designate objects or functions in storage.

How it is used
Uses pointers to access caller-owned objects and dynamically structured data across code boundaries.
How deep it goes
Develops pointer operations and validity from opaque representations through array parameters, object types, and conversions.
Examples
Illustrates swapping doubles, summing an array, testing a null pointer, and accessing a one-past pointer.
What you can do after
Apply pointers to access and modify objects, traverse arrays, and check bounds and type constraints.

Read how Modern C, Third Edition explains reference →

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 borrow data for functions without transferring ownership.
How deep it goes
Explains reference creation, dereferencing, access rules, and invalid local returns using code and compiler feedback.
Examples
Demonstrates repeated function calls with a borrowed String and mutation through a numeric reference.
What you can do after
Apply references in Rust functions, choose mutable or immutable access, and recognize invalid returns of local references.

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 represent absence, share values, and avoid copying synchronization primitives.
How deep it goes
Traces pointer sharing, range-variable addresses, and slice retention through observed failures and alternative fixes.
Examples
Uses customer pointers stored in a map and a counter whose value receiver copies a mutex.
What you can do after
Diagnose/debug incorrect sharing and retention, and choose pointer-based fixes for configuration, synchronization, and nullable queries.

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.

Read how Go by Example explains reference →

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.

Read how Grokking Data Structures explains reference →

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.

Read how Idiomatic Rust explains reference →

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

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.