Skip to main content
In this lesson, we explore the go.mod file and how it manages dependency tracking within a Go module. This file serves as the cornerstone for module initialization and dependency management, ensuring that your project remains consistent and reproducible.

​
Creating a go.mod File

To initialize a new Go module, run the following command in your project’s root directory: 
go mod init example.com/learn
This command creates a go.mod file that marks the collection of Go source code as a module. It also maintains a record of the module’s dependencies. A typical go.mod file appears as follows: 
module example.com/learn
go 1.19
Every go.mod file begins with a module declaration using the keyword module followed by a unique module path (in this case, “example.com/learn”). The file also specifies the minimum compatible Go version (“1.19” here).

​
Setting Up a main.go File

Next, create a main.go file as the entry point for your module. Start by declaring the package as main and defining the main function: 
package main

func main() {
}
To enhance this file, import the third-party package “github.com/pborman/uuid” from GitHub. This package is used to generate universally unique IDs (UUIDs). Update your main.go file as follows: 
package main

import (
    "fmt"
    "github.com/pborman/uuid"
)

func main() {
    uuid := uuid.NewRandom()
    fmt.Println(uuid)
}
In this version, the function uuid.NewRandom() generates a new UUID, which is then printed to the console using fmt.Println.

​
Synchronizing Dependencies with go.mod

At this point, although the code references a third-party package, it hasn’t been downloaded yet. To update your dependencies and the go.mod file, run the command: 
go mod tidy
The go mod tidy command scans your source code for all required dependencies and adds any that are missing. You may see output similar to the following: 
go: finding module for package github.com/pborman/uuid
go: found github.com/pborman/uuid in github.com/pborman/uuid v1.2.1
After execution, your go.mod file will include a require section listing the dependencies along with the appropriate versions. An updated file might resemble this: 
module example.com/learn

go 1.19

require github.com/pborman/uuid v1.2.1
require github.com/google/uuid v1.0.0 // indirect
The require section ensures that the correct module versions are used. Notice that the dependency on github.com/google/uuid is marked as indirect because it is used by one of the dependencies rather than directly by your code.
The go mod tidy command not only downloads missing dependencies but also cleans up any unused ones, ensuring your module remains lean and up-to-date.

​
Running Your Application

Before executing the program, verify that the correct function name (NewRandom()) is used from the UUID package. To run the application, execute: 
go run main.go
The console output will display a newly generated UUID, for example: 
ofc766ac-80d1-4999-9ab4-701d50600cb8

​
Summary

A Go module is simply a collection of source files managed by a go.mod file. This file includes:
  • The module declaration with a unique module path.
  • The required Go version.
  • Dependencies listed with their correct versions.
This file structure ensures reliable dependency management and helps maintain the integrity of your project across different environments.
The image explains the purpose of a go.mod file in Go programming, highlighting its role in defining a module and specifying dependencies and version compatibility.
This concludes our detailed lesson on the go.mod file. Happy coding and see you in the next lesson!

Watch Video