liveBook · Manning

Validation

Validation is the process of checking data, behavior, or results against defined criteria to determine their correctness, acceptability, or suitability for a purpose.

How 32 Manning books explain it

Machine Learning Platform Engineering

Model validation is the process of evaluating a trained machine learning model on data or tests intended to estimate its performance and suitability.

How it is used
Places model checks between training and deployment decisions within reproducible ML pipelines.
How deep it goes
Works through a KFP component that runs YOLO validation and logs metrics; leaves custom validation logic open to evolving requirements.
Examples
Uses YOLO object-detection metric logging, PVC-mounted model weights, and a movie-recommender training workflow.
What you can do after
Build it from scratch as a KFP validation component that loads a trained YOLO model and records validation metrics.

Read how Machine Learning Platform Engineering explains validation →

ASP.NET Core in Action, 3e

Validation is the application framework process that checks model data against rules to determine whether it is acceptable.

How it is used
Validates user-supplied request data before application code uses it for domain or infrastructure operations.
How deep it goes
Explains validation timing, failure handling, filters, custom attributes, and alternative validator classes with implementation examples.
Examples
Uses a checkout form, a user endpoint, and currency conversion rules to demonstrate validation.
What you can do after
Apply validation using DataAnnotations and MinimalApis.Extensions, handle Razor Pages errors, and define FluentValidation rules.

Read how ASP.NET Core in Action, 3e explains validation →

Pro ASP.NET Core 7, Tenth Edition

Validation is the process of checking data against rules to determine whether it is acceptable for processing.

How it is used
Checks submitted form and API data before actions use it or store it, while providing feedback when it fails.
How deep it goes
Works through attribute rules, ModelState branching, error display, and API responses; identifies custom and client-side validation without detailing their implementations.
Examples
Uses an RSVP form, a product API POST, and a database-backed product create form.
What you can do after
Build it from scratch with validation attributes, ModelState checks, form feedback, and a bad-request response for invalid API input.

Read how Pro ASP.NET Core 7, Tenth Edition explains validation →

Build AI-Enhanced Web Apps

Validation is the checking of input against permitted formats, values, or constraints before it is accepted or processed.

How it is used
Uses validation to control incoming requests and check generated responses in AI web applications.
How deep it goes
Explains threat modeling and client-versus-server checks, with schema parsing and output-constraint tests.
Examples
Checks prompt length with Zod, tests generated text for word counts and keywords, and validates document upload types and sizes.
What you can do after
Apply it via Zod to parse incoming prompts and use constraint checks to test generated text.

Read how Build AI-Enhanced Web Apps explains validation →

The Art of AI Product Development

Data validation is the process of checking data for correctness, consistency, completeness, and conformity to specified conditions.

How it is used
Checks training data, model inputs, and generated outputs to protect reliability and trust in AI products.
How deep it goes
Offers practical checks and monitoring measures, and identifies post-generation schema validation without detailing its implementation.
Examples
Uses irrelevant customer recommendations, manipulative prompts, and Pydantic schema checks as examples.
What you can do after
Apply validation checks to incoming data, model inputs, and generated structures, alongside production monitoring.

Read how The Art of AI Product Development explains validation →

Pro Angular 16

Data validation is the process of checking input data against specified rules for correctness, completeness, or acceptability.

How it is used
Checks product and checkout form input before accepting a product or saving an order.
How deep it goes
Works through field rules, status, error messages, whole-form checks, summaries, and reset; identifies custom rules without implementing them here.
Examples
Uses a product-entry form with name, category, and price fields, plus an order checkout form.
What you can do after
Apply it via Angular forms to reject invalid submissions and show field-level or form-wide feedback.

Read how Pro Angular 16 explains validation →

Machine Learning System Design

A procedure for partitioning or otherwise structuring data and evaluation conditions to estimate a machine learning system's performance under expected operating conditions.

How it is used
Estimates unseen-data performance under expected operating conditions and supports model and feature selection.
How deep it goes
Develops schema-selection criteria and worked evaluation designs, including nested rolling validation and stable user-group splits.
Examples
Uses retail demand forecasting and search query evaluation to illustrate time-based and user-grouped splits.
What you can do after
Apply validation schemas to estimate performance and select a split that reflects production conditions.

Read how Machine Learning System Design explains validation →

Build Financial Software with Generative AI (From Scratch)

Validation is the process of checking data or inputs against defined correctness and acceptance rules.

How it is used
Uses validation to protect incoming API data and check ACH records and generated payment files.
How deep it goes
Works through field constraints, database-backed checks, error responses, and tests, while initially deferring rejected-file recovery.
Examples
Uses ACH routing numbers, file ID patterns, entry counts, and Base64 image prefixes as validation examples.
What you can do after
Apply validation via Pydantic field constraints and validators, and test accepted and rejected API inputs.

