GoLang Tutorial - Workspaces I

In this tutorial, we'll create two modules in a shared multi-module workspace, make changes across those modules, and see the results of those changes in a build.

$ mkdir workspace
$ cd workspace   

Our example will create a new module hello that will depend on the golang.org/x/example module.

$ mkdir hello
$ cd hello
$ go mod init example.com/hello
go: creating new go.mod: module example.com/hello

Now, we want to add a dependency on the golang.org/x/example/hello/reverse package using go get command. It will download a Go package from the specified repository.

$ go get golang.org/x/example/hello/reverse
go: downloading golang.org/x/example v0.0.0-20231013143937-1d6d2400d402
go: downloading golang.org/x/example/hello v0.0.0-20231013143937-1d6d2400d402
go: added golang.org/x/example/hello v0.0.0-20231013143937-1d6d2400d402    

The go get command is fetching the specified Go package and its dependencies, and the output indicates the versions that have been downloaded and added to our project. After running this command, we can use the package in our Go code, and it will be included in our Go module.

Let's create hello/hello.go with the following contents:

package main

import (
    "fmt"

    "golang.org/x/example/hello/reverse"
)

func main() {
    fmt.Println(reverse.String("Hello"))
}    

Run the code:

$ go run .
olleH    

In this section, we'll create a go.work file to specify a workspace with the module.

In the workspace directory, run go work init command to tell go to create a go.work file for a workspace containing the modules in the ./hello directory.

$ go work init ./hello

The go command produces a go.work file that looks like this:

$ cat go.work
go 1.21.4

use ./hello

The go.work file has similar syntax to go.mod.

1. The go directive tells Go which version of Go the file should be interpreted with. It's similar to the go directive in the go.mod file.
2. The use directive tells Go that the module in the hello directory should be main modules when doing a build.
3. So in any subdirectory of workspace the module (in this case, the one in the hello directory) will be active and treated as the main module.

Last time, we run the program in workspace/hello directory. But we can run it in workspace directory:

$ go run ./hello
olleH    

The Go command includes all the modules in the workspace as main modules. This allows us to refer to a package in the module, even outside the module.

Running the go run command outside the module or the workspace would result in an error because the go command wouldn't know which modules to use.

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)