Versioning
Versioning is the practice of assigning or maintaining identifiable revisions of artifacts over time so their changes, histories, or compatibility can be tracked.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- Architecting an Apache Iceberg Lakehouse
- API Design Patterns
- Think Like a Software Engineering Manager
- Troubleshooting Java, Second Edition
- Secure APIs
- Crack Any Codebase with AIIn early access (MEAP)
- Django in Action
- Build High Value Software SystemsIn early access (MEAP)
- High Performance Unity Game DevelopmentIn early access (MEAP)
- Grokking Statistics
- Developer Experience on KubernetesIn early access (MEAP)
- Shipping Go: Develop, deliver, discuss, design, and go again
What to know first
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
Related concepts
- context-as-codeused by · Context-as-code is a practice of representing context configuration and management logic as versionable, executable code.
- gitincludes · Git is a distributed version-control system for recording changes to files and coordinating work across repositories.
- breaking changeaddresses · A breaking change is a modification to an interface, behavior, format, configuration, or contract that can prevent existing consumers from working correctly without changes.
- GitOpsused by · GitOps is an operational approach that uses version-controlled declarative configuration as the source of truth and automation to apply or reconcile system state.
- deployment pipelineused by · A deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- reproducibilityproduces · Reproducibility is the ability to obtain consistent or comparable results by repeating a process with the same documented inputs, methods, and relevant conditions.
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.



