Read how Build Financial Software with Generative AI (From Scratch) explains validation →

Django in Action

Validation is the process of checking whether a value satisfies specified correctness or format constraints.

How it is used
Uses field and form checks to keep invalid values from entering application processing.
How deep it goes
Explains field-based checks, is_valid(), cleaned_data, error redisplay, and redirects without detailing validation internals.
Examples
Demonstrates EmailField format checking and a RiffMates comment form handled by one GET-and-POST view.
What you can do after
Apply it via Django forms to accept valid submissions, redisplay invalid input with errors, and redirect after success.

Read how Django in Action explains validation →

Learn Go with Pocket-Sized Projects

Input validation is the process of checking submitted data against required formats, types, and value constraints before processing it.

How it is used
Protects domain entities, API boundaries, HTTP handlers, and table-driven tests from invalid or incorrectly asserted data.
How deep it goes
Works through normalization, rejection, defaults, typed errors, transport mapping, parsing, and focused tests; it stops short of a validation library implementation.
Examples
Uses money conversion tests, habit creation, whitespace-only names, missing defaults, gRPC status codes, and HTTP form parsing.
What you can do after
Build it from scratch by validating domain entities, returning typed errors, testing outcomes, and mapping failures at HTTP or gRPC boundaries.

Read how Learn Go with Pocket-Sized Projects explains validation →

Kafka for Architects

Message validation is the checking of a message's structure and content against required validity rules before it is accepted or processed.

How it is used
Protects event-driven consumers by checking message conformance before publication and planning for invalid messages that still reach topics.
How deep it goes
Explains the client-side validation flow, broker limitation, and consumer failure paths without a low-level implementation walkthrough.
Examples
Uses schema-ID retrieval and a missing-field message that repeatedly fails deserialization until the consumer handles or bypasses it.
What you can do after
Diagnose/debug with it when invalid messages disrupt consumers, and establish handling policies for dead-letter topics and offset recovery.

Read how Kafka for Architects explains validation →

Starting Data Analytics with Generative AI and Python

Validation is the process of checking whether an analytical or model-generated result is accurate, relevant, plausible, and fit for its intended purpose.

How it is used
Uses checks to protect data quality and assess whether AI-generated results support responsible analytical or business decisions.
How deep it goes
Provides procedural steps, test-case guidance, and reporting requirements without developing formal statistical validation theory.
Examples
Uses malformed dates, cross-table foreign-key violations, and AI-generated financial-product pricing code with edge-case tests.
What you can do after
Diagnose data and model-output problems through constraints, sanity checks, expert review, test cases, and documented verification.

Read how Starting Data Analytics with Generative AI and Python explains validation →

Learn Haskell by Example

Validation is the process of checking data against specified conditions to determine whether it is acceptable or well-formed.

How it is used
Transforms untrusted parsed PNM data into image data only after format, size, and color constraints pass.
How deep it goes
Works through per-pixel conversion, bounds checks, helper predicates, and top-level error propagation with Either and mapM.
Examples
Uses bitmap, graymap, and RGB pixmap pixels, including invalid constructors and values exceeding a maximum.
What you can do after
Apply it via JuicyPixels pixel types to reject malformed PNM parse results before later image processing.

Read how Learn Haskell by Example explains validation →

ScyllaDB in Action

Data validation is the process of checking that migrated data is complete and accurate relative to its source.

How it is used
Uses dual-reading to verify that a live migration remains invisible to upstream applications.
How deep it goes
Defines completeness and correctness, then details comparisons, retries, logging, and mismatch classification.
Examples
Uses source-versus-destination reads and millisecond-versus-microsecond timestamps to classify mismatches.
What you can do after
Diagnose migration mismatches by comparing dual-reads, retrying transient differences, and investigating persistent ones.

Read how ScyllaDB in Action explains validation →

Generative AI in Action

Validation is the process of checking generated software or content against functional, quality, security, and compliance requirements.

How it is used
Applies checks to generated outputs, data pipelines, and deployed models to support enterprise quality and safety.
How deep it goes
Provides review checklists and security safeguards, with an illustrative SQL injection scenario rather than a validation implementation.
Examples
Illustrates insecure output handling with a generated SQL query containing a table-deletion command.
What you can do after
Practice reviewing generated code and identifying checks and safeguards for generated SQL before production use.

Read how Generative AI in Action explains validation →

Classic Computer Science Problems in Swift: Essential techniques for practicing programmers

Validation is the evaluation of a trained model on examples held apart from the data used to adjust its parameters.

How it is used
Evaluates classification networks on samples excluded from parameter training.
How deep it goes
Demonstrates dataset splitting, repeated training, output interpretation, and accuracy reporting without explaining validation internals.
Examples
Uses iris and wine datasets with held-out subsets, interpreted class outputs, and reported correct counts and percentages.
What you can do after
Evaluate a trained Swift neural network with validate and quantify classification accuracy on held-out samples.

