Pipeline
A pipeline is an ordered or coordinated sequence of connected processing stages or tasks that passes data, work, or results toward an outcome.
Natural Language Processing in Action, Second Edition
An NLU pipeline is a sequence of natural-language-understanding stages that transform text into an interpretation or decision.
- How it is used
- Turns natural-language input into features, decisions, or replies for applications such as chatbots and question answering.
- How deep it goes
- Defines a five-subsystem chatbot design and explores processing layers, while allowing simpler applications to use only a few algorithms.
- Examples
- Uses a two-intent greeting recognizer, spaCy token inspection, and a chatbot with conversation memory and a faulty math reply.
- What you can do after
- Build it from scratch by combining suitable parsing, analysis, generation, decision, and memory components for a chatbot.
Read how Natural Language Processing in Action, Second Edition explains pipeline →
Build AI-Enhanced Web Apps
A workflow is an ordered set of connected tasks or operations that accomplishes a broader process.
- How it is used
- Organizes AI web-app processing into connected stages, from user input or document ingestion to generated output.
- How deep it goes
- Works through runnable composition, retrieval input matching, and document workflows, while leaving the wider LangChain ecosystem outside its scope.
- Examples
- Demonstrates a vowel-count chain, a retriever-backed question-answering chain, and an uploaded-document summarization workflow.
- What you can do after
- Build it from scratch with LangChain.js runnables, then connect retrieval or streamed UI output to a web application.
AI Agents and Applications
A multi-step workflow is a process composed of several ordered or coordinated operations that collectively accomplish a task.
- How it is used
- Organizes summarization, web research, and RAG into connected operations that produce outputs a single prompt cannot conveniently handle.
- How deep it goes
- Builds sequential and parallel LCEL chains from runnable components, then identifies where linear flow and implicit state make adaptation difficult.
- Examples
- Works through chunk-by-chunk summarization, a parallel web-research report, and document ingestion followed by retrieval-based question answering.
- What you can do after
- Build it from scratch with LCEL and Runnable components, then test sub-chains and inspect intermediate results when behavior is brittle.
Machine Learning System Design
An ordered set of computational steps and dependencies that accomplishes a defined process.
- How it is used
- Organizes model preparation and prediction into reproducible workflows rather than isolated training or serving actions.
- How deep it goes
- Defines DAG-based steps and works through training stages, orchestration, scaling, and testing; treats inference framework choices without prescribing one platform.
- Examples
- Uses a manual notebook workflow, demand forecasting, multimodal search, and a reduced-run training smoke test.
- What you can do after
- Build it from scratch as a reproducible training workflow, then test its steps and choose scaling to match expected data growth.
Delivering Machine Learning Projects: From design to deployment
A production data flow is the operational movement and transformation of data through a deployed machine learning system.
- How it is used
- Feeds application data through feature creation to running models so a production system can make inferences.
- How deep it goes
- Defines scheduled DAGs and gives implementation tasks for integration, testing, and production replication; stops short of a tool-specific build walkthrough.
- Examples
- Uses an ELT DAG joining and cleaning two tables and a shopping-basket click assembled from several application data sources.
- What you can do after
- Build it from scratch as a tested production data flow that recreates model inputs and reports step failures.
Read how Delivering Machine Learning Projects: From design to deployment explains pipeline →
"Looks Good to Me"
A workflow is an ordered sequence of activities and handoffs used to complete a process.
- How it is used
- Organizes code review into shared stages, responsibilities, handoffs, feedback, and approval decisions.
- How deep it goes
- Defines four core workflow components and six team decisions, while deferring deeper automation and advanced practices.
- Examples
- Uses pull requests, reviewer assignments, review comments, approval gates, whiteboard maps, and revised baseline workflows.
- What you can do after
- Build it from scratch by agreeing on goals, tools, stages, guidelines, signoff conditions, and later refinements with the team.
Financial AI in Practice
An ordered sequence of data-processing or modeling steps that transforms inputs into outputs.
- How it is used
- Organizes financial data preparation, modeling, and signal generation into ordered workflows whose outputs support downstream decisions.
- How deep it goes
- Works through DAG tasks and multi-stage modeling and retrieval flows, while identifying production controls beyond the minimal batch example.
- Examples
- Uses monthly credit-data merges, fold-safe LightGBM fraud training, and nightly ledger–clickstream joins.
- What you can do after
- Apply it via Apache Airflow to schedule dependent financial-data tasks, with lineage and missing-data controls planned for production.
Effective Platform Engineering
A pipeline workflow is a defined arrangement of automation steps or jobs that executes as a coordinated process.
- How it is used
- Coordinates repository automation and platform releases, while also describing type-specific observability data ingestion.
- How deep it goes
- Explains triggers, filters, job dependencies, and reusable code; extends to platform-scale patterns without specifying a complete pipeline configuration.
- Examples
- Uses CircleCI branch and tag filters, control-plane service and extension pipelines, and preview-environment conformance tests.
- What you can do after
- Build it from scratch with simple triggers and orchestration, then move reusable steps into versioned shared code.
Machine Learning Platform Engineering
An orchestrated pipeline is a coordinated sequence of automated data and machine learning workflow steps, including iteration and dependencies.
- How it is used
- Coordinates repeatable ML work from data preparation through validation and deployment, replacing error-prone manual handoffs with orchestrated execution.
- How deep it goes
- Builds from reusable components to compiled KFP workflows, then identifies production triggers, monitoring, and data-access concerns.
- Examples
- Uses dataset download and splitting, an ID card detector, and a configurable movie-recommender training pipeline.
- What you can do after
- Build it from scratch with KFP components, then connect and configure them as an executable ML workflow.
Read how Machine Learning Platform Engineering explains pipeline →
ASP.NET Core in Action, 3e
A handler pipeline is an ordered chain of HTTP message handlers that can modify requests and inspect responses around a final transport handler.
- How it is used
- Adds shared behavior to outgoing HttpClient calls without repeating it at each call site.
- How deep it goes
- Explains request and response flow, handler registration, ordering, retries, and factory-managed lifetimes; defers detailed Polly strategy trade-offs.
- Examples
- Shows an API-key header handler and a typed HTTP client configured with three delayed retries.
- What you can do after
- Build it from scratch: register a custom handler on a named or typed client and use Polly for transient-error retries.
Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
A data pipeline is a sequence of data-processing steps that moves and transforms data between systems or stages.
- How it is used
- Organizes tabular preprocessing and repeated model training or deployment into consistent workflows.
- How deep it goes
- Distinguishes three pipeline meanings and develops feature transformations through a Vertex AI deployment workflow.
- Examples
- Uses synthetic classification, Airbnb listings, and Kuala Lumpur real-estate prediction workflows.
- What you can do after
- Apply it via Scikit-learn or Vertex AI to transform data, evaluate models, and automate training and deployment.
Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains pipeline →
Learn Docker in a Month of Lunches, Second Edition
A workflow is a declarative automation definition that specifies jobs, triggers, and execution steps for a software delivery process.
- How it is used
- Automates build, test, image promotion, and deployment checks after source changes.
- How deep it goes
- Shows a runnable job and a staged delivery process, while keeping most execution logic in scripts rather than workflow YAML.
- Examples
- Uses a PowerShell build job, staging-image workflows, and a temporary Kubernetes deployment test.
- What you can do after
- Build it from scratch with GitHub Actions YAML and reusable scripts, then verify runs and failures after pushing changes.
Read how Learn Docker in a Month of Lunches, Second Edition explains pipeline →
AI Agents in Action, Second Edition
Ingestion is the phase of preparing source documents by loading, transforming, embedding, and storing them for later retrieval.
- How it is used
- Organizes well-defined tasks into ordered agent stages or prepares documents for later retrieval through ingestion stages.
- How deep it goes
- Defines sequential agent coordination and enumerates ingestion stages, while deferring detailed ingestion implementation.
- Examples
- Uses an agent coordination pattern comparison and a PDF-to-vector-store RAG scenario.
- What you can do after
- Build it from scratch as ordered agent stages with typed outputs and deterministic checkpoints, or identify the stages of RAG ingestion.
Read how AI Agents in Action, Second Edition explains pipeline →
The Art of Code
A pipeline is a composable sequence of data-processing stages in which intermediate operations define transformations and a terminal operation executes them.
- How it is used
- Expresses stepwise data transformations declaratively, reducing control-flow noise when composition makes intent clear.
- How deep it goes
- Defines creation, lazy intermediate operations, terminal execution, consumption, exception tradeoffs, and readability refactoring without stream implementation internals.
- Examples
- Uses recent-book author extraction, file-line flattening, email sanitization, and a constrained youngest-oldest-name exercise.
- What you can do after
- Apply it via Java streams to compose lazy transformations, trigger results, and simplify overly long chains.
Designing Deep Learning Systems: A guide for software engineers
A data pipeline is an automated workflow that repeatedly acquires, transforms, labels, or otherwise moves data through processing stages.
- How it is used
- Automates continuous ingestion, processing, labeling, and dataset updates for production machine learning workflows.
- How deep it goes
- Explains stages, automation, versioning, provenance, and a containerized Pachyderm pipeline definition.
- Examples
- Demonstrates OpenCV edge extraction from an images dataset and training triggered by newly labeled images.
- What you can do after
- Operate/configure it with Pachyderm to chain containers, trigger jobs from data changes, and inspect versioned outputs.
Read how Designing Deep Learning Systems: A guide for software engineers explains pipeline →
Spring AI in Action
A workflow is an explicitly defined sequence of operations that coordinates application processing steps.
- How it is used
- Coordinates Embabel actions into goal-oriented application processing.
- How deep it goes
- Derives workflows from typed action dependencies and goal annotations, stopping short of describing the framework’s internal planning algorithm.
- Examples
- Uses board-game rules, mechanics, player counts, Java records, TikaDocumentReader, and prompt templates.
- What you can do after
- Build it from scratch by composing typed Embabel actions that load inputs and achieve analysis goals.
Go by Example
- How it is used
- Structures concurrent request processing behind a synchronous SendN API while delivering results through an iterator.
- How deep it goes
- Works through designing and integrating producer, optional throttler, and dispatcher stages, while deferring basic goroutine and channel knowledge.
- Examples
- Uses an HTTP load-testing client whose producer, throttler, and dispatcher send requests and stream Result values.
- What you can do after
- Build it from scratch by composing channel-connected stages that concurrently process requests without changing the exported API.
F# in Action: A Revised Edition of Get Programming with F#
A pipeline is a sequence of transformations in which the output of one step becomes the input of the next, applied here to HTTP requests and responses.
- How it is used
- Structures application data flow as successive transformations, including collection queries, event streams, and HTTP request/response handling.
- How deep it goes
- Explains forward-pipe syntax, curried arguments, collection stages, composability, and partial-execution debugging without implementation internals.
- Examples
- Demonstrates arithmetic chaining, customer-email processing, football-result aggregation, partial F# Interactive execution, timer events, and command-input sequences.
- What you can do after
- Apply it with F# functions and collection modules to compose readable transformations and inspect intermediate results when connections fail.
Read how F# in Action: A Revised Edition of Get Programming with F# explains pipeline →
Shipping Go: Develop, deliver, discuss, design, and go again
A software delivery pipeline is an ordered set of automated stages that processes code from a change through validation and delivery.
- How it is used
- Moves small code changes through automated feedback toward delivery, helping teams ship useful increments.
- How deep it goes
- Traces initial setup through automated checks and a produced binary, while treating individual phases as adaptable rather than prescribing a universal configuration.
- Examples
- Uses a hello API, a README milestone checklist, a Go endpoint, and a GitHub Actions binary.
- What you can do after
- Build it from scratch: establish a basic repository-to-artifact path, then extend its checks and delivery steps as needs become clearer.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains pipeline →
Platform Engineering on Kubernetes
A workflow is an organized sequence of activities and practices for accomplishing a software delivery or operational objective.
- How it is used
- Automates repeatable service-delivery tasks and organizes event processing for platform metrics.
- How deep it goes
- Explains definitions, engine-run instances, and task status, then works through Tekton resources and commands.
- Examples
- Uses a Tekton file-fetching Pipeline with task-run output and a CloudEvents-based metrics collection pipeline.
- What you can do after
- Apply it via Tekton to define and run a task sequence, then inspect its task runs and logs.
Read how Platform Engineering on Kubernetes explains pipeline →
AI-Powered Search
A pipeline is an ordered sequence of processing stages in which each stage transforms or passes information to the next stage.
- How it is used
- Organizes document preparation and query interpretation into stages that help return relevant, ranked search results.
- How deep it goes
- Defines four query phases and explains modular stages and fallbacks; illustrates executable code only for a separate Transformers pipeline.
- Examples
- Contrasts zero-result lexical search with interpreted restaurant results and traces another query through entity extraction and signals boosting.
- What you can do after
- Build it from scratch as a four-phase semantic query workflow with replaceable stages and a keyword fallback.
Learn Concurrent Programming with Go
A pipeline is a sequence of processing stages connected so that the output of one stage becomes the input of the next.
- How it is used
- Organizes dependent concurrent tasks into stages to increase throughput.
- How deep it goes
- Implements channel-connected goroutine stages and examines throughput, latency, and bottlenecks through timed pipeline runs.
- Examples
- Uses RFC URL downloading and word extraction, plus a timed cupcake-factory workflow.
- What you can do after
- Build it from scratch with Go goroutines and channels, then target the bottleneck to improve throughput.
Read how Learn Concurrent Programming with Go explains pipeline →
The Art of AI Product Development
A workflow is an ordered, often iterative sequence of tasks and operations that produces a process outcome.
- How it is used
- Organizes data preparation, model delivery, prompting, or tool-based tasks into steps aimed at a usable outcome.
- How deep it goes
- Explains several workflow patterns and their trade-offs, but does not specify a universal pipeline architecture.
- Examples
- Uses a financial-dashboard chatbot with misaligned training data and a comparison of manual versus LM-agent workflows.
- What you can do after
- Evaluate/understand where a workflow can fail upstream and which steps might benefit from chaining or automation.
Read how The Art of AI Product Development explains pipeline →
Build an AI Agent (From Scratch)
A workflow is a predefined sequence of computational steps that controls execution while delegating selected steps to language models or other components.
- How it is used
- Structures LLM tasks or agent collaboration when execution steps can be defined ahead of time.
- How deep it goes
- Defines single calls, chains, and routers, then develops sequential, parallel, loop, and nested multi-agent workflows through a shared run interface.
- Examples
- Uses document processing and a composed research, parallel-analysis, write–review, and editing pipeline.
- What you can do after
- Build it from scratch: define agent order and context handling, then compose sequential, parallel, and loop stages behind one interface.
Read how Build an AI Agent (From Scratch) explains pipeline →
Data Pipelines with Apache Airflow, Second Edition
A data workflow is an ordered set of data-processing activities and their dependencies.
- How it is used
- Coordinates dependent data-processing tasks, particularly recurring or batch-oriented work.
- How deep it goes
- Works from task boundaries and DAG-file definitions through scheduling and execution components, while leaving complex service configuration to individual pipelines.
- Examples
- Uses a rocket-launch download workflow and a handwritten-digit classifier that copies S3 data, trains with SageMaker, and deploys a model.
- What you can do after
- Build it from scratch as an Airflow DAG with ordered tasks and a schedule, then monitor its runs.
Read how Data Pipelines with Apache Airflow, Second Edition explains pipeline →
Build a Frontend Web Framework (From Scratch)
An operation sequence is an ordered collection of array-editing operations that describes a transformation from one array state to another.
- How it is used
- Plans child-node additions, removals, and moves so virtual DOM reconciliation can patch the real DOM.
- How deep it goes
- Works through a left-to-right algorithm and incremental JavaScript implementation, including current and original indices; leaves applying sequences as an exercise.
- Examples
- Uses [A, B, C] becoming [C, B, D] and a duplicate-containing array exercise to test generated operations.
- What you can do after
- Build it from scratch with arraysDiffSequence(), then verify its operations by applying them to an old array.
Read how Build a Frontend Web Framework (From Scratch) explains pipeline →
Deep Learning with R, Third Edition
A workflow is an organized sequence of modeling or training operations that provides a particular balance of usability and flexibility.
- How it is used
- Organizes model-building, training, or input preparation around the desired balance of convenience and control.
- How deep it goes
- Works through image dataset creation and introduces Dataset iteration, batching, mapping, and fitting; also outlines a multistage text pipeline.
- Examples
- Uses class-labeled JPEG directories and text shards prepared for Transformer pretraining.
- What you can do after
- Apply it via image_dataset_from_directory() and tf.data.Dataset transformations to prepare batches for Keras fit().
Read how Deep Learning with R, Third Edition explains pipeline →
Functional Programming in JavaScript
A Ramda function that composes functions from left to right into a new function.
- How it is used
- Connects functional transformations into reusable sequences instead of confining operations to one object’s methods.
- How deep it goes
- Explains inputs, outputs, type mappings, and coupling, but stops short of implementing a general pipeline utility.
- Examples
- Uses string transformations, an isEmpty function, and a Lodash array chain involving filter, map, uniq, and sort.
- What you can do after
- Apply it by arranging functions whose outputs match the next functions’ inputs, including functions from different libraries.
Read how Functional Programming in JavaScript explains pipeline →
Data Analysis with LLMs
A data-processing pipeline is an ordered sequence of computational stages that transform or analyze data, with each stage passing results to the next.
- How it is used
- Organizes multistep language-model applications by passing data through connected processing components.
- How deep it goes
- Works through a three-component classification chain and its CSV application, while deferring parallel and conditional execution.
- Examples
- Uses sentiment classification from a CSV file, speech translation, and indexed-data question answering.
- What you can do after
- Apply it via LangChain to classify a batch of input texts and save the labels alongside CSV data.
Build Applications with Local AI Models on a Mac
A sequence of processing stages in which each stage feeds its output to the next.
- How it is used
- Connects successive processing stages into a voice assistant and, separately, into chains and custom-model workflows.
- How deep it goes
- Works through stage handoffs, a temporary-file bridge, and separate startup checks; leaves branching multistep chains for later exploration.
- Examples
- Uses a voice chatbot, a prompt-to-LLM-to-parser chain, and a fine-tuned model exported to Ollama.
- What you can do after
- Build it from scratch as a local voice chatbot, then diagnose failures by testing its prerequisites separately.
Read how Build Applications with Local AI Models on a Mac explains pipeline →
Effective Data Analysis
A data pipeline is an automated sequence of processing steps that retrieves, transforms, and delivers data between systems.
- How it is used
- Supports repeatable retrieval, transformation, and warehouse delivery while helping stakeholders choose between automation and manual collection.
- How deep it goes
- Compares connectors, custom workflows, manual uploads, and scraping, but stops short of detailed implementation code or orchestration design.
- Examples
- Uses weather retrieval, weekly source refreshes, survey spreadsheets, static census data, and scraped HTML as pipeline cases.
- What you can do after
- Evaluate and recommend retrieval approaches, then select connector, custom workflow, manual upload, or scraping strategies for warehouse use.
Deep Learning with Python, Third Edition
A supported way of using Keras that combines model-building and training choices for a particular level of flexibility.
- How it is used
- Connects data loading, preprocessing, batching, model training, and evaluation while scaling from convenient APIs to custom workflows.
- How deep it goes
- Explains file decoding, tensor conversion, resizing, batching, iteration, mapping, parallelization, prefetching, and direct fit() integration.
- Examples
- Uses directory-based cat-and-dog image classification, NumPy arrays, batching, mapped reshaping, augmentation, metric curves, and test evaluation.
- What you can do after
- Apply it via Keras utilities and Dataset operations to prepare inputs, train models, inspect metrics, and evaluate saved checkpoints.
Read how Deep Learning with Python, Third Edition explains pipeline →
Kafka Streams in Action, Second Edition
Pipelining is a processing pattern that overlaps record retrieval and record processing so the consumer can continue retrieving batches while earlier batches are handled.
- How it is used
- Overlaps high-volume Kafka consumption with slow asynchronous record processing to help a consumer stay caught up.
- How deep it goes
- Explains the consumer loop, partition offset calculation, and commit timing, while omitting the complete processor implementation.
- Examples
- Uses Java consumer and processor listings that poll batches, process partition records, queue offsets, and commit synchronously.
- What you can do after
- Implement pipelined Kafka consumption with manual commits that acknowledge only successfully processed records.
Read how Kafka Streams in Action, Second Edition explains pipeline →
Practical Automation with PowerShell: Effective scripting from the console to the cloud
A PowerShell pipeline passes output objects from one command as input to subsequent commands or functions.
- How it is used
- Chains operational cmdlets for archival, bulk server updates, and disk provisioning.
- How deep it goes
- Explains pipeline tradeoffs and function lifecycle blocks, while deferring broader pipeline internals.
- Examples
- Demonstrates file archiving, VMware cluster server updates, and raw-disk initialization.
- What you can do after
- Apply it via PowerShell cmdlets and functions to process collections without repeated queries.
C++ Concurrency in Action, Second Edition
A pipeline is a processing pattern in which work passes through a sequence of stages.
- How it is used
- Processes repeated sequences of operations across independent items by assigning work to stages.
- How deep it goes
- Explains stage threads and queue handoffs, then motivates the performance tradeoff without detailing synchronization implementation.
- Examples
- Uses network arrivals, filesystem scanning, and a 20-item workload to illustrate pipeline use and performance comparison.
- What you can do after
- Apply a pipeline by assigning operations to threads and passing completed items through queues.
Read how C++ Concurrency in Action, Second Edition explains pipeline →
Introduction to Generative AI, Second Edition
A data pipeline is a sequence of processes that collects, transforms, transports, and prepares data for downstream use.
- How it is used
- Uses linked prompts to divide a larger task into steps, especially in enterprise applications, RAG workflows, and tool-augmented assistants.
- How deep it goes
- Defines prompt chaining and explains its modular benefits with an example, without detailing implementation.
- Examples
- Illustrates chaining by extracting relevant document quotes before generating an answer.
- What you can do after
- Understand how to divide a task across prompts so one step’s output informs the next.
Read how Introduction to Generative AI, Second Edition explains pipeline →
Starting Data Analytics with Generative AI and Python
A data pipeline is a sequence of processes that moves and transforms data between sources, storage, and analytical stages.
- How it is used
- Frames data analysis as a decision-support process rather than a simple transformation of raw data into charts.
- How deep it goes
- Defines collection, cleaning, processing, and presentation, but defers detailed methods for each stage.
- Examples
- Uses retail, healthcare, and manufacturing examples with distinct data sources and analytical goals.
- What you can do after
- Apply a staged workflow that collects, prepares, analyzes, and presents data for a defined business question.
Read how Starting Data Analytics with Generative AI and Python explains pipeline →
Microsoft Azure in Action
A pipeline is an ordered sequence of processing stages that moves data or executes computational tasks.
- How it is used
- Moves command results or AI data through successive processing stages for inspection, ingestion, labeling, training, and deployment.
- How deep it goes
- Explains PowerShell chaining and AI data connections, but stops short of detailing complete end-to-end solution development.
- Examples
- Uses Get-AzStorageBlob piped to select Name and nightly review files flowing from Blob Storage into AI workflows.
- What you can do after
- Apply it via PowerShell pipelines or configure AI Foundry storage connections, permissions, and downstream data-processing steps.
Deep Learning with PyTorch, Second Edition
- How it is used
- Packages image-generation components into an inpainting workflow and splits model computation across devices for training.
- How deep it goes
- Shows component bundling and staged execution, but focuses on invoking rather than reimplementing the inpainting pipeline.
- Examples
- Uses horse-to-zebra inpainting, GPipe microbatch execution, earlier rule-based NLP processing, and a proposed segmentation-classification workflow.
- What you can do after
- Apply it via Diffusers to inpaint a masked image, or configure PyTorch pipeline parallelism with model splits and a GPipe schedule.
Read how Deep Learning with PyTorch, Second Edition explains pipeline →
Quarkus in Action
A reactive pipeline is a composition of asynchronous processing stages connected so that results, completion, and failures flow between them.
- How it is used
- Uses asynchronous continuations to connect processing stages in Quarkus applications and reactive services.
- How deep it goes
- Explains stage execution, event flow, subscription, and fluent construction, but does not detail internal implementation.
- Examples
- Demonstrates a Mutiny Multi that transforms, observes, filters, completes, and delivers selected strings to a subscriber.
- What you can do after
- Build reactive pipelines with Mutiny's Uni and Multi fluent APIs, then trigger them through subscription.
Go in Practice, Second Edition
A template pipeline is a Go template construct that sequences commands and supports value processing and control logic.
- How it is used
- Formats template data and expresses iteration or conditional presentation logic without moving display concerns into application code.
- How deep it goes
- Explains chaining, final-argument passing, custom-function registration, and range scope, but stops short of broader template internals.
- Examples
- Uses date formatting, quoted printf output, transformed links, and comment iteration with current and outer-scope values.
- What you can do after
- Apply it via html/template to chain built-in commands and registered Go functions while formatting or controlling rendered output.
Learn Go with Pocket-Sized Projects
A template pipeline is a sequence of template commands in which each command's output becomes input to the next command.
- How it is used
- Sequences template actions when one action’s output must become the next action’s input.
- How deep it goes
- Defines pipe-based composition and demonstrates function registration, but stops short of deeper execution internals.
- Examples
- Uses URL hostname extraction, lowercase normalization, println output, and a slice of example URLs.
- What you can do after
- Apply it in Go templates by registering functions with Funcs and chaining their outputs with |.
Read how Learn Go with Pocket-Sized Projects explains pipeline →
Spring in Action, Sixth Edition
A pipeline is a sequence of processing components through which data or messages flow from an input toward an output.
- How it is used
- Connects external systems or reactive transformations by moving messages and data through ordered processing components.
- How deep it goes
- Defines pipeline flow and contrasts imperative and reactive execution, but defers detailed operator behavior and configuration.
- Examples
- Uses a name-to-greeting transformation with uppercase conversion, mapping, subscription, and printing.
- What you can do after
- Build it from scratch using Spring configuration or Reactor operators to connect processing stages into a data flow.
Read how Spring in Action, Sixth Edition explains pipeline →
Rust in Action: Systems programming concepts and techniques
A pipeline is a sequence of processing stages in which each stage transforms data for the next stage.
- How it is used
- Uses staged transformations to turn input into an SVG file while keeping each processing responsibility separate.
- How deep it goes
- Explains four stages and their data flow, then shows orchestration in main(); it stops short of general pipeline abstractions.
- Examples
- Uses render-hex, hexadecimal operations, a virtual pen, SVG path commands, and a saved SVG document as concrete artifacts.
- What you can do after
- Build it from scratch by organizing a Rust program into parsing, conversion, document generation, and file-saving stages.
Read how Rust in Action: Systems programming concepts and techniques explains pipeline →
Grokking Concurrency
Pipeline processing is a technique that divides computation into stages so different stages can operate concurrently on different portions of the work.
- How it is used
- Uses staged task decomposition to structure concurrent applications and overlap work across workers or cores.
- How deep it goes
- Explains consecutive stages, worker handoffs, resource overlap, and a Python implementation while deferring detailed execution mechanics.
- Examples
- Demonstrates laundry stages, CPU instruction stages, and a Python washer-dryer-folder program.
- What you can do after
- Apply via Python threads and queues to divide staged work and observe overlapping processing.
Data for All
A data pipeline is an automated or structured sequence that moves and processes data between sources and destinations.
- How it is used
- Supports firms’ analytics operations by supplying data to models and operational engines that predict and influence behavior.
- How deep it goes
- Explains dependence on data and disruption from external change, but stops short of implementation details.
- Examples
- Uses the COVID pandemic, social media, news, shopping, and buy-now-pay-later services as examples of pipeline dependence.
- What you can do after
- Evaluate how changing or withholding data can disrupt predictions and alter companies’ targeting and engagement.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A workflow is an ordered sequence of activities through which work progresses toward a result.
- How it is used
- Moves code toward production and helps teams inspect business or customer flows for bottlenecks, frustration, and missed outcomes.
- How deep it goes
- Explains automated delivery steps, environment provisioning, lead-time measurement, and workflow mapping without detailing implementation mechanics.
- Examples
- Uses commit-to-production delivery, automated environments, customer funnels, subscription cancellation, and support-agent handoffs as examples.
- What you can do after
- Operate delivery pipelines, measure change lead time, and diagnose workflow friction by mapping steps, handoffs, and dropout points.
Graph Neural Networks in Action
A data pipeline is a sequence of processes that moves data from an input state through transformation and preparation stages to an output suitable for storage or computation.
- How it is used
- Moves raw graph data toward a preprocessed dataset suitable for GNN processing and training.
- How deep it goes
- Defines representations and outlines exploration, conversion, preprocessing, and splitting while leaving implementation details problem-dependent.
- Examples
- Uses edge lists, adjacency matrices, NetworkX graph objects, PyG data objects, masks, and graph visualizations as concrete artifacts.
- What you can do after
- Apply it via NetworkX and PyG to explore, convert, preprocess, and split graph data for GNN use.
Read how Graph Neural Networks in Action explains pipeline →
Related concepts
- PowerShellused by · PowerShell is Microsoft's cross-platform command shell and scripting language for administering computer systems and automating tasks.
- SMOTEuses · SMOTE is an oversampling technique that generates synthetic examples for a minority class by interpolating between existing minority-class examples and their nearest neighbors.
- fluent interfaceused by · A fluent interface is an API design style in which operations return objects or values that enable readable chaining of subsequent calls.
- data layerpart of · A data layer is an architectural part of a system that organizes access to, management of, or persistence of data for other components.
- remove operationhas part · A remove operation represents deleting an item from the working array because it is absent from the target array at the relevant position.
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.