How can you handle versioning in a Go application or library?

Versioning in a Go application or library is crucial for managing dependencies and ensuring that your project remains stable and predictable as it evolves. Go modules, introduced in Go 1.11, are the standard and recommended way to handle versioning and dependency management in Go projects.

To handle versioning in a Go application or library, follow these steps:

1. Enable Go modules:

Make sure you have Go 1.11 or later installed. Enable Go modules by running the following command:

   export GO111MODULE=on

Alternatively, you can put your project outside of your ‘GOPATH‘.

2. Initialize a new module:

In the root of your project, run the following command:

   go mod init <module-name>

This will create a ‘go.mod‘ file in your project directory, which will track your project’s dependencies and their corresponding versions.

3. Add dependencies:

When you import packages in your code, Go will automatically fetch the required modules and add them as dependencies in the ‘go.mod‘ file, along with their semantic version. You can also add dependencies manually by editing the ‘go.mod‘ file, or by running:

   go get <dependency>@<version>

4. Commit and tag your module:

When you have a stable version of your code, commit it and use Git to create a new tag with a semantic version, such as ‘v1.0.0‘:

   git add .
   git commit -m "Initial release"
   git tag v1.0.0
   git push origin v1.0.0

Other projects can now reference your module with the corresponding version.

5. Update dependencies:

To update a dependency to a new version, you can edit the version number in the ‘go.mod‘ file or use the ‘go get‘ command:

   go get -u <dependency>@<new-version>

This will update the version of the dependency and make any necessary changes to the ‘go.sum‘ file.

6. Follow semantic versioning principles:

As your project evolves, make sure to adhere to the rules of semantic versioning (https://semver.org/). This means that you should increment the major version when you make incompatible API changes, increment the minor version when you add functionality in a backwards-compatible manner, and increment the patch version for backwards-compatible bug fixes.

By following these steps, you can effectively handle versioning in your Go application or library using Go modules. This will ensure that your project remains stable, predictable, and easy to manage as it grows and evolves.