liveBook · Manning

Versioning

Also called version control

Versioning is the practice of assigning or maintaining identifiable revisions of artifacts over time so their changes, histories, or compatibility can be tracked.

How 36 Manning books explain it

Automating API Delivery

A version control system is software that records changes to files over time and supports version history, collaboration, and restoration of earlier versions.

How it is used
Supports collaborative API design, governed pull-request review, and CI/CD automation through versioned API files.
How deep it goes
Defines revision tracking and details repository and review practices, but does not teach Git commands or internals.
Examples
Uses API definitions, guide documentation, conformance tests, gateway configuration, and a hypothetical DEV-XXXX pull-request policy.
What you can do after
Apply it via Git to make API definitions and configurations reviewable, versioned inputs to an APIOps workflow.

Read how Automating API Delivery explains versioning →

Machine Learning Platform Engineering

The systematic recording and management of changes to files, code, or other managed artifacts over time.

How it is used
Connects changing data, code, configurations, and deployed models to reproducible training and traceable releases.
How deep it goes
Explains lineage and operational uses, including dataset correction and rollback, but does not specify versioning commands or a data-versioning tool.
Examples
Uses a versioned ETL pipeline for a car-price dataset and MLflow experiment and model tracking for a movie recommender.
What you can do after
Operate/configure it by linking model releases to dataset versions, logging transitions, and retaining earlier models for rollback.

Read how Machine Learning Platform Engineering explains versioning →

Java Persistence with Spring Data and Hibernate epub

Entity versioning associates persistent data with a version value that changes when it is updated, enabling concurrent modifications to be detected.

How it is used
Uses versioning to detect concurrent entity modifications and, separately, to retain historical data for auditing.
How deep it goes
Explains version mapping, flush-time checks and explicit lock modes, and outlines revision storage and historical queries with Envers.
Examples
Uses a conflicting Item update, an optimistic query lock, a forced version increment and historical Item queries.
What you can do after
Apply it via JPA and Hibernate to detect conflicting updates and use Envers to retain and query revisions.

Read how Java Persistence with Spring Data and Hibernate epub explains versioning →

Software Engineering for Data Scientists

Version control software is software that records and manages successive versions of source code and coordinates changes among contributors.

How it is used
Supports shared data-science codebases by tracking changes, coordinating contributors, and preserving experiments.
How deep it goes
Defines repositories and local-to-remote workflows, then introduces commits, pushes, pulls, branches, conflicts, and notebook comparison.
Examples
Uses a customer-churn project where collaborators alter extraction, visualization, cleaning, utility, and model code.
What you can do after
Operate/configure it by maintaining a repository, committing descriptive changes, synchronizing updates, and following a branch policy.

Read how Software Engineering for Data Scientists explains versioning →

Designing Deep Learning Systems: A guide for software engineers

The practice of recording and retrieving distinct versions of data, code, configurations, or other artifacts over time.

How it is used
Supports reproducible deep learning development by separating training-data collection from downstream data consumption.
How deep it goes
Explains version tracking through enterprise workflow complexity, schema contracts, and dataset-management architecture without detailing storage or command interfaces.
Examples
Uses data collection, preprocessing, training, evaluation, and strongly typed schemas as workflow examples.
What you can do after
Apply version tracking to training datasets to support reproducible model development and coordinated team workflows.

Read how Designing Deep Learning Systems: A guide for software engineers explains versioning →

Building Web APIs with ASP.NET Core

Source control is a system for tracking, versioning, and managing changes to files such as source code.

How it is used
Keeps older API behavior available while clients transition after breaking changes.
How deep it goes
Works through ASP.NET Core service, controller, DTO, and Swagger configuration; weighs maintenance and security costs.
Examples
Uses a board-game DTO property rename and a version 3 query-parameter exercise.
What you can do after
Build it from scratch in ASP.NET Core with versioned routes, controllers, and Swagger documentation.

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

Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform

Version control is the practice and supporting system for recording, comparing, and managing successive versions of files and configuration.

How it is used
Uses commits to document, reproduce, review, test, and coordinate infrastructure changes.
How deep it goes
Explains commit rationale, ticket traceability, secrets, reproducibility, branching trade-offs, and automated testing, but not version-control fundamentals.
Examples
Demonstrates firewall and network changes, descriptive Git commits, ticket-prefixed commits, feature branches, and trunk-based workflows.
What you can do after
Apply it to document infrastructure intent, reproduce environments, trace requests, review changes, and choose a branching workflow.

