Semantic versioning
Semantic Versioning is a version-numbering convention using MAJOR.MINOR.PATCH components to communicate compatibility impact: major for incompatible changes, minor for compatible additions, and patch for compatible fixes.
Building Web APIs with ASP.NET Core
Semantic versioning is a version-numbering convention using MAJOR, MINOR, and PATCH components whose increments communicate compatibility and change significance.
- How it is used
- Frames version numbers as compatibility signals when managing API changes.
- How deep it goes
- Defines the three increment rules and notes extensions without detailing them.
- Examples
- Uses an ASP.NET Core API configured with a default version of 1.0.
- What you can do after
- Evaluate/understand whether an API change calls for a major, minor, or patch increment.
Read how Building Web APIs with ASP.NET Core explains semantic versioning →
Go in Action, Second Edition
Semantic versioning is a versioning convention in which changes to major, minor, and patch components communicate compatibility and release significance.
- How it is used
- Versions Go modules to communicate compatibility expectations to consumers.
- How deep it goes
- Defines major, minor, and patch changes and demonstrates tagging and consuming an initial module release.
- Examples
- Uses a domain module tagged domain/v0.0.1 and a storage module that depends on that version.
- What you can do after
- Apply it via Git and Go to tag a module release and request a specific dependency version.
Read how Go in Action, Second Edition explains semantic versioning →
Microservices Patterns, Second Edition
Semantic versioning is a convention that assigns major, minor, and patch numbers to communicate the compatibility and nature of software changes.
- How it is used
- Uses version numbers to communicate API change type and compatibility during controlled evolution.
- How deep it goes
- Defines major, minor, and patch increments and shows where API versions can appear, without detailing a complete change process.
- Examples
- Illustrates the three-part format with Spring Boot 3.5.6 and describes URL-path and message-based API versioning.
- What you can do after
- Apply major, minor, and patch increments to communicate API compatibility and change type.
Read how Microservices Patterns, Second Edition explains semantic versioning →
API Design Patterns
A semantic version string is a dotted three-number representation whose major, minor, and patch components communicate the nature of software changes.
- How it is used
- Communicates API change impact and compatibility expectations through one version label.
- How deep it goes
- Defines three dotted numbers and explains major and minor semantics, while leaving patch behavior unspecified.
- Examples
- Uses field renaming and field addition to demonstrate incompatible and compatible API changes.
- What you can do after
- Apply version increments to communicate whether API changes should preserve existing client behavior.
The Design of Web APIs, Second Edition
A semantic version number is a version identifier with major, minor, and patch components whose changes conventionally communicate compatibility impact.
- How it is used
- Signals whether an API interface change is breaking or backward compatible so consumers can plan for it.
- How deep it goes
- Defines MAJOR and MINOR changes through banking API examples and distinguishes API versions from optional document patch versions.
- Examples
- Uses banking API operation and response changes, an OpenAPI info.version value, and a faulty version for a Spectral exercise.
- What you can do after
- Apply it via OpenAPI to label API changes, and practice enforcing the identifier format with a Spectral rule.
Read how The Design of Web APIs, Second Edition explains semantic versioning →
The Art of Code
Semantic versioning is a version-numbering convention in which major, minor, and patch components communicate compatibility and change significance.
- How it is used
- Communicates release risk while preserving trust during public API evolution.
- How deep it goes
- Defines major, minor, and patch meanings, then connects them to compatibility and deprecation without detailing a formal specification.
- Examples
- Uses breaking fields, validation, endpoint changes, deprecated methods, and MAJOR.MINOR.PATCH release categories as examples.
- What you can do after
- Evaluate upgrade risk and communicate whether a release breaks compatibility, adds functionality, or fixes defects.
GitHub Actions in Action: Continuous integration and delivery for DevOps
Semantic versioning is a versioning scheme that communicates compatibility and change significance through major, minor, and patch version numbers.
- How it is used
- Signals release compatibility for packages, artifacts, and shared GitHub Actions.
- How deep it goes
- Defines MAJOR.MINOR.PATCH increments and demonstrates Git-history-based calculation, while deferring fuller release-management coverage.
- Examples
- Uses v3.0.0, v3, and v3.0.1 tags plus a GitVersion workflow with fetch-depth 0.
- What you can do after
- Apply it via GitVersion or release tags to publish compatibility-signaling versions and update major tags for fixes.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
Semantic versioning is a version-numbering scheme in which major, minor, and patch components communicate the kinds of changes between releases.
- How it is used
- Controls infrastructure-module dependencies while enabling downstream evolution, auditing, and retirement of inactive releases.
- How deep it goes
- Defines major, minor, and patch changes, then stops short of a full specification of semantic-versioning approaches.
- Examples
- Uses a database module that moves a password into a secrets manager, alongside Git tags and release history.
- What you can do after
- Apply it via Git tags or artifact labels to select explicit module versions and manage breaking infrastructure changes.
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A semantic version is a version identifier following major, minor, and patch precedence rules.
- How it is used
- Signals Terraform module and provider upgrade risk through release numbers and Git tags.
- How deep it goes
- Explains version fields, change categories, constraint operators, and upgrade boundaries through configuration examples.
- Examples
- Uses module changelogs, Terraform version expressions, registry tags, and provider releases built by GitHub Actions.
- What you can do after
- Apply Terraform version constraints and publish module or provider releases with semantic Git tags.
Also covered in
- Build AI-Enhanced Web Apps
- CSS in Depth, Second Edition
- Shipping Go: Develop, deliver, discuss, design, and go again
- Secrets of the JavaScript Ninja, Third EditionIn early access (MEAP)
- Code Like a Pro in Rust
- Kubernetes for Developers
- Learn Go with Pocket-Sized Projects
- Logs and Telemetry
- Write Powerful Rust Macros
- Designing AI SystemsIn early access (MEAP)
- Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
- Automating API Delivery
What to know first
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- OpenAPI specificationThe OpenAPI Specification is a machine-readable standard for describing HTTP APIs, including their operations, inputs, outputs, data structures, and security requirements.
- attributeAn attribute is a named property or piece of information associated with an entity, object, or structured data item.
- breaking changeA breaking change is a modification to an interface, behavior, format, configuration, or contract that can prevent existing consumers from working correctly without changes.
Related concepts
- major versionhas part · A major version is the primary component of a version identifier that distinguishes a release line and commonly signals potentially backward-incompatible changes.
- CSSused by · CSS (Cascading Style Sheets) is a stylesheet language for specifying the presentation and layout of structured documents.
Questions about semantic versioning
What is semantic versioning?
Semantic Versioning is a version-numbering convention using MAJOR.MINOR.PATCH components to communicate compatibility impact: major for incompatible changes, minor for compatible additions, and patch for compatible fixes.
Which Manning books explain semantic versioning?
Building Web APIs with ASP.NET Core, Go in Action, Second Edition, Microservices Patterns, Second Edition, API Design Patterns, The Design of Web APIs, Second Edition, The Art of Code, GitHub Actions in Action: Continuous integration and delivery for DevOps, Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform and 1 more.
What should I know before learning semantic versioning?
Manning books that teach semantic versioning usually introduce contract, OpenAPI specification, attribute and breaking change first.
What is the difference between semantic versioning and date-based versioning?
Semantic Versioning is a version-numbering convention using MAJOR.MINOR.PATCH components to communicate compatibility impact: major for incompatible changes, minor for compatible additions, and patch for compatible fixes. Date-based versioning identifies or selects a software or API version by a date associated with its release or use.
What are the parts of semantic versioning?
Semantic versioning includes major version, minor version and patch version.
What is semantic versioning also called?
Semantic versioning is also called SemVer or semantic version.
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.








