Versioning
The practice of identifying and managing successive revisions of files, data, models, interfaces, or other artifacts so changes can be tracked and earlier states recovered.
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
- Detects conflicting changes to persistent entities in concurrent transactions and distinguishes that check from retaining historical revisions.
- How deep it goes
- Shows @Version mapping and flush-time SQL checking, then extends to manual checks, forced increments, timestamps, and Envers revisions.
- Examples
- Uses a versioned entity update that conflicts at flush time, a category-price calculation, and an Envers historical-data query.
- What you can do after
- Apply it via JPA @Version and optimistic lock modes to detect conflicting updates; use Hibernate Envers when historical revisions are required.
Read how Java Persistence with Spring Data and Hibernate epub 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
- Makes model revisions selectable through an API and makes potentially breaking behavior changes visible to callers.
- How deep it goes
- Shows version selection during initialization and warns about unbumped changes, but defers more advanced management to the model registry pattern.
- Examples
- Uses a version-loading Model class and a Python upgrade that caused mismatched outputs.
- What you can do after
- Operate/configure it by requesting a model version at initialization and checking whether pipeline changes require a version change.
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 →
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.
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
- Uses Git to preserve working states and supply AI coding assistants with context for implementing and repairing code.
- How deep it goes
- Explains change tracking and branch-based recovery through a worked authentication example, but does not detail version-control internals.
- Examples
- Uses broken authentication, a working branch, discarded changes, and a three-step Git repair workflow.
- What you can do after
- Diagnose/debug with Git by comparing broken work against a known-working branch and guiding an assistant toward the proven pattern.
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.
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.
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
- Controls changing ML components so teams can explore data and deliver reliable production configurations.
- How deep it goes
- Explains artifact checksums, signed binaries, known-value sampling, dependency registration, and CI/CD implications without enumerating every versioned item.
- Examples
- Uses checksums, signed binaries, known-value samples, Jenkins, GCP Cloud Build, and AWS Code Build.
- What you can do after
- Operate CI/CD delivery with validated component versions and trace problems to specific artifacts or dependencies.
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 reviewed, auditable software artifacts within policy governance and engineering workflows.
- How deep it goes
- Explains repository history, attribution, peer review, and traceability, then connects changes to automated validation and deployment.
- Examples
- Uses Git repositories, pull requests, ADRs, declarative Cedar policies, signed bundles, and a Team Reports access rule.
- What you can do after
- Operate policy changes through reviewable history, automated checks, repeatable deployment, and auditable authorization workflows.
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
- Communicates API evolution and helps dependent systems manage compatibility without losing confidence in future releases.
- How deep it goes
- Explains semantic-version meanings, deprecation, compatibility risks, and method extension, but does not detail repository workflows.
- Examples
- Uses changed fields, validation rules, endpoint URLs, optional parameters, and a Java deprecation annotation as compatibility examples.
- What you can do after
- Apply it via semantic versioning and deprecation practices when evolving a public interface.
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.
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.
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.
Related concepts
- gitincludes · Git is a distributed version-control system that records changes to files and supports managing project history and collaboration 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.
- reproducibilityproduces · Reproducibility is the ability to recreate the same or equivalent results by repeating a process with the same relevant inputs, methods, and conditions.
- deployment pipelineused by · A sequence of automated or manual stages that builds, tests or validates, packages, and delivers software or models toward deployment.
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.