Read how Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform explains versioning →

Machine Learning System Design

Model versioning is the practice of assigning and managing distinct identifiers for machine learning model revisions.

How it is used
Supports predictable ML integration by distinguishing model revisions and allowing callers to request a specific version.
How deep it goes
Explains compatibility risks and feature-version metadata, while deferring advanced model registry solutions.
Examples
Uses a version-selecting model initializer, changed feature calculations, and a Python update that altered outputs.
What you can do after
Operate/configure model version selection and record feature versions to support reproducibility and compatibility.

Read how Machine Learning System Design explains versioning →

100 SQL Server Mistakes and How to Avoid Them

A version control system records successive versions of files and supports collaboration, comparison, and recovery of earlier states.

How it is used
Replaces development-server backups with a shared, recoverable home for database code and deployment inputs.
How deep it goes
Explains repository setup, branches, parallel edits, conflicts, commits, history, and rollback without detailing Git commands or merge resolution.
Examples
Uses MagicChoc’s backup-dependent development server and manual deployment scripts to contrast with a Git repository workflow.
What you can do after
Operate/configure it by creating a Git repository, branching work, committing changes, and merging approved code for automated delivery.

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

Effective Platform Engineering

Software versioning is the practice of assigning identifiable versions to software artifacts and managing changes between them.

How it is used
Provides source code version control for platform bootstrap and versions shared pipeline libraries for lower-friction releases.
How deep it goes
Defines versioning as a software practice and explains release adaptation, but leaves version-control commands and workflows unspecified.
Examples
Uses source code version control in the platform foundation and versioned CircleCI orbs as reusable pipeline assets.
What you can do after
Operate/configure shared pipeline resources with versioned releases that give developers time to understand and adapt to changes.

Read how Effective Platform Engineering explains versioning →

AI Model Evaluation

Versioning is the practice of recording distinct revisions of data, models, code, prompts, metrics, and configuration so that changes can be identified and reproduced.

How it is used
Supports repeatable offline evaluations and traceable LLM-judge results as inputs and configurations change.
How deep it goes
Provides a component checklist and prompt-tracking practices, without specifying a complete version-control implementation.
Examples
Uses prompt edits, timestamped revisions, response schemas, and fixed-prompt canary runs to illustrate traceability.
What you can do after
Diagnose/debug evaluation changes by tracing prompt versions and comparing fixed-prompt results with a stored baseline.

Read how AI Model Evaluation explains versioning →

Think Like a CTO

Version control is a system or practice for tracking, comparing, and managing changes to files over time.

How it is used
Supports parallel development and access to the production version when a bug must be fixed without releasing unfinished features.
How deep it goes
Defines the purpose of version control and illustrates branching decisions, but does not teach commands or repository internals.
Examples
Uses a production bug during new development, release directories and zip files, and a migration from a home-built substitute to Git.
What you can do after
Evaluate/understand it by assessing team adoption, choosing a branching strategy for parallel work, and questioning inadequate inherited substitutes.

Read how Think Like a CTO explains versioning →

The Design of Web APIs, Second Edition

An API version scheme is a convention for identifying and expressing different versions of an API.

How it is used
Identifies consumer-visible API contracts as an interface evolves, especially when changes could break existing applications.
How deep it goes
Compares identifier schemes and versioning-policy decisions, then examines breaking-change impact and options for exposing concurrent versions.
Examples
Uses banking account and transaction changes, semantic and date-based identifiers, and concurrent-version implementation scenarios.
What you can do after
Evaluate/understand API version choices and assess whether a breaking release warrants consumer migration and concurrent support.

Read how The Design of Web APIs, Second Edition explains versioning →

AI for Everyday IT

Version control is the management of successive states of files or other artifacts, including their changes and history.

How it is used
Supports document integrity and gives AI coding assistants earlier working code to guide repairs.
How deep it goes
Illustrates a branch-based debugging workflow and document-labeling practices, without detailing Git commands.
Examples
Uses broken authentication and a working branch to demonstrate prompts for an AI-assisted fix.
What you can do after
Diagnose persistent code bugs with Git and an AI assistant by using working code on another branch as a guide.

