DevOps Bootcamp · Lesson

Semantic Versioning with Tags

Apply semantic versioning principles to your project and use Git tags to mark significant points in your history.

Semantic Versioning with Tags is a free DevOps Bootcamp lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the DevOps Bootcamp learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What is Software Versioning?

Imagine building a house. You wouldn't want to use old blueprints mixed with new ones, right?

Software versioning helps keep track of changes in your code.
It gives each release a unique identifier, like a version number.
This helps developers and users understand what's new, what's fixed, and what might break.

It's crucial for managing dependencies and communicating changes effectively.

Introducing Semantic Versioning (SemVer)

Semantic Versioning (or SemVer) is a widely adopted standard for assigning version numbers.

It uses a simple MAJOR.MINOR.PATCH format:

MAJOR: For big, breaking changes.
MINOR: For new features that are backward-compatible.
PATCH: For small bug fixes, also backward-compatible.

This system clearly communicates the impact of a new release.

Understanding the MAJOR Version

The MAJOR version number is incremented when you make incompatible API changes.

This means if someone is using your software, upgrading to a new MAJOR version might break their existing code.

Example: From 1.0.0 to 2.0.0.
Always communicate breaking changes clearly in your release notes!

It signals a significant update that requires attention from users.

Understanding the MINOR Version

The MINOR version is incremented when you add new functionality in a backward-compatible manner.

Users can upgrade to a new MINOR version without fear of their existing code breaking.

Example: From 1.2.0 to 1.3.0.
New features are added, but old ones still work as expected.

When the MINOR version is incremented, the PATCH version resets to 0 (e.g., 1.2.5 becomes 1.3.0).

Understanding the PATCH Version

The PATCH version is incremented when you make backward-compatible bug fixes.

These are typically small, internal changes that don't add new features or break existing ones.

Example: From 1.2.3 to 1.2.4.
Users can confidently upgrade to get bug fixes.

PATCH releases are often critical for stability and security.

Why SemVer is Important

Adopting Semantic Versioning brings several benefits:

Clarity: Developers instantly understand the impact of an update.
Predictability: Helps avoid unexpected breakage in dependent projects.
Dependency Management: Tools can automatically update to safe versions.
Communication: Provides a common language for discussing releases.

It builds trust and makes software development more robust.

Using Git Tags for Versioning

Git has a feature called tags that allows you to mark specific points in your repository's history as important.

This is perfect for marking release versions, like v1.0.0 or v2.1.5.

A tag is like a permanent bookmark to a specific commit.
It helps you easily reference a released version of your code later.

Tags are often used to signify official release points in a project's timeline.

Annotated vs. Lightweight Tags

Git offers two main types of tags:

Lightweight Tags: Simple pointers to a commit. They're just a name.
Annotated Tags: Full Git objects. They contain a tagger name, email, date, and a message.

For releases, annotated tags are preferred because they store valuable metadata and can be signed for authenticity.

Think of an annotated tag as a small release commit itself.

Creating an Annotated Tag

To create an annotated tag, use the git tag -a command, followed by the tag name and a message.

Here's how to mark your first stable release:

git init
echo "Initial content" > README.md
git add README.md
git commit -m "First commit"
git tag -a v1.0.0 -m "Initial stable release"
git log --oneline --decorate

Viewing and Inspecting Tags

Once tags are created, you can list them or view their details.

Use git tag to list all tags in your repository.
Use git show <tagname> to see the commit associated with a tag and its metadata.

Try running the example to see how:

git init
echo "Feature A" > a.txt
git add a.txt
git commit -m "Add feature A"
git tag -a v0.1.0 -m "First feature release"
echo "Bug Fix B" > b.txt
git add b.txt
git commit -m "Fix bug B"
git tag -a v0.1.1 -m "Bug B fixed"
git tag
git show v0.1.0

Quick Check: SemVer Impact

Consider a project currently at version 1.5.2. The team decides to add a new, backward-compatible feature and fix a minor bug.

What should the next version number be according to Semantic Versioning?

Recap: SemVer & Git Tags

Great job! You've learned the essentials of Semantic Versioning and how to use Git tags to mark your releases.

SemVer (MAJOR.MINOR.PATCH) provides a clear way to communicate changes.
MAJOR: Breaking changes.
MINOR: New, backward-compatible features.
PATCH: Backward-compatible bug fixes.
Git Tags: Act as permanent bookmarks for specific commits, ideal for marking release versions.
Annotated Tags: Preferred for releases due to their metadata.

This knowledge is key for effective release management and collaboration!

Frequently asked questions

Is the “Semantic Versioning with Tags” lesson free?

Yes — the full text of “Semantic Versioning with Tags” is free to read here on the web, and the DevOps Bootcamp course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the DevOps Bootcamp course, upgrade to CoddyKit PRO.

What will I learn in “Semantic Versioning with Tags”?

Apply semantic versioning principles to your project and use Git tags to mark significant points in your history. You practise DevOps Bootcamp with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start DevOps Bootcamp?

No prior experience is required. DevOps Bootcamp on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Semantic Versioning with Tags” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this DevOps Bootcamp lesson?

Yes. Every DevOps Bootcamp lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to DevOps Bootcamp