Map
A map is an associative data structure that stores key-value pairs and supports retrieving values by key.
Python Workout, Second Edition
A dictionary is a mutable mapping in Python that associates hashable keys with values and preserves insertion order in modern implementations.
- How it is used
- Uses dictionaries for records, name–value associations, accumulation, dispatch tables, and transforming data from files or JSON.
- How deep it goes
- Explains hashing, key constraints, lookup strategy, idioms, edge cases, nested structures, comprehensions, and dictionary-based design exercises.
- Examples
- Practices menus, rainfall totals, dictionary differences, dispatch tables, flipped dictionaries, file statistics, configuration data, and JSON records.
- What you can do after
- Build it from scratch by choosing keys, retrieving values, accumulating data, comparing dictionaries, and composing dictionary-based solutions.
A Pythonic Adventure: From Python basics to a working web app
A Python dictionary is a mutable mapping that associates unique keys with values for lookup and assignment.
- How it is used
- Collects customer order details so menus, confirmation, saving, and printing can pass one order value around.
- How deep it goes
- Defines key-value storage and demonstrates empty creation, assignment, return, form collection, and template lookup without discussing dictionary internals.
- Examples
- Uses a coffee order with name, drink, flavor, and topping, plus submitted web-form values rendered on a page.
- What you can do after
- Build it from scratch as an order dictionary, populate it from input or a form, return it, and retrieve values by key.
Read how A Pythonic Adventure: From Python basics to a working web app explains Map →
Learn Go with Pocket-Sized Projects
An associative array is a collection that associates keys with values rather than using only positional indexes.
- How it is used
- Replaces growing conditionals with lookups and supports counting, named tests, membership checks, and cache storage.
- How deep it goes
- Works through literals, initialization, reads, writes, missing keys, comparable keys, iteration, and a map-backed cache; does not develop hash-table internals.
- Examples
- Uses a multilingual phrasebook, bookshelf occurrence counts, named JSON-loading test cases, and a generic cache.
- What you can do after
- Build it from scratch: create maps for lookup, counting, or membership, and check key presence when absence matters.
Grokking Algorithms, Second Edition
A dictionary is a Python mapping data structure that associates keys with corresponding values.
- How it is used
- Maps keys to values for quick lookups, duplicate checks, caching, and graph representations.
- How deep it goes
- Explains dictionary operations and hash-table mechanics through collisions, performance, load factor, and resizing, without requiring a from-scratch implementation.
- Examples
- Uses produce prices, a phone book, voter records, cached pages, and graph nodes as key-value examples.
- What you can do after
- Apply it via Python dictionaries to store and retrieve values, test membership, and model relationships.
Python Workout: 50 ten-minute exercises
A dict is Python's mutable mapping type that associates hashable keys with values.
- How it is used
- Uses dictionaries as lookup tables, small databases, grouped records, accumulators, and function-facing data containers.
- How deep it goes
- Explains creation, lookup, membership, iteration, accumulation, comparison, parsing, and hashing, but does not detail dictionary implementation internals.
- Examples
- Demonstrates menus, rainfall totals, log grouping, file counts, password records, dictionary differences, reversals, and keyword-generated XML.
- What you can do after
- Apply it via Python syntax to build lookups, accumulate data, compare mappings, parse records, and transform collections.
Read how Python Workout: 50 ten-minute exercises explains Map →
Python How-To
- How it is used
- Uses dictionaries to retrieve values by key and organize task, function, and CSV data.
- How deep it goes
- Explains construction, lookup choices, hashable keys, and O(1) retrieval without detailing hash-table implementation.
- Examples
- Uses task urgencies, zipped task IDs and titles, function dispatch, and header-based CSV rows.
- What you can do after
- Build it from scratch with literals, zip, or comprehensions, then apply it to keyed lookup and labeled records.
The Well-Grounded Rubyist, Fourth Edition
A key-value data structure that associates keys with corresponding values and preserves the insertion order of its keys.
- How it is used
- Uses key/value lookup to associate data such as state names with abbreviations and to package related method arguments.
- How deep it goes
- Works through creation, lookup, defaults, insertion order, and transformations without descending into hash implementation internals.
- Examples
- Demonstrates state-abbreviation lookup, missing-key defaults, filtering pairs, and passing city data as a final hash argument.
- What you can do after
- Build it from scratch with Ruby hash literals or constructors, then retrieve, update, and transform key/value pairs.
Read how The Well-Grounded Rubyist, Fourth Edition explains Map →
The Quick Python Book, Fourth Edition
- How it is used
- Uses dictionaries for keyed access, word counts, sparse matrices, and caches.
- How deep it goes
- Explains creation, lookup, operations, hashable keys, views, and insertion order; identifies hash tables without detailing their internals.
- Examples
- Works through word counting, a word-translation lookup, tuple-keyed sparse matrices, and cached function results.
- What you can do after
- Build it from scratch using `dict` literals, keyed assignment, membership tests, and fallback lookups for small keyed-data tasks.
Read how The Quick Python Book, Fourth Edition explains Map →
100 Go Mistakes and How to Avoid Them
A map is a Go data structure that associates keys with values and requires keys to satisfy comparability rules.
- How it is used
- Diagnoses performance, retained memory, iteration-order assumptions, and unsafe concurrent access in Go maps.
- How deep it goes
- Explains hash buckets, growth, and non-shrinkage through mechanisms and measurements rather than stopping at map syntax.
- Examples
- Uses million-entry heap measurements and a balance-cache race to expose retained buckets and shallow assignments.
- What you can do after
- Apply it via `make` and `sync.RWMutex` to pre-size maps and protect shared iteration.
Read how 100 Go Mistakes and How to Avoid Them explains Map →
Grokking Data Structures
A dictionary is an associative data structure that maps keys to values and supports operations such as lookup, insertion, and deletion by key.
- How it is used
- Uses key-based lookup to find stored values, track card collections, count occurrences, and remove duplicates.
- How deep it goes
- Defines insertion, retrieval, and deletion, then compares implementation costs and explains hash-table tradeoffs.
- Examples
- Uses baseball-card lookup, duplicate removal, Python occurrence counting, and a table of implementation costs.
- What you can do after
- Evaluate/understand map implementations by comparing the costs of key-based insertion, search, and deletion.
Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond
- How it is used
- Stores and retrieves keyed data when keys may be objects or when ordered key–value iteration matters.
- How deep it goes
- Works through construction, methods, iteration, destructuring, selection tradeoffs, and exercises; does not detail the internal storage mechanism.
- Examples
- Uses search-facet rendering, object-keyed card state, and sorting and inversion exercises.
- What you can do after
- Apply it via JavaScript Map to iterate keyed data, retrieve values, and track state by object reference.
Tiny Python Projects: Learn coding and testing with puzzles and games
An empty dictionary is a dictionary containing no key-value mappings.
- How it is used
- Uses mappings to encode characters, look up file lines, represent records, and eliminate duplicate words.
- How deep it goes
- Explains creation, mutation, lookup, membership, iteration, methods, key constraints, and applied patterns, without covering implementation internals.
- Examples
- Demonstrates knight answers, digit substitution, letter-indexed poetry lines, CSV records, and unique word collection.
- What you can do after
- Build lookup tables, safely retrieve values, transform text, index file contents, and convert delimited records into dictionaries.
Read how Tiny Python Projects: Learn coding and testing with puzzles and games explains Map →
Get Programming: Learn to code with Python
- How it is used
- Uses dictionaries to connect paired data and retrieve a value by its key.
- How deep it goes
- Works through creation, updates, removal, iteration, and key restrictions, but gives only a brief hash-function explanation.
- Examples
- Uses grocery quantities, student grades, song ratings, word counts, and shape-area functions as examples.
- What you can do after
- Build it from scratch to store paired data, update entries, count words, and support document comparison.
Read how Get Programming: Learn to code with Python explains Map →
Learn Haskell by Example
An associative list is a list of key-value pair elements that represents mappings between values.
- How it is used
- Models line numbering, graph adjacency, and word-permutation lookup through key-value associations.
- How deep it goes
- Builds an associative-list map through tuple types, membership, zip/unzip, and a recursive alteration operation, while deferring faster replacements.
- Examples
- Uses numbered text lines, graph nodes and edges, paired lists, and a small integer associative list for alterations.
- What you can do after
- Build it from scratch as an associative-list map that checks membership and adds, removes, or conditionally updates mappings.
Fast Python: High performance techniques for large datasets
- How it is used
- Uses dictionaries to retrieve values by known keys and group weather-file contents by station.
- How deep it goes
- Explains hash-based lookup by comparison with sets and examines shallow memory measurements, without developing hash-function internals.
- Examples
- Compares list and set membership timings, groups weather files by station, and inspects the resulting dictionary’s memory footprint.
- What you can do after
- Evaluate/understand when known-key lookup suits a dictionary and why container size alone understates its storage costs.
Read how Fast Python: High performance techniques for large datasets explains Map →
Go in Action, Second Edition
A map is a Go associative data structure that associates keys with values.
- How it is used
- Uses keys suited to a domain to store and retrieve associated values, from inventory weights to grocery-list measurements.
- How deep it goes
- Explains declaration, lookup, mutation, iteration, and function sharing, with a bucket-level hash-table sketch rather than a detailed implementation.
- Examples
- Calculates fruit shipping weights, checks membership through Boolean values, filters ages, and aggregates recipe ingredients into a grocery list.
- What you can do after
- Build it from scratch: initialize and use keyed collections, distinguish absent keys from stored zero values, and avoid relying on iteration order.
Pandas Workout: 200 exercises to make you a stronger data analyst
A mutable Python mapping from unique keys to values.
- How it is used
- Uses mappings to clean categorical data, assemble DataFrames, and dispatch file-format operations without repeated code.
- How deep it goes
- Explains key-value mappings through three executable patterns but stops short of dictionary internals or a general Python reference.
- Examples
- Uses vehicle-color normalization, Series-based DataFrame construction, and timed CSV, JSON, and feather read-write loops.
- What you can do after
- Apply dictionaries through pandas replacement, DataFrame construction, and loops that invoke stored methods or reader functions.
Read how Pandas Workout: 200 exercises to make you a stronger data analyst explains Map →
Advanced Algorithms and Data Structures
A dictionary is an abstract data structure that stores key-value associations and supports operations such as lookup, insertion, and deletion.
- How it is used
- Supports fast lookup, insertion, and removal when applications associate values with arbitrary keys.
- How deep it goes
- Defines the abstract API, compares array and tree alternatives, and explains hashing, collisions, and amortized performance.
- Examples
- Uses contact lists, word associations, spell-checking, heap membership, and local cache access as concrete applications.
- What you can do after
- Evaluate map implementations and apply their APIs to fast in-memory lookup, updates, membership checks, and synchronization.
Read how Advanced Algorithms and Data Structures explains Map →
Java Persistence with Spring Data and Hibernate epub
Map is a Java collection interface representing key-value associations in which each key maps to at most one value.
- How it is used
- Models persistent, uniquely keyed collections of values and entity associations in a Java domain model.
- How deep it goes
- Works through annotation mappings, composite keys, embeddable keys and values, and a ternary join table.
- Examples
- Illustrates filename-to-name image entries, embeddable image values, and an item-to-user map owned by a category.
- What you can do after
- Build it from scratch with JPA map annotations, selecting keys and columns to fit a value collection or entity association.
Read how Java Persistence with Spring Data and Hibernate epub explains Map →
Julia as a Second Language
A dictionary is a mutable associative collection that maps keys to values, with each dictionary specifying or inferring the types of its keys and values.
- How it is used
- Uses dictionaries to retrieve values by keys, from Roman-numeral conversion to product-number lookup.
- How deep it goes
- Works through construction, types, lookup, and array trade-offs; leaves the mechanism behind fast lookup outside its scope.
- Examples
- Demonstrates Roman-numeral values, pizza prices, product-number searches, and alphabet substitution.
- What you can do after
- Apply it via Julia’s `Dict` to build typed key-value lookups and choose them over arrays when appropriate.
Practices of the Python Pro
- How it is used
- Uses key-to-value mappings to retrieve data, represent configuration, and replace repetitive conditional branches.
- How deep it goes
- Defines mappings, retrieval, sorting, performance, and refactoring applications without descending into dictionary internals.
- Examples
- Demonstrates state capitals, choice-to-word mappings, and HTTP response-format configuration.
- What you can do after
- Apply Python dictionaries to retrieve values and simplify choice-based or configuration-driven code.
API Design Patterns
A map is a collection of key-value pairs in which keys identify associated values and may be dynamically defined.
- How it is used
- Stores arbitrary, dynamic key-value data inside resources when a predefined schema would be too restrictive.
- How deep it goes
- Defines maps, contrasts schemas, explains bounds, and specifies nested field-mask syntax without detailing storage internals.
- Examples
- Uses ChatRoom configuration, grocery ingredient amounts, JSON objects, and nested settings field-mask paths.
- What you can do after
- Build it from scratch by choosing maps for dynamic fields, bounding their contents, and addressing nested entries with valid field masks.
Data Analysis with LLMs
A Python dictionary is a mutable mapping data structure that associates keys with values.
- How it is used
- Uses dictionaries to describe chat messages, organize multimodal input, look up encoded images, and prepare fine-tuning samples.
- How deep it goes
- Shows dictionary literals, nested values, and entries added during image loading; does not examine mapping internals.
- Examples
- Shows a user chat message, a text-and-image prompt, a PNG filename-to-image map, and labeled review interactions.
- What you can do after
- Build it from scratch as message dictionaries or filename-to-image maps for GPT-4o workflows.
Secrets of the JavaScript Ninja, Second Edition
A collection type that stores key-value associations and supports efficient lookup by key.
- How it is used
- Use maps as dictionaries for associating keys with values, including cases where plain-object properties create lookup problems.
- How deep it goes
- Explains prototype-property and key-coercion pitfalls through examples, recommends Map, and stops short of detailing its API.
- Examples
- Uses a localization dictionary, an inherited constructor lookup, and HTML elements whose object keys collide after string conversion.
- What you can do after
- Apply JavaScript’s built-in Map instead of a plain object when prototype properties or non-string keys could disrupt lookups.
Read how Secrets of the JavaScript Ninja, Second Edition explains Map →
D3.js in Action, Third Edition
A JavaScript Map is a key-value collection that preserves associations between keys and values and supports lookup by key.
- How it is used
- Uses a Map to translate hidden Canvas pixel colors into the visualization nodes under the pointer.
- How deep it goes
- Explains initialization, uniqueness checking, insertion, and retrieval, but does not survey the broader Map API.
- Examples
- Demonstrates a nodesColors Map that associates generated RGB colors with circles representing paintings.
- What you can do after
- Apply Map with Canvas getImageData() to identify hovered visualization nodes and display their metadata.
Latency
A lookup table is a data structure that stores precomputed values indexed for rapid retrieval.
- How it is used
- Provides keyed local storage for a replicated key–value store and rapid retrieval of precomputed results on latency-sensitive paths.
- How deep it goes
- Shows synchronized Rust get and put operations and compares lookup complexity; does not develop hash-table internals.
- Examples
- Uses a Rust primary–replica key–value store, an array-scan comparison, and precomputed storage-usage statistics.
- What you can do after
- Build it from scratch as a synchronized in-memory Rust key–value store, or evaluate lookup tables for avoiding expensive request-time computation.
Build Your Own Robot: Using Python, CRICKIT, and Raspberry Pi
A dictionary is a mapping data structure that associates keys with corresponding values.
- How it is used
- Organizes robot settings, hardware objects, colors, and joystick identifiers for readable keyed access.
- How deep it goes
- Demonstrates creating dictionaries, indexing and get lookups, and iterating keys in runnable robot programs; does not discuss implementation internals.
- Examples
- Uses motor calibration maps, RGB color names for a blinking LED, and button and axis number maps for joystick output.
- What you can do after
- Apply it via Python dictionaries to retrieve robot configuration, hardware, and human-readable event labels by key.
Read how Build Your Own Robot: Using Python, CRICKIT, and Raspberry Pi explains Map →
Learn AI-Assisted Python Programming, Second Edition
- How it is used
- Uses dictionaries to model associations such as words and frequencies, quarterback names and passing yards, or letters and scores.
- How deep it goes
- Explains mappings, keys, values, uniqueness, mutability, indexing, methods, iteration, and key errors through interactive examples.
- Examples
- Demonstrates word frequencies, quarterback passing yards, Scrabble letter scores, method calls, key errors, updates, and iteration.
- What you can do after
- Apply dictionaries via Python to store associations, retrieve and update values, remove entries, and iterate through mappings.
Read how Learn AI-Assisted Python Programming, Second Edition explains Map →
Learn Rust in a Month of Lunches
- How it is used
- Stores and retrieves values by key, and supports counting or grouping data.
- How deep it goes
- Defines creation, insertion, lookup, ordering, replacement, and entry-based counting and grouping.
- Examples
- Demonstrates city populations, city-to-country lookup, book counts, and grouping survey responses.
- What you can do after
- Apply Rust's HashMap to retrieve, replace, count, and group values by key.
Investing for Programmers
A lookup table is a structured mapping that associates source identifiers or attributes with corresponding standardized values.
- How it is used
- Uses key–value mappings to reconcile asset identifiers, enrich holdings, and construct JSON-compatible API payloads.
- How deep it goes
- Explains mapping roles and demonstrates schemas, DataFrame merging, fallback values, and nested API payloads without discussing dictionary internals.
- Examples
- Demonstrates ticker mappings, asset metadata records, Notion title properties, page blocks, and chunked content payloads.
- What you can do after
- Apply via Python to organize metadata, merge lookup information, and send structured content through an API.
Rust in Action: Systems programming concepts and techniques
An associative array is an abstract data structure that maps keys to values without requiring integer indices.
- How it is used
- Uses maps to store and retrieve key–value pairs, then choose between Rust’s HashMap and BTreeMap.
- How deep it goes
- Explains basic operations and hashing’s lookup behavior, then demonstrates ordering and range queries without detailing either implementation’s internals.
- Examples
- Uses island nations and capitals for insertion and lookup, and investment amounts for ordered iteration and a range query.
- What you can do after
- Apply Rust’s HashMap to store and retrieve pairs, handle missing keys with `.get()`, and select BTreeMap when ordering matters.
Read how Rust in Action: Systems programming concepts and techniques explains Map →
Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
A hash table is a key-value data structure that associates unique keys with corresponding values.
- How it is used
- Uses dictionaries to pass command parameters, construct structured objects, and assemble output dynamically in reusable PowerShell tools.
- How deep it goes
- Demonstrates literal construction, splatting, conditional keys, object creation, dynamic additions, and display-order tradeoffs.
- Examples
- Demonstrates CIM queries, machine-information objects, service arguments, and DNS results assembled from successful or failed lookups.
- What you can do after
- Apply dictionaries to shorten commands, create reusable structured output, and add properties conditionally before pipeline emission.
ASP.NET Core in Action, 3e
A dictionary is a key-value data structure that associates each key with a value.
- How it is used
- Uses key-value storage for API records and binds dictionaries from configuration or submitted form data.
- How deep it goes
- Explains CRUD access and binding rules, including supported key types and initialized collection behavior.
- Examples
- Uses a fruit catalog, configuration options, and selected currencies to demonstrate dictionary storage and binding.
- What you can do after
- Apply it via C# dictionaries to store keyed API data and bind keyed configuration or form values.
Code Like a Pro in Rust
- How it is used
- Uses `HashMap` as Rust’s standard container for retrieving values by key.
- How deep it goes
- Explains key trait bounds and required custom-hasher methods, while deferring detailed treatment of traits and `#[derive]`.
- Examples
- Demonstrates a `MetroBuildHasher` map with insertion and lookup, plus a compound key with derived traits.
- What you can do after
- Apply it via `HashMap` with a derived compound key or a crate-provided custom hasher.
Object-Oriented Software Design in C++
- How it is used
- Uses dictionaries to represent variable book attributes and support reusable catalogue searches.
- How deep it goes
- Defines key–value mapping and demonstrates typed implementation with map and variant, without detailing map internals.
- Examples
- Demonstrates book records, typed attribute tables, case-insensitive surname matching, and region-based cookbook searches.
- What you can do after
- Apply it via STL map and variant to model heterogeneous attributes and query matching records.
Read how Object-Oriented Software Design in C++ explains Map →
Essential TypeScript 5, Third Edition
Map is a JavaScript built-in collection that stores key/value pairs and permits keys and values of arbitrary types.
- How it is used
- Organizes application objects by stable keys, replacing restrictive string-keyed object collections.
- How deep it goes
- Explains storage, lookup, iteration, and TypeScript generic restrictions through worked collections, without descending into runtime internals.
- Examples
- Uses TodoItem objects keyed by numeric IDs and products keyed by names.
- What you can do after
- Apply it via JavaScript and TypeScript to build typed keyed collections, retrieve values, and iterate over stored objects.
Read how Essential TypeScript 5, Third Edition explains Map →
Go in Practice, Second Edition
- How it is used
- Uses maps for dictionary-style collections, including accessing fields in JSON objects and representing valid options.
- How deep it goes
- Defines maps as dictionary-like collections and demonstrates accessing JSON fields through a typed map assertion.
- Examples
- Uses valid-language options and a parsed JSON object with a firstName field.
- What you can do after
- Apply maps to retrieve named fields from JSON objects with unknown structure.
100 Java Mistakes and How to Avoid Them
HashMap is a Java map implementation that stores key-value associations using hashing.
- How it is used
- Warns against mutating objects used as HashMap keys or HashSet elements.
- How deep it goes
- Explains bucket selection, changed hash codes, equality inconsistencies, debugging consequences, and prevention choices.
- Examples
- Uses mutable lists, BitSet, Date, Calendar, LocalDateTime, and StringBuilder to expose key-related failures.
- What you can do after
- Diagnose failed lookups by checking key mutation, hashCode stability, equality consistency, and bucket-sensitive behavior.
Read how 100 Java Mistakes and How to Avoid Them explains Map →
Kotlin in Action, 2E
HashMap is a hash-table-based Java map implementation that stores key-value associations and uses key hash codes for lookup.
- How it is used
- Supports direct lookup, mutable updates, iteration, grouping, and collection-to-map transformations.
- How deep it goes
- Explains Kotlin syntax, destructuring, grouping, association directions, and duplicate-key overwrites without covering map implementation internals.
- Examples
- Uses binary character representations, age-based people groups, first-character string groups, and person-to-age associations.
- What you can do after
- Apply Kotlin map indexing, destructuring, groupBy, associate, associateWith, and associateBy to collection data.
Software Design for Python Programmers
A dictionary is a collection that maps unique immutable keys to values.
- How it is used
- Models flexible book attributes while removing duplication between book-type and attribute subclasses.
- How deep it goes
- Explains keys, values, immutability, uniqueness, typed validation, matching, formatting, and catalogue searches.
- Examples
- Uses book metadata, enumeration keys, case-insensitive author searches, and region-based catalogue searches.
- What you can do after
- Build it from scratch to represent validated, searchable collections of changing name–value attributes.
Read how Software Design for Python Programmers explains Map →
Clojure: The Essential Reference
A map is an associative Clojure collection that stores values under keys.
- How it is used
- Uses maps for associative lookup, membership testing, and extracting key or value sequences.
- How deep it goes
- Defines supported map-like inputs, return behavior, ordering, and notable exceptions without detailing map implementation internals.
- Examples
- Demonstrates nil-valued entries, key membership, extracted sequences, filtered MapEntry values, and configuration scoring.
- What you can do after
- Apply map membership checks with contains? and extract keys or values with keys and vals.
Elixir in Action, Third Edition
A map is an Elixir data structure that associates keys with values, with both keys and values allowed to be any term.
- How it is used
- Stores dynamic key-value collections and small named records in Elixir programs.
- How deep it goes
- Explains construction, lookup, missing-key behavior, updates, and field access without covering the complete Map API.
- Examples
- Uses empty maps, square-number mappings, Map.new/1, and a named Bob record.
- What you can do after
- Apply map literals, Map functions, access operators, and update syntax while choosing explicit missing-key behavior.
Related concepts
- data structurekind of · A data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
- name-value pairhas part · A name-value pair is a data association in which an identifying name or key corresponds to a value.
- OrderedDictincludes · OrderedDict is a Python dictionary subclass that preserves insertion order and provides operations for explicitly rearranging entries.
- arrayuses · An array is an indexed, ordered collection of elements arranged in one or more dimensions, with elements accessed by position.
- dict.getused by · dict.get is a Python dictionary method that returns the value for a key or a specified default when the key is absent.
- membership operatorused by · A membership operator is a language construct that tests whether a specified value or property is present in a supported collection, range, or object.
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.