Read how AI for Everyday IT explains versioning →

Unit Testing Principles, Practices, and Patterns

A source control system records, versions, and manages changes to files such as application code and database definitions.

How it is used
Keeps database schemas versioned and aligned with application-code changes while enabling database integration testing.
How deep it goes
Defines history and single-source-of-truth benefits, but defers detailed source-control operations and workflows.
Examples
Contrasts a dedicated model database with Git-managed schema updates and explicit database migrations.
What you can do after
Operate database changes through Git as the authoritative record instead of maintaining a separate model database.

Read how Unit Testing Principles, Practices, and Patterns explains versioning →

Building User-Friendly DSLs

The practice of recording and managing successive versions of files or other artifacts.

How it is used
Manages changing DSL content collaboratively and supports release management, auditing, and regulatory compliance.
How deep it goes
Defines commits, branches, tags, and distributed workflows, while noting that accumulated changes can make merging challenging.
Examples
Uses Git, feature and bug-fixing branches, SHA-identified commits, version tags, and a Gitflow-style workflow.
What you can do after
Apply Git-based distributed workflows to branch, commit, review, merge, and version DSL changes.

Read how Building User-Friendly DSLs explains versioning →

Road to Kubernetes

Version control is a system for recording, managing, and coordinating changes to files and source code over time.

How it is used
Uses code history and sharing to support application deployment and later automation.
How deep it goes
Defines version control through an undo analogy and lists Git capabilities, without detailing their internal mechanics.
Examples
Uses notebook copies and undo/redo as analogies, then illustrates Git with code tracking and reversion.
What you can do after
Apply version control via Git to track, revert, share, and retrieve code, and trigger workflows.

Read how Road to Kubernetes explains versioning →

First-Party Data Activation

Versioning is the maintenance of identifiable successive states of data, code, or system artifacts.

How it is used
Protects destination integrations from API changes and supports recovery of lakehouse data after faulty updates.
How deep it goes
Explains proactive API monitoring and snapshot rollback with operational examples, without detailing implementation steps.
Examples
Uses destination API changes and corrupted user segments as examples, naming Delta and Iceberg snapshots.
What you can do after
Diagnose pipeline anomalies using audit context and, where supported, restore a table to an earlier snapshot.

Read how First-Party Data Activation explains versioning →

The Art of AI Product Development

Version control is a system for recording changes to artifacts so that versions can be compared, managed, and restored.

How it is used
Tracks prompt changes during development to support iteration, collaboration, and rollback.
How deep it goes
Describes saving, tracking, and rolling back prompt changes, but does not detail version-control mechanics.
Examples
Tracks prompt tweaks and records what worked or failed during few-shot prompt development.
What you can do after
Operate a prompt-development process that preserves changes, supports experimentation, and enables rollback.

Read how The Art of AI Product Development explains versioning →

Microsoft Azure in Action

Source control is a system for recording, comparing, and managing versions of files and their changes.

How it is used
Protects Azure Storage data by keeping earlier blob versions available for recovery after changes or deletion.
How deep it goes
Explains automatic version creation and recovery, then demonstrates enabling versioning and listing versions with CLI commands.
Examples
Uses a blob container of banned books and Azure CLI commands to enable versioning and list blob versions.
What you can do after
Operate Azure CLI to enable blob versioning and inspect historical versions for recovery.

Read how Microsoft Azure in Action explains versioning →

LLM Customization and Fine-Tuning

The practice of tracking distinct iterations of a model and their changes over time.

How it is used
Tracks model provenance and deployment history to support reproducibility, rollback, and auditability.
How deep it goes
Specifies registry fields, a naming scheme, lifecycle operations, and storage choices, with a JSON registry implementation.
Examples
Uses an IT-support registry to compare an SFT baseline with a degraded DPO experiment and its rollback.
What you can do after
Operate/configure a JSON registry by registering, listing, promoting, and rolling back model versions.

Read how LLM Customization and Fine-Tuning explains versioning →

Delivering Machine Learning Projects: From design to deployment

Version control is a system for tracking, comparing, and managing successive versions of files and artifacts.

