Chapter 2: Write your first kernel in Triton
Introduces the chapter’s plan to build, examine, launch, and benchmark a vector-addition kernel in Triton.
After this chapter you will be able to
- Kernel author and compiler roles. Explain that a Triton kernel describes a parallel computation while the compiler handles implementation details for efficient execution on the target GPU.
- Block-Level Programming Model. Distinguish CUDA’s thread-level point of view from Triton’s block-level point of view. Explain that a Triton program instance operates on a block of data rather than being written as the work of one thread.
- Vectorized Block Operations. Trace the section’s eight-element vector-addition example with a block size of four. Describe how two Triton program instances each add a four-element slice using vector operations, and distinguish that from four scalar additions assigned to four CUDA threads per block.
- Triton block-level program instances. Explain how Triton changes the unit of work from CUDA’s individual elements to blocks or tiles of elements, with one program instance applying the same logic across its block.
- Grid and program ID roles. Describe how a grid launches one copy of a Triton program per tile and how each instance uses its program ID to read its own input slice.
- Block-level vector addition. Explain how Triton performs Z = X + Y across a vector: each parallel program instance applies the same logic to a different contiguous block, and a grid covers the full vector.
- First-launch JIT compilation. Explain when @triton.jit compiles a kernel and why an initial call can be slower than later calls that reuse its compiled result.
- Tensor pointers and base addresses. Explain that x_ptr, y_ptr, and z_ptr are GPU memory addresses rather than tensors, and that the kernel combines these base addresses with offsets to access elements.
- Compile-time block size specialization. Explain what BLOCK_SIZE: tl.constexpr means in a Triton signature and how fixing that value before code generation lets Triton specialize the kernel.
- Runtime values versus constexpr. Distinguish parameters that shape the kernel, such as block sizes, from changing data-related values such as n_elements, and explain the compilation cost of marking the latter constexpr.
- Program IDs and block ownership. Explain how tl.program_id(axis=0) gives each program instance a unique ID that identifies its block of input elements in this one-dimensional vector-addition kernel.
- Program chunk starting position. Explain how a program uses its ID and BLOCK_SIZE to calculate the first element of its assigned vector chunk, and why consecutive IDs handle consecutive chunks.
- Local to global offsets. Explain how adding block_start to the sequence from tl.arange gives a program the absolute indices of the elements it will work on.
- Masking the final block. Explain why the final program may compute out-of-bounds offsets and how a boolean mask prevents loads and stores at those positions.
- Global memory and registers. Explain where tl.load gets input values, where arithmetic happens, and where tl.store sends the results.
- Block addresses and valid positions. Describe how a program forms addresses for its input slices and uses the mask when loading them.
- Elementwise addition and output. Trace how a program adds its two input slices and writes its results into the output vector.
- Launch grid size. Explain how to choose a one-dimensional launch grid for a vector of n_elements when each program handles BLOCK_SIZE elements.
- Launch-time grid function. Describe how the lambda grid function obtains BLOCK_SIZE and how its returned tuple is used when launching the kernel.
- Kernel and grid separation. Explain why the same block-processing kernel works for vectors of different sizes.
- Launch Grid and Work Assignment. Trace how the host launches the kernel and how each GPU program finds its chunk of the vectors.
- Masked Vector Addition Flow. Describe how a program loads, adds, and stores its vector elements while protecting positions beyond the input boundary.
- Asynchronous GPU timing. Explain why timing a Triton call with a CPU wall clock alone is misleading, and describe how synchronization or CUDA events measure completed GPU work.
- Correctness before timing. Explain why the output must be checked against a reference before benchmarking and how a tolerance-based comparison handles floating-point differences.
- Compilation and specialization costs. Explain why first-call compilation must be excluded from steady-state timing and distinguish changes in runtime vector length from changes in constexpr block size.
- Repeated benchmarking with do_bench. Describe how to use triton.testing.do_bench for repeated GPU measurements and how its warmup, timing budgets, and reported statistics work.
- Vector addition performance comparison. Interpret why the Python, PyTorch, and Triton results differ across input sizes, and explain why the CPU Python loop needs a different timer.
- High-level syntax and compilation. Explain how a Triton kernel can feel like an ordinary Python function while a low-level compiler turns it into optimized machine code for parallel GPU execution.
- Kernel compilation sequence. Trace the path from a function captured by @triton.jit through parsing, TTIR, TTGIR, LLVM IR, PTX, and CUBIN to execution by the GPU.
- TTIR and TTGIR roles. Distinguish the hardware-agnostic kernel logic in TTIR from the GPU-specific layouts and access decisions introduced in TTGIR.
- Programmatic compilation stage access. Describe how a first kernel launch makes compilation artifacts available locally and how to retrieve them through the compiled kernel’s asm attribute.
- Stage-specific debugging clues. Explain what inspecting TTIR, TTGIR, and PTX can reveal about a kernel, and when that inspection is worth doing.
- Compiler Explorer inspection tradeoff. Describe how Compiler Explorer lets you compare Triton compilation stages without a local run, and distinguish its output from locally inspected artifacts.
What it builds on
- What is Triton? (chapter 1) · Introduces Triton as a GPU programming tool.
- The GPU execution model (chapter 1) · The GPU execution model provides context for grids, blocks, and threads.
Section by section
Introduction
Introduces the chapter’s plan to build, examine, launch, and benchmark a vector-addition kernel in Triton.
2.1 The Triton programming model
This section introduces Triton’s division of work between kernel authors and the compiler, and notes that its foundational kernel APIs tend to remain stable across releases.
- Kernel author and compiler roles: Explain that a Triton kernel describes a parallel computation while the compiler handles implementation details for efficient execution on the target GPU.
Why it matters: This division of work explains why Triton can be easier to write than low-level GPU code without leaving execution details entirely to the developer. - Foundational kernel API stability: Explain why the section expects kernels using its foundational patterns to keep running on newer Triton releases.
Why it matters: A newer Triton release does not necessarily make the chapter’s basic kernel patterns obsolete.
Key terms: Triton kernel, compiler, parallel computation, memory coalescing, shared memory, instruction scheduling, program IDs, offsets, masks, @triton.jit decorator
2.1.1 Thinking in blocks, not threads
This section shifts the reader from thinking about individual GPU threads to writing Triton programs that operate on blocks of data.
- Block-Level Programming Model: Distinguish CUDA’s thread-level point of view from Triton’s block-level point of view. Explain that a Triton program instance operates on a block of data rather than being written as the work of one thread.
Why it matters: Choosing the block as your unit of thought makes the rest of a Triton kernel easier to follow. - Vectorized Block Operations: Trace the section’s eight-element vector-addition example with a block size of four. Describe how two Triton program instances each add a four-element slice using vector operations, and distinguish that from four scalar additions assigned to four CUDA threads per block.
Why it matters: The example shows what it means in practice to write an operation over a data slice instead of individual elements. - Automatic Intra-Block Coordination: Explain why Triton’s block-level model reduces manual coordination: its compiler and runtime handle how threads execute within a block, and the compiler inserts needed synchronization.
Why it matters: This explains why block-level Triton code can be simpler to write and maintain while still using parallel hardware.
Key terms: block-level programs, thread-level programs, program instance, block size, vectorized, coordination, synchronization, compiler, runtime
2.1.2 The Single Program, Multiple Data model
Explains how Triton applies one program to many data blocks, how that differs from CUDA’s thread-level model, and how a grid assigns blocks to program instances.
- SPMD and SIMT distinction: Distinguish SPMD as the pattern of running the same program on different data from SIMT as the way NVIDIA hardware executes threads in warps.
Why it matters: It keeps the programming pattern separate from the hardware’s execution model. - Triton block-level program instances: Explain how Triton changes the unit of work from CUDA’s individual elements to blocks or tiles of elements, with one program instance applying the same logic across its block.
Why it matters: Thinking in blocks is the central shift in how you write a Triton kernel. - Grid and program ID roles: Describe how a grid launches one copy of a Triton program per tile and how each instance uses its program ID to read its own input slice.
Why it matters: The grid and program ID connect block-level code to distinct parts of the input.
Key terms: Single Program, Multiple Data (SPMD), Single Instruction, Multiple Threads (SIMT), warp, blocked SPMD, tiled SPMD, program instance, block, tile, grid, program ID
2.2 A complete Triton kernel: vector addition end to end
This section uses vector addition to show how a Triton kernel’s block-level work and a host-side launch combine to produce a complete GPU computation.
- Block-level vector addition: Explain how Triton performs Z = X + Y across a vector: each parallel program instance applies the same logic to a different contiguous block, and a grid covers the full vector.
Why it matters: This is the basic mapping from one kernel program to work across an entire vector. - Kernel and host responsibilities: Distinguish the device kernel’s work from the host wrapper’s work in this example.
Why it matters: Separating CPU launch code from GPU computation makes the complete example easier to follow. - Purpose of the addition example: Justify why the section uses vector addition as a first kernel without presenting basic addition as Triton’s main advantage.
Why it matters: It keeps the teaching example distinct from the kinds of workloads that motivate Triton.
Key terms: SPMD, program instance, block, grid, vector addition, device kernel, host-side wrapper, host, device, grid configuration
2.2.1 Imports and the JIT decorator
This section explains the roles of Triton’s imports and how @triton.jit compiles, specializes, and caches a kernel when it is first launched.
- Triton module roles: Distinguish what the triton and triton.language modules provide when writing a kernel.
Why it matters: The distinction clarifies where kernel operations come from and what runs the kernel. - First-launch JIT compilation: Explain when @triton.jit compiles a kernel and why an initial call can be slower than later calls that reuse its compiled result.
Why it matters: A first-call timing includes compilation and does not represent the kernel’s cached execution speed. - Runtime specialization versus AOT: Distinguish Triton’s runtime specialization from ahead-of-time compilation as described in the section.
Why it matters: Waiting for actual arguments lets Triton tailor generated code to inputs that were not known before the program ran.
Key terms: triton, triton.language, tl.load, tl.store, @triton.jit, Just-In-Time compilation, first launch, cached, specialization, shapes
2.2.2 Function signature and pointers
This section explains what the vector-addition kernel’s pointer and size parameters mean, and why BLOCK_SIZE is a compile-time constant while vector length remains a runtime argument.
- Tensor pointers and base addresses: Explain that x_ptr, y_ptr, and z_ptr are GPU memory addresses rather than tensors, and that the kernel combines these base addresses with offsets to access elements.
Why it matters: This is how the kernel locates the tensor elements it reads and writes. - Compile-time block size specialization: Explain what BLOCK_SIZE: tl.constexpr means in a Triton signature and how fixing that value before code generation lets Triton specialize the kernel.
Why it matters: A fixed block size lets Triton generate code for that chunk size instead of handling an arbitrary size at runtime. - Runtime values versus constexpr: Distinguish parameters that shape the kernel, such as block sizes, from changing data-related values such as n_elements, and explain the compilation cost of marking the latter constexpr.
Why it matters: Keeping frequently changing lengths at runtime avoids repeated compilation without sacrificing the specialization BLOCK_SIZE provides. - Warp-aligned block size: State why a multiple of 32 is often a good starting BLOCK_SIZE on NVIDIA GPUs.
Why it matters: Warp alignment gives a practical starting point when choosing a block size.
Key terms: x_ptr, y_ptr, z_ptr, pointer, base address, offset, BLOCK_SIZE, tl.constexpr, type annotation, compile-time constant
2.2.3 Getting a unique program ID
Explains how a Triton program instance uses its program ID to identify the block of a vector it handles.
- Program IDs and block ownership: Explain how tl.program_id(axis=0) gives each program instance a unique ID that identifies its block of input elements in this one-dimensional vector-addition kernel.
Why it matters: The program ID lets each parallel instance work on its own part of the input.
Key terms: program ID, tl.program_id(axis=0), pid, launch grid, BLOCK_SIZE
2.2.4 Calculating the data chunk
Explains how a Triton program finds its vector chunk and how the launch-time block size affects the work assigned to each program.
- Program chunk starting position: Explain how a program uses its ID and BLOCK_SIZE to calculate the first element of its assigned vector chunk, and why consecutive IDs handle consecutive chunks.
Why it matters: This calculation lets one kernel assign different parts of a vector to different programs. - Launch-time block size choices: Describe who sets BLOCK_SIZE and how increasing or decreasing it changes the work per program and the number of programs. Explain why a multiple of 32 is a usual starting point on NVIDIA hardware.
Why it matters: Block size changes how work is divided among programs and can affect resource use.
Key terms: block_start, pid, BLOCK_SIZE, SPMD model, warps
2.2.5 Computing the element offsets
Shows how a Triton program turns positions within its block into indices in the global array.
- Local to global offsets: Explain how adding block_start to the sequence from tl.arange gives a program the absolute indices of the elements it will work on.
Why it matters: These offsets tell each program which array elements it will load and update.
Key terms: block_start, tl.arange, local indices, absolute indices
2.2.6 Handling edges with a mask
This section explains how a boolean mask lets the final vector-addition block handle offsets beyond the array safely.
- Masking the final block: Explain why the final program may compute out-of-bounds offsets and how a boolean mask prevents loads and stores at those positions.
Why it matters: Masking keeps the kernel safe when the vector does not fill its final block.
Key terms: BLOCK_SIZE, offsets, mask, tl.load, tl.store
2.2.7 Loading data and performing the computation
Explains how each Triton program loads its block of vector data, adds corresponding elements, and stores valid results.
- Global memory and registers: Explain where tl.load gets input values, where arithmetic happens, and where tl.store sends the results.
Why it matters: This explains the load–compute–store path followed by the vector-addition kernel. - Block addresses and valid positions: Describe how a program forms addresses for its input slices and uses the mask when loading them.
Why it matters: It connects the previously calculated offsets and mask to the actual input values each program reads. - Elementwise addition and output: Trace how a program adds its two input slices and writes its results into the output vector.
Why it matters: This completes the account of how the separate programs collectively produce the output vector.
Key terms: tl.load, tl.store, global memory, registers, x_ptr, y_ptr, offsets, BLOCK_SIZE, mask, element-wise addition
2.2.8 The launch grid
Explains how a launch grid assigns one program instance per vector block, adapts to the chosen block size, and lets the same kernel scale to different input sizes.
- Launch grid size: Explain how to choose a one-dimensional launch grid for a vector of n_elements when each program handles BLOCK_SIZE elements.
Why it matters: The grid must provide enough programs to cover the entire vector, including a final partial block. - Launch-time grid function: Describe how the lambda grid function obtains BLOCK_SIZE and how its returned tuple is used when launching the kernel.
Why it matters: A launch-time grid function can use the block size chosen for that call without fixing it in advance. - Kernel and grid separation: Explain why the same block-processing kernel works for vectors of different sizes.
Why it matters: Separating per-block work from the host’s grid choice makes the kernel reusable across input sizes.
Key terms: launch grid, n_elements, BLOCK_SIZE, triton.cdiv, lambda, meta, tl.constexpr, program instance, tl.program_id(0), host code
2.2.9 Kernel execution flow
This section traces a vector-addition kernel from the host launch through each program’s work to completion across the GPU.
- Launch Grid and Work Assignment: Trace how the host launches the kernel and how each GPU program finds its chunk of the vectors.
Why it matters: This connects a single kernel launch to the distinct chunks of data processed on the GPU. - Masked Vector Addition Flow: Describe how a program loads, adds, and stores its vector elements while protecting positions beyond the input boundary.
Why it matters: The mask lets the final program handle a chunk that extends past the vector’s end. - Concurrent Grid Completion: Explain how the GPU runs the grid’s program instances and when the complete output is ready.
Why it matters: It explains how independent chunks become one complete result without requiring programs to run one after another.
Key terms: host, launch grid, program instance, program ID, offsets, mask, registers, element-wise addition, output tensor, grid
2.2.10 Benchmarking the kernel
The section shows how to benchmark a Triton vector-addition kernel reliably and interprets its performance against Python and PyTorch.
- Asynchronous GPU timing: Explain why timing a Triton call with a CPU wall clock alone is misleading, and describe how synchronization or CUDA events measure completed GPU work.
Why it matters: Otherwise, an apparently fast kernel may simply be one whose launch returned quickly. - Correctness before timing: Explain why the output must be checked against a reference before benchmarking and how a tolerance-based comparison handles floating-point differences.
Why it matters: Checking first prevents a fast but incorrect implementation from appearing successful. - Compilation and specialization costs: Explain why first-call compilation must be excluded from steady-state timing and distinguish changes in runtime vector length from changes in constexpr block size.
Why it matters: Separating compilation from execution makes both timing results and input-size sweeps interpretable. - Repeated benchmarking with do_bench: Describe how to use triton.testing.do_bench for repeated GPU measurements and how its warmup, timing budgets, and reported statistics work.
Why it matters: Repeated, warmed-up measurements are more representative than one isolated call. - Cold-cache benchmark conditions: Explain why do_bench flushes the L2 cache between timed iterations of this memory-bound workload.
Why it matters: Otherwise, repeated runs can make fresh-data bandwidth appear better than it is. - Vector addition performance comparison: Interpret why the Python, PyTorch, and Triton results differ across input sizes, and explain why the CPU Python loop needs a different timer.
Why it matters: The comparison connects reliable measurements to when GPU parallelism pays off and what a small Triton kernel can achieve.
Key terms: asynchronous execution, torch.cuda.synchronize(), CUDA events, triton.testing.assert_close, reference tensor, atol, rtol, just-in-time compilation, warmup runs, n_elements
2.3 A high-level language with a low-level compiler
This section explains Triton’s high-level programming and low-level compilation duality, while noting that its block-level syntax does not remove every GPU performance concern.
- High-level syntax and compilation: Explain how a Triton kernel can feel like an ordinary Python function while a low-level compiler turns it into optimized machine code for parallel GPU execution.
Why it matters: It explains why writing a Triton kernel can feel simple even though executing it on a GPU is complex. - Remaining warp divergence risk: Describe the performance concern that can arise when threads in a warp disagree about a conditional branch inside a Triton kernel.
Why it matters: It qualifies the high-level programming benefit: kernel code can still have GPU-specific performance costs.
Key terms: high-level syntax, low-level compiler, machine code, block-level syntax, warp divergence, warp
2.3.1 The compilation funnel (advanced)
This subsection traces how Triton progressively compiles a block-level Python kernel into GPU-executable code.
- Kernel compilation sequence: Trace the path from a function captured by @triton.jit through parsing, TTIR, TTGIR, LLVM IR, PTX, and CUBIN to execution by the GPU.
Why it matters: The sequence connects the kernel you write to the binary the GPU runs. - TTIR and TTGIR roles: Distinguish the hardware-agnostic kernel logic in TTIR from the GPU-specific layouts and access decisions introduced in TTGIR.
Why it matters: This distinction shows where Triton turns block-level intent into hardware-aware choices.
Key terms: @triton.jit, abstract syntax tree, TTIR, TTGIR, LLVM IR, PTX, Triton IR, Triton GPU IR, layout, coalescing
2.3.2 Practical inspection of compilation stages
This section shows how to inspect Triton’s compilation stages locally or in Compiler Explorer to understand and troubleshoot generated GPU code.
- Programmatic compilation stage access: Describe how a first kernel launch makes compilation artifacts available locally and how to retrieve them through the compiled kernel’s asm attribute.
Why it matters: You can inspect what Triton generated for a kernel you actually ran without dumping every stage into the terminal. - Stage-specific debugging clues: Explain what inspecting TTIR, TTGIR, and PTX can reveal about a kernel, and when that inspection is worth doing.
Why it matters: Choosing the relevant stage helps you investigate a performance problem without having to understand every compiler artifact. - Compiler Explorer inspection tradeoff: Describe how Compiler Explorer lets you compare Triton compilation stages without a local run, and distinguish its output from locally inspected artifacts.
Why it matters: The online view is convenient for exploration, while local artifacts are the better match for diagnosing a kernel on your own system.
Key terms: local cache, compiled kernel object, asm attribute, TTIR, PTX, cubin, TTGIR, block-level logic, thread hierarchy, performance cliffs
2.4 Summary
Where this is used later
- Triton’s primitives for reduction (chapter 4) · The block-based model in which a program instance works on a tile.
- (chapter intro) (chapter 4) · GPU programs process separate portions of data.
- Embarrassingly parallel tasks: the baseline GPU pattern (chapter 3) · Uses the vector-addition example introduced in the previous chapter.
- Matrix addition (chapter 5) · The vector-addition kernel used as the 1D comparison.
- Kernel fusion: the solution (chapter 3) · The kernel-fusion section develops the motivation introduced here.
- Building the kernel (chapter 3) · Getting a unique program ID
- Advanced indexing: coordinate mapping (RoPE) (chapter 3) · The vector-addition kernel’s element-offset calculation.
- The memory layout challenge (chapter 3) · Computing element offsets for kernel loads.
Concepts explained in this chapter
- vector additionVector addition is the element-wise operation that adds corresponding components of two equal-sized vectors to produce a third vector.
- cubinA cubin is a CUDA binary containing GPU machine code compiled for a particular NVIDIA GPU architecture.
- specializationCode specialization generates an implementation tailored to particular known argument types, shapes, or configuration values.
- constexprconstexpr denotes a value available at compile time rather than only at runtime.
- benchmarkingA benchmark is a specified test or measurement procedure used to evaluate program performance.
- tl.program_idA program ID is an integer identifying a Triton program instance along a selected dimension of the launch grid.
- CUDA eventA CUDA event is a GPU-timeline timestamp object used to record and measure points in CUDA stream execution.
- asynchronous programmingAsynchronous execution allows a processor to issue work and continue without waiting for that work to finish.
- cache flushingCache flushing is the deliberate eviction of cached data so subsequent measurements begin without data retained from earlier executions.
- effective memory bandwidthThe achieved rate of data transfer during a computation, as distinct from the memory system's peak bandwidth.
- torch.cuda.synchronize()torch.cuda.synchronize() is a PyTorch CUDA API call that blocks the CPU until all previously issued GPU work has completed.
- triton.testing.assert_closetriton.testing.assert_close is a Triton testing utility that compares result and reference tensors within absolute and relative tolerances and raises an error when they differ excessively.
- triton.testing.do_benchtriton.testing.do_bench is a Triton benchmarking utility that performs warmup, synchronized timing, repetition, and runtime summarization for a callable.
- warming upA warmup run is an untimed execution performed before measurement to complete initialization and bring hardware into a representative operating state.
- program instanceA program instance is Triton's unit of work corresponding to one block of input elements in a compiled kernel launch.
- gridA GPU grid is the complete collection of blocks or program instances launched for one kernel call.
- maskA mask is a per-element boolean predicate that enables or suppresses selected elements of a GPU memory operation.
- block-level programmingA block-level programming language lets a programmer express a GPU kernel from the perspective of one block processing one tile.
- LLVM IRLLVM IR is a typed, low-level intermediate representation used by the LLVM compiler infrastructure for analysis and code generation.
- SPMDThe SPMD model runs the same program code across multiple program instances while each instance operates on a different portion of the data.
- @triton.jit@triton.jit is a Triton decorator that marks a Python function for JIT compilation into a GPU kernel.
- block sizeBlock size specifies the number of elements or threads assigned to a GPU computation block or Triton program instance.
- TritonThe Triton compiler transforms Triton programs into optimized GPU code for a target backend.
- hostIn GPU computing, the host is the CPU-side execution environment that launches and orchestrates device work.
- Compiler ExplorerCompiler Explorer is an online tool that compiles source code and displays its generated intermediate and target representations.
- asm attributeThe asm attribute is a compiled Triton kernel object's mapping from compilation-stage names to generated source or binary representations.
- intermediate representationAn intermediate representation is a structured compiler artifact that expresses a program between its source form and its final executable form.
- ir inspectionIR inspection is the examination of compiler intermediate representations to understand program lowering and generated code.
- vectorizationVectorization is an optimization technique that performs one operation on multiple data elements using vector or SIMD instructions.
- pointerA pointer is a variable that stores a memory address used to locate data in memory.
- tl.constexprtl.constexpr is a Triton annotation that marks a kernel parameter as a compile-time constant for specialization.
- type hintsA type annotation is syntax attached to a programming-language parameter or value that specifies type-related metadata or compilation semantics.
- tl.loadtl.load is Triton's operation for loading values from memory through pointer expressions, with optional per-element masking.
- tl.storetl.store is Triton's operation for storing values to memory through pointer expressions, with optional per-element masking.
- just-in-time compilationJIT compilation translates program code into executable machine code at or near the time it is invoked.
- PTXPTX is NVIDIA's low-level virtual instruction-set representation for GPU programs.
- SIMTThe Single Instruction, Multiple Threads (SIMT) execution model runs the same instruction across multiple threads operating on separate data.
- offsetAn offset is an index displacement used to address an element within a data region.
- GPU kernelA GPU kernel is a function launched on a GPU to perform computation in parallel.
- deviceIn CUDA terminology, the device is the GPU-side processor and execution environment that executes dispatched parallel work.
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.
