feat(conventional_commits): signal breaking changes in commit titles


Short version

  • I like Conventional Commits.
  • Conventional Commits miss an important opportunity to signal the breakingness of change in the title rather than just the body of a commit message.
  • Introducing a “BREAK: “ prefix might be a good way to do this. There are other ideas.
  • Call to action: help make Conventional Commits better in this and other respects

Status quo:

feat: split `ROLE_VIEW_ABSENCE_HISTORIES`

(Is this a breaking change? You’ll have to read the exciting commit message body and footer to find out…)

Better:

BREAK: feat: split ROLE_VIEW_ABSENCE_HISTORIES

or

!feat: split ROLE_VIEW_ABSENCE_HISTORIES

or

FEAT: split ROLE_VIEW_ABSENCE_HISTORIES

Conventional Commits

I like Conventional Commits.

Conventional Commits are a commit message format specification. Much of the value of Conventional Commits is in encouraging semantic commits that thoughtfully express carefully crafted units of meaning.

Like Jeremy Mack, I think that taking care to compose single-thought semantic commits makes me a better programmer.

Conventional Commits look like this:

feat: turbocharge the whatsit

That token at the front is the type, followed on the line by a super-brief description. This first line altogether is the title of the commit message.

Conventional Commit messages have an optional body

fix: correct the twinkle

The twinkle was not previously astronomically correct;
this fix corrects to a precision of six decimal places.

Fixes #14

Conventional Commits thinks of the last part of the body as an optional footer.

Conventional Commits can also express a scope, an area of the project where the change type is being applied.

docs(song): note that carbon stars are sort-of diamonds in the sky

Conventional Commits are meant to help with [Semantic Versioning][]. A release containing only backwards-compatible fixes like

fix: tighten the goober

would be a patch release (like 2.4.1).

A minor release (like 2.5) introducing new features would include commits like

feat: expose HRS URLs in the JSON API at /api/urls

One is meant to be able to take a look at the commit log and thereby figure out what sort of Semantic Versioning bump is in order. An adopter faced with a major release is meant to be able to look at the commit history to inspect the breaking changes.

Conventional commits of any type can be API-breaking changes. These changes occasion a major version change (5 to 6, say) in Semantic Versioning. An author notes the breakingness of a change (and advice for how clients of the library might adapt to the breaking change) in the body or footer of a Conventional Commit.

So,

fix: correct spelling of referrer in header

BREAKING CHANGE: Rather than using misspelled "Referer" as name of header,
instead use correct spelling "Referrer". Clients expecting "Referer" will no
longer receive that header  and will presumably not honor the new "Referrer"
until updated to support this new name for this header.

Improving Conventional Commits: signal the breakingness in the commit title

There are contexts in which only the title and not the body of commit messages display, e.g. in GitHub’s presentation of a branch’s history or in some Git command line tooling.

Which of these are breaking changes?

fix: correct spelling of referrer in header
fix: correct spelling of referrer in label
fix: tighten the wingnut
feat: bolt on the blender

You can’t tell from the commit title. You’d have to look at the body of the message for each one to realize that e.g. the header spelling fix is a breaking change.

I think Conventional Commits should be improved to reliably reflect the breakingness of change in the title of the commit rather than just in the body. There are a few ideas on how to do this:

The sigil idea

!fix: correct spelling of referrer in header

A sigil is delightfully succinct. However, it might not be immediately apparent to a naive reader what meaning that ! is trying to convey.

Question: how would a screen reader or other accessibility tool treat that sigil?

The ALL-CAPS idea

FIX: correct spelling of referrer in header

This solution consumes zero characters. It’s also relatable in that ALL-CAPS ON THE INTERNET IS SHOUTING and that’s just the idea, to shout out the most important changes so that adopters can more readily identify the changes that are breaking their usages. I think it’s likely as readable and self-evident as a sigil, and it’s elegant that it consumes zero characters.

However, Conventional Commits has not to date specified the capitalization of type. Some have argued for specifying the capitalization, or specifying that the capitalization is unspecified. In any case it’s the kind of thing developers might be inconsistent about. Any inadvertent ALL-CAPS commit messages will be false positives for this signal.

Question: how well would a screen reader or other accessibility tool present the fact that the type is ALL-CAPS rather than lowercase?

The prefix idea

BREAK: fix: correct spelling of referrer in header

I like this solution best. It consumes 7 characters, but it’s also more self-documenting, more readily apparent even to someone unfamiliar with Conventional Commits what it’s trying to say. Which commits are the breaking changes? Oh yeah, the ones that are shouting at me “BREAK”.

Call to action

I think that some (required!) way of indicating the breakingness of change in Conventional Commit titles should be specified. What is often the most important thing to say about a breaking-change commit shouldn’t be only in the body of the message.

Maybe you have other ideas for how to convey breakingness in Conventional Commit commit titles. Maybe you have some expertise to offer about how screen readers and other accessibility tools would present the title under the different options under consideration. Maybe you like one of these ideas. Maybe you too don’t know which solution should be adopted but really wish Conventional Commits would go ahead and accept some solution so that identifying breaking changes in repositories using Conventional Commits will get easier sooner. Maybe you like the status quo just fine and don’t want to see Conventional Commit titles change for this.

However you think this ought to play out, engage in GitHub to help make it happen.

References and learn more

Author: Andrew Petro

Related Posts

CAS 6.1.0 RC5 Feature Release

...in which I present an overview of CAS 6.1.0 RC5 release.

Apereo CAS - Passwordless Authentication

Learn how to modify Apereo CAS to allow users to login without the need to remember a password.

Apereo CAS - Handling Authentication Webflow Errors with Grace

Learn how to modify Apereo CAS to customize exception handling and produce localized error messages for your deployment.

Apereo CAS - Are We Logged In Yet?

Learn how to modify and extend a CAS deployment to determine whether an SSO session is still valid and tied to a user authentication session.

Apereo CAS - REST API Integrations

Learn how to integrate with CAS using its REST API to authenticate, exchange tickets and get access to user profiles and attributes.

CAS 6.1.0 RC4 Feature Release

...in which I present an overview of CAS 6.1.0 RC4 release.

Apereo CAS - Multifactor Provider Selection

Learn how to configure CAS to integrate with and use multiple multifactor providers at the same time. This post also reveals a few super secret and yet open-source strategies one may use to select appropriate providers for authentication attempts, whether automatically or based on a menu.

Apereo CAS - Dockerized Hazelcast Deployments

Learn how to run CAS backed by a Hazelcast cluster in Docker containers and take advantage of the Hazelcast management center to monitor and observer cluster members.

Apereo CAS - Configuration Security w/ Jasypt

Learn how to secure CAS configuration settings and properties with Jasypt.

CAS 6.1.0 RC3 Feature Release

...in which I present an overview of CAS 6.1.0 RC3 release.