GoLang Tutorial - Modules 1 (Creating a new module)

This post is an introduction to the basic operations needed to get started using modules.

A module is a collection of Go packages stored in a file tree with a go.mod file at its root. The go.mod file defines the module's module path, which is also the import path used for the root directory, and its dependency requirements, which are the other modules needed for a successful build. Each dependency requirement is written as a module path and a specific semantic version.

Starting from Go 1.13, module mode will be the default for all development.

Go code is grouped into packages, and packages are grouped into modules. Our module specifies dependencies needed to run our code, including the Go version and the set of other modules it requires.

Sourcing one module per repository:

Sourcing multiple modules per repository:

Here is the file structure we're going to produce:

Let's create a new module.

First, we want to create a new, empty directory, greetings, cd into that directory:

$ mkdir greetings
$ cd greetings    

Run the go mod init command, giving it the module path -- here, use example/greetings:

$ go mod init example/greetings 
go: creating new go.mod: module example/greetings

The go mod init command creates a go.mod file to track code's dependencies. So far, the file includes only the name of module and the supported Go version. But as we add dependencies, the go.mod file will list the versions our code depends on. This keeps builds reproducible and gives us direct control over which module versions to use.

greetings.go:

package greetings

import "fmt"

// Hello returns a greeting for the named person.
func Hello(name string) string {
    // Return a greeting that embeds the name in a message.
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message
}    

In Go, a function whose name starts with a capital letter can be called by a function not in the same package. This is known in Go as an exported name.

In Go, the := operator is a shortcut for declaring and initializing a variable in one line, but we might have written the line as the following:

var message string
message = fmt.Sprintf("Hi, %v. Welcome!", name)    

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)