How it is used
Establishes component control early so teams can explore data and deliver machine-learning systems reliably.
How deep it goes
Recommends artifact checks and dependency controls but does not enumerate every component requiring versioning.
Examples
Checks checksums, signed binaries, and sampled known values; names Jenkins, GCP Cloud Build, and AWS Code Build.
What you can do after
Apply systematic checks to validate artifacts and manage component versions for production delivery.

Read how Delivering Machine Learning Projects: From design to deployment explains versioning →

Authorization in Action

A version control system is a software system that records and manages successive versions of files and supports operations such as rollback and audit.

How it is used
Manages authorization policies as reviewable, traceable artifacts within policy governance and change workflows.
How deep it goes
Explains history, authorship, peer review, approval, and CI checks, but does not detail version-control commands.
Examples
Uses Carol’s Team Reports rule and Bob’s pull request to illustrate review, testing, and deployment.
What you can do after
Apply Git-based version control to policy changes to support review, traceability, and accountable deployment.

Read how Authorization in Action explains versioning →

The Art of Code

Versioning is the practice of identifying successive revisions of an interface or artifact so clients can distinguish and manage compatibility between them.

How it is used
Guides interface evolution so releases communicate change clearly and preserve client trust.
How deep it goes
Explains semantic-version categories and compatibility tactics, but does not detail a migration process.
Examples
Uses breaking API changes and a Java deprecation annotation as concrete examples.
What you can do after
Apply semantic-version labels and compatibility tactics when evolving an interface.

Read how The Art of Code explains versioning →

Build Financial Software with Generative AI (From Scratch)

Versioning is the practice of managing distinct revisions of a software interface or system so that changes can be introduced and supported over time.

How it is used
Uses versioned API paths to preserve consumer access while introducing changes within API-driven design.
How deep it goes
Implements a URL-prefix refactor and updates unit tests, while identifying multiversion maintenance and deprecation without detailing a full lifecycle.
Examples
Uses `/api/v1/files`, a proposed `/v2` successor, and FastAPI route-prefix changes that require updated unit-test URLs.
What you can do after
Operate/configure API routes by assigning versioned prefixes in FastAPI and updating unit-test URLs after routes change.

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

Designing AI Systems

The systematic identification and preservation of successive versions of software, data, models, or configuration.

How it is used
Preserves compatibility as tools and workflows evolve, enabling independent releases and gradual application migration.
How deep it goes
Defines semantic-version compatibility, version pinning, and deprecation, then describes registry enforcement and migration periods.
Examples
Uses a scheduling tool with changing parameters and independently deployed workflows running versions 1.0 and 2.0.
What you can do after
Operate/configure tool registries with version constraints, compatibility checks, and structured deprecation.

Read how Designing AI Systems explains versioning →

Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools

Source control is a system and practice for tracking, managing, and coordinating changes to files such as source code.

How it is used
Positions source control as a professional practice for maintaining automation and coordinating PowerShell projects.
How deep it goes
Defines tracking and history, contrasts centralized and decentralized systems, and stops short of detailed Git workflows.
Examples
Uses script folders, checkout and check-in, change comments, local Git copies, merges, and hosted repositories as examples.
What you can do after
Apply Git from the command line to maintain PowerShell projects and participate in shared or community repositories.

Read how Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools explains versioning →

Grokking Software Architecture

Version control is the systematic management of changing files and their history so changes can be reviewed, reproduced, and restored.

How it is used
Protects API consumers while allowing public contracts to evolve.
How deep it goes
Compares URI-path and date-based strategies, examples, and tradeoffs without detailing implementation steps.
Examples
Shows v1 and v2 order endpoints and a Stripe release-date header.
What you can do after
Evaluate versioning approaches by client migration needs and server-side complexity.

Read how Grokking Software Architecture explains versioning →

Amazon Web Services in Action, Third Edition: An in-depth guide to AWS

Versioning is a bucket setting that preserves multiple revisions of objects stored under the same key.

How it is used
Supports S3 backup and archiving by retaining earlier object data after uploads replace the same key.
How deep it goes
Explains default behavior, enablement, version listing, and storage-cost growth without detailing version management.
Examples
Demonstrates two uploads under key A and AWS CLI commands to enable and list versions.
What you can do after
Apply via AWS CLI by enabling bucket versioning and listing stored object versions.

Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains versioning →

Build AI Drug Discovery Pipelines

