What do we want? Version management for Go packages! When do we want it? Yesterday!
What does everyone want? We want our Go build tool of choice to fetch the latest stable version when you start using the package in your project. We want them to grab security updates and bug fixes automatically,
But as it stands, today, in 2016, there is no way for a human, or a tool, to look at an arbitrary git (or mercurial, or bzr, etc) repository of Go code and ask questions like:
- What versions of this project have been released?
- What is the latest stable release of this software?
- If I have version 1.2.3, is there a bugfix or security update that I should apply?
The reason for this is Go projects (repositories of Go packages) do not have versions, at least not in the way that our friends in other languages use that word. Go projects do not have versions because there is no formalised release process.
But there’s vendor/ right?
Arguing about tools to manage your vendor/ directory, or which markup format a manifest file should be written in is eating the elephant from the wrong end.
Before you can argue about the format of a file that records the version of a package, you have to have some way of actually knowing what that version is. A version number has to be sortable, so you can ask, “is there a newer version available than the one you have on disk?” Ideally the version number should give you a clue to how large the jump between versions is, perhaps even give a clue to backwards or forwards compatibility between two versions.
SemVer is no one’s favourite, yet one format is everyone’s favourite.
I recommend that Go projects adopt SemVer 2.0.0. It’s a sound standard, it is well understood by many, not just Go programmers, and semantic versioning will let people write tools to build a dependency management ecosystem on top of a minimal release process.
Following the lead of the big three Go projects, Docker, Kubernetes, and CoreOS (and GitHub’s on releases page), the format of the tag must be:
That is, the letter
v followed by a string which is SemVer 2.0.0 compliant. Here are some examples:
git tag -a v1.2.3 git tag -a v0.1.0 git tag -a v1.0.0-rc.1
Here are some incorrect examples:
git tag -a 1.2.3 // missing v prefix git tag -a v1.0 // 1.0 is not SemVer compliant git tag -a v2.0.0beta3 // also not SemVer compliant
Of course, if you’re using hg, bzr, or another version control system, please adjust as appropriate. This isn’t just for git or GitHub repos.
What do you get for this?
Imagine if godoc.org could show you the documentation for the version of the package you’re using, not just the latest from HEAD.
Now, imagine if godoc.org could not just show you the documentation, but also serve you a tarball or zip file of the source code of that version. Imagine not having to install mercurial just to
go get that one dependency that is still on google code (rest in peace), or bitbucket in hg form.
Establishing a single release process for Go projects and adopting semantic versioning will let your favourite Go package management or vendoring tool provide you things like a real upgrade command. Instead of letting you figure out which revision to switch to, SemVer gives tool writers the ability to do things like upgrade a dependency to the latest patch release of version 1.2.
Build it and they will come
ust like writing tools that can, at the moment, only record git hashes is pointless.
Here’s the deal: If you release your Go projects with the correctly formatted tags, then there are a host of developers who are working dependency management tools for Go packages that want to consume this information.
How can I declare which versions of other packages my project depends on?
If you’ve read this far you are probably wondering how using tagging releases in your own repository is going to help specify the versions of your Go project’s dependencies.
The Go import statement doesn’t contain this version information, all it has is the import path. But whether you’re in the camp that wants to add version information to the import statement, a comment inside the source file, or you would prefer to put that information in a metadata file, everyone needs version information, and that starts with tagging your release of your Go projects.
No version information, no tools, and the situation never improves. It’s that simple.