Read how Classic Computer Science Problems in Swift: Essential techniques for practicing programmers explains validation →

F# in Action: A Revised Edition of Get Programming with F#

Validation is the process of checking data against rules that determine whether it is acceptable for a domain or operation.

How it is used
Checks external data before converting it into domain values or handling a web request.
How deep it goes
Works through Result-based field checks and a raw-to-domain conversion, then outlines web response handling; it does not develop an all-errors implementation.
Examples
Uses customer IDs and countries, JSON guitar inventory, and raw web-request records to illustrate validation.
What you can do after
Build it from scratch with F# functions returning Result, or apply common checks via Validus.

Read how F# in Action: A Revised Edition of Get Programming with F# explains validation →

Coding with AI

Validation is the checking of input or application state against expected rules and constraints.

How it is used
Applies validation to user input, application behavior, and AI-generated code before accepting results.
How deep it goes
Demonstrates requirements checks, form handling, error cases, testing, and human review, but does not detail validation implementation internals.
Examples
Uses a Flask quiz form, stored answers, question navigation, database testing, and review of an overengineered SQLAlchemy proposal.
What you can do after
Diagnose missing inputs, implementation failures, and unsuitable AI suggestions before deploying or adopting them.

Read how Coding with AI explains validation →

100 C++ Mistakes and How to Avoid Them

Validation is the checking of supplied data against rules that determine whether it is acceptable for an operation or object state.

How it is used
Enforces class invariants by checking constructor data and mutator inputs before they establish or change object state.
How deep it goes
Works through range checks, exception behavior, and shared helpers, while distinguishing validation from the separate decision to allow mutation.
Examples
Uses a Circle with a nonnegative radius and a Person with nonempty names and nonnegative ages.
What you can do after
Apply it by validating values before assignment and throwing when invalid input would violate the class invariant.

Read how 100 C++ Mistakes and How to Avoid Them explains validation →

The Well-Grounded Python Developer: How the pros use Python and Flask

Validation is the process of checking input data against required presence, format, and value constraints.

How it is used
Protects authentication, registration, and comment-submission workflows from missing, malformed, or unacceptable input.
How deep it goes
Explains field validators, custom database-backed checks, error display, and conditional persistence without cataloging broader validation strategies.
Examples
Uses login, new-user registration, duplicate-email detection, and hierarchical comment creation as concrete validation scenarios.
What you can do after
Apply it via Flask-WTF validators and validate_on_submit() before rendering errors or committing accepted records.

Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains validation →

Grokking Machine Learning

A model-development procedure that evaluates candidate models or settings on held-out data without using the final test data for those decisions.

How it is used
Uses held-out validation data to choose models or settings while reserving the test set for a final check.
How deep it goes
Separates data into training, validation, and testing roles, gives common split ratios, and defers further procedural detail.
Examples
Compares polynomial regression models of degrees 1, 2, and 10, and gives 60-20-20 and 80-10-10 dataset splits.
What you can do after
Apply the three-way split to choose a model with validation data and reserve the test data for final evaluation.

Read how Grokking Machine Learning explains validation →

Build an AI Agent (From Scratch)

Data validation is the process of checking data against specified structural, type, and constraint requirements.

How it is used
Uses validation to reject invalid tool inputs and check agent outputs against explicit requirements.
How deep it goes
Explains schema constraints and error-handling practices without implementing a complete validator.
Examples
Uses a restaurant reservation schema, a light-control enum, and JSON output checks to illustrate constraints.
What you can do after
Apply validation by specifying tool input constraints and using code-based checks for precise output requirements.

Read how Build an AI Agent (From Scratch) explains validation →

100 SQL Server Mistakes and How to Avoid Them

Input validation is the process of checking supplied data against allowed formats, values, or constraints before processing it.

How it is used
Protects web-login queries by checking or safely handling user-supplied values before database processing.
How deep it goes
Demonstrates the vulnerability and injection result, then stops short of defining a validation checklist or validation rules.
Examples
Uses a C# Web Forms login, a Users table, a normal credential query, and the payload ' OR 1=1--.
What you can do after
Apply it by replacing concatenated login input with stored-procedure parameters and testing an injection payload.

Read how 100 SQL Server Mistakes and How to Avoid Them explains validation →

Functional Design and Architecture: Examples in Haskell

Validation is the systematic checking of input or data against rules before it is accepted for further processing.

How it is used
Protects web-service business logic by rejecting invalid requests at the API boundary.
How deep it goes
Descends from immediate handler failures to applicative, nested, path-aware validation, without detailing library internals.
Examples
Uses nonempty request fields, pointed validators, nested structures, and path-specific validation errors.
What you can do after
Apply it via Haskell handlers and applicative validators to reject bad requests and report nested failures.