Version management is the systematic tracking and control of changing versions of software, models, data, and configuration artifacts.

How it is used
Supports reproducibility when models and their associated analysis components evolve.
How deep it goes
Identifies models, training datasets, preprocessing, and inference parameters to track.
Examples
Contrasts analyses run with ESM-2 versions 1.0 and 2.0.
What you can do after
Apply version tracking to reproduce analyses across changing models and supporting artifacts.

Read how Build AI Drug Discovery Pipelines explains versioning →

Building Reliable AI Systems

A technique for associating entries with versions so entries from an outdated version can be invalidated.

How it is used
Keeps cached answers consistent when knowledge bases or system prompts change.
How deep it goes
Describes version tags and invalidation, but not a storage-level implementation.
Examples
Uses a changing shipping policy to illustrate invalidating cached answers.
What you can do after
Operate a cache by incrementing its version after knowledge-base or system-prompt revisions.

Read how Building Reliable AI Systems explains versioning →

Data Without Labels

Version control is the systematic management of changes to files, especially source code, so revisions can be tracked, compared, and recovered.

How it is used
Supports reproducible model deployment, protected iteration, and recovery when a new version causes problems.
How deep it goes
Explains the operational rationale and tool choice, but stops short of command-level workflows or repository internals.
Examples
Uses Git, regular code check-ins, documented code, and rollback to a previous model version.
What you can do after
Operate Git or another version-control tool to safeguard code, support reproducibility, and restore earlier versions.

Read how Data Without Labels explains versioning →

Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu

Version control is the practice of tracking and managing successive changes to files and code.

How it is used
Tracks infrastructure changes, supports collaboration and review, and provides versioning for reusable modules.
How deep it goes
Connects Git practices to module registries and GitOps, but does not detail version-selection commands.
Examples
Uses branches and pull requests for infrastructure changes, and shared repositories as GitOps sources for deployed configuration.
What you can do after
Apply it via Git branches, pull requests, and shared repositories to review changes and maintain infrastructure audit trails.

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

LLMs in Production

Versioning is the practice of recording and managing distinct revisions of software, data, models, or configuration.

How it is used
Uses versioning to replace models safely, support production experiments, and reproduce a software setup.
How deep it goes
Connects model revisions to replacement and production tests, but gives no detailed model-versioning workflow.
Examples
Uses production model tests and a pinned llama.cpp Git commit as examples of versioning.
What you can do after
Operate model deployments by retaining revisions for replacement and experiments, and reproduce a llama.cpp setup by checking out its tested commit.

Read how LLMs in Production explains versioning →

Claude at Work

Versioning is the practice of preserving and comparing successive states of files or other content.

How it is used
Preserves reviewable project states while Claude works on files.
How deep it goes
Demonstrates commits, pushes, diff review, and reverting, without detailing Git internals.
Examples
Uses Claude-edited project files and Markdown documents prepared for Word or PDF publication.
What you can do after
Operate versioning by committing work, reviewing diffs, and keeping or reverting changes.

Read how Claude at Work explains versioning →

Context Engineering

The practice of tracking and managing changes to files so changes can be reviewed and earlier versions restored.

How it is used
Manage prompts and broader AI context assets as reviewable, testable production artifacts.
How deep it goes
Applies versioning through Git history, peer review, regression checks, environment promotion, and rollback.
Examples
Uses parameterized prompts and repositories grouping context assets by function and deployment environment.
What you can do after
Operate/configure prompt and context updates independently, review changes, run regression checks, and roll back deployments.

Read how Context Engineering explains versioning →

Also covered in

What to know first

Related concepts

Questions about versioning

What is versioning?

Versioning is the practice of assigning or maintaining identifiable revisions of artifacts over time so their changes, histories, or compatibility can be tracked.

Which Manning books explain versioning?

Automating API Delivery, Machine Learning Platform Engineering, Java Persistence with Spring Data and Hibernate epub, Software Engineering for Data Scientists, Designing Deep Learning Systems: A guide for software engineers, Building Web APIs with ASP.NET Core, Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform, Machine Learning System Design and 28 more.

What should I know before learning versioning?

Manning books that teach versioning usually introduce deployment pipeline, contract, language model and JSON first.

What kinds of versioning are there?

Kinds of versioning include git.

What is versioning also called?

Versioning is also called version control.

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.