Read how Functional Design and Architecture: Examples in Haskell explains validation →

Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu

Validation is the process of checking configuration inputs against required formats, values, or dependencies before processing them.

How it is used
Catches Terraform input and provider-configuration errors before they lead to misconfiguration or client creation.
How deep it goes
Explains variable conditions and error messages, then gives a provider procedure for collecting diagnostics before returning.
Examples
Uses integer-range checks, an instance-count input, and an unknown provider host to show distinct failures.
What you can do after
Apply it via Terraform validation blocks and provider diagnostics to report actionable input errors before using configuration values.

Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains validation →

Simple Object-Oriented Design: Create clean, maintainable applications

A validation mechanism checks requested values or state changes against validity constraints.

How it is used
Protects objects and client-facing operations from invalid data and state changes.
How deep it goes
Explains ownership, service extraction, setter design, and two validation approaches, but does not detail their implementations.
Examples
Uses training-course offerings, participant limits, enrollment, database-dependent checks, and protected versus unprotected baskets.
What you can do after
Apply validation by placing local checks in entities and complex business checks in services or dedicated validation classes.

Read how Simple Object-Oriented Design: Create clean, maintainable applications explains validation →

Building Web APIs with ASP.NET Core

Data validation is the process of checking incoming data for validity, accuracy, meaningfulness, and security before processing it.

How it is used
Protects web API endpoints by checking incoming HTTP data before controller processing.
How deep it goes
Explains model binding, annotations, ModelState, cross-validation, and automatic versus manual processing.
Examples
Uses invalid pageIndex input and a DomainDTO rule requiring an allowed Id or Name.
What you can do after
Apply it via ASP.NET Core model binding, validation attributes, IValidatableObject, and ModelState handling.

Read how Building Web APIs with ASP.NET Core explains validation →

Go in Action, Second Edition

Validation is the process of checking that input data satisfies required structural, type, and semantic constraints.

How it is used
Validates JSON configurations, template-specific schemas, command-line values, environment values, and file-based settings before application use.
How deep it goes
Descends from parsing and type checks to range checks and custom URL validation through UnmarshalJSON.
Examples
Uses configuration JSON, template dispatch, Host URL checks, bounded port parsing, Boolean parsing, and formatted configuration values.
What you can do after
Builds validation from scratch with encoding/json, custom UnmarshalJSON methods, and strconv parsing functions.

Read how Go in Action, Second Edition explains validation →

AI Agents in Action, Second Edition

Output validation is the process of checking generated or returned data against defined conditions before it is accepted or delivered.

How it is used
Checks agent inputs, outputs, and tool results before they are accepted or used in further actions.
How deep it goes
Demonstrates string and length checks with tripwires, while allowing more complex logic without detailing it.
Examples
Uses a forbidden research title, string comparisons, length checks, and a typed research output model.
What you can do after
Apply guardrails to check agent inputs and outputs, trigger failures, and validate tool results before further actions.

Read how AI Agents in Action, Second Edition explains validation →

Rust Servers, Services, and Apps

Input validation is the process of checking supplied data against format, length, type, or business constraints before processing it.

How it is used
Checks registration and sign-in form data before processing and guides users when entries are invalid.
How deep it goes
Distinguishes simple browser checks from complex handler checks, without detailing their implementation.
Examples
Uses tutor registration fields, sign-in credentials, field-length checks, and username availability as examples.
What you can do after
Apply basic checks in HTML and complex checks in handlers, then return invalid forms with suitable feedback.

Read how Rust Servers, Services, and Apps explains validation →

.NET MAUI in Action

Validation is the process of checking user-provided data against validity rules and informing the user when the data is invalid.

How it is used
Improves UI usability by checking entered data, communicating failures, and stopping invalid form submission.
How deep it goes
Explains validation rules, feedback, and implementation choices, but stops short of detailed bindable-property implementation.
Examples
Uses a stock-count stepper, nonnegative range checks, warning labels, approved lists, and email-address checks.
What you can do after
Apply validation through warning labels, control-state checks, or .NET MAUI Community Toolkit behaviors.

Read how .NET MAUI in Action explains validation →

AI for Everyday IT

Validation is the process of checking an input or result against correctness, safety, or other defined requirements.

How it is used
Checks generated SQL for correctness, performance problems, and security risks before execution.
How deep it goes
Describes a query-checking workflow and safeguards, but does not detail their implementation.
Examples
Uses a 1996 order-count query and recommends adversarial tests for forbidden data access or dangerous commands.
What you can do after
Apply validation by checking generated SQL before running it and using strict types, whitelists, and parameterized queries.

Read how AI for Everyday IT explains validation →

Related concepts

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.