Go Tooling🔗

Using go run to Try out Small Programs🔗

Go is a compiled language, but go run allows executing source code directly without creating a binary.
It compiles the program into a temporary directory, runs it, and deletes the binary afterward.
Useful for testing small programs or treating Go like a scripting language.

Adding Third-Party Tools with go install🔗

Installs Go programs from source repositories by downloading, compiling, and placing them in the Go binary directory.
Requires specifying the package path with @version or @latest to avoid unintended behaviour.
Default installation location is $HOME/go/bin, which should be added to the system’s PATH.
Default installation location is $HOME/go/bin, which should be added to the system’s PATH.

Environment Variables in Go🔗

GOROOT (Go installation directory) and GOPATH (workspace for Go code) are automatically managed; manual configuration is usually unnecessary.
GOBIN can be set to customise where installed binaries are stored.
go help environment lists all available environment variables.

Updating Installed Tools🔗

Running go install with @latest updates an installed tool to the newest version.
Example: go install github.com/rakyll/hey@latest updates hey.

Distribution of Go Programs🔗

go install is the preferred method for installing developer tools but is not mandatory for distribution.
Binaries built using go build can be shared separately.

Improving Import Formatting with goimports🔗

goimports also cleans up import statements, puts them in alphabetical order, removes unused imports and tries to guess any unspecified imports.
go install golang.org/x/tools/cmd/goimports@latest
goimports -l -w .

Using Code-Quality Scanners🔗

go vet is a built-in tool that scans for common programming errors.
Third-party linters help check code style and detect potential bugs missed by go vet
Linters enforce idiomatic Go practices, such as * Properly naming variables * Formatting error messages correctly. * Adding comments to public methods and types.
While linting suggestions aren't always mandatory, following them helps maintain readable and consistent code.

Best Practices When Using Linters🔗

Linters may produce false positives or false negatives - review their suggestions before applying changes
If ignoring a linter warning, add a comment explaining why for future reference
Each linter provides a different format for disabling specific warnings - check the documentation

staticcheck🔗

One of the best third-party scanners with over 150 checks
Minimizes false positives and is widely supported
go install honnef.co/go/tools/cmd/staticcheck@latest\
staticcheck ./...

Example issue detected by staticcheck but not by go vet:

s := fmt.Sprintf("Hello")
fmt.Println(s)

// staticcheck ./...
// main.go:6:7: unnecessary use of fmt.Sprintf (S1039)

Another example: Detecting unused assignments to err.

revive🔗

successor to golint, providing style and quality checks
Installation: go install github.com/mgechev/revive@latest
Default Checks include * Missing comments on exported identifiers. * Improper naming conventions. * Incorrect ordering of return values.
Customizable via configuration files (.toml). Example:
```
[rule.redefines-builtin-id]
```

Example issue detected by revive:

true := false
fmt.Println(true)

// revive -config built_in.toml ./...
// main.go:6:2: assignment creates a shadow of built-in identifier true

golangcli-lint🔗

Aggregates multiple linters into a single tool (includes go vet, staticcheck, revive, etc.).
Efficient and configurable.
Installation (recommended via binary download): Follow instructions on the official site.
golangci-lint run

Example Issue Detection

x := 10
x = 30
// golangci-lint run
// main.go:6:2: ineffectual assignment to x (ineffassign)

Supports advanced shadowing checks with .golangci.yml

linters:
  enable:
    - govet
    - predeclared
linters-settings:
  govet:
    check-shadowing: true
    settings:
      shadow:
        strict: true
    enable-all: true

Choosing a Right Linter for Your Team🔗

Tool	Best For
`go vet`	Basic, built-in checks
`staticcheck`	Comprehensive analysis with minimal false positives
`revive`	Style and naming conventions with configurability
`golangci-lint`	Running multiple linters efficiently

Recommendations🔗

Start with go vet in your automated builds
Add staticcheck for deeper analysis with fewer false positives
Use revive if you need customizable rules for code quality
Adopt golangci-lint once you're comfortable managing multiple linters
Standardize configuration and commit them to source control to maintain consistency across developers

Using govulncheck to Scan for Vulnerable Dependencies🔗

govulncheck scans through dependencies and finds known vulnerabilities in both the standard library and in third-party libraries imported modules.
Installation: go install golang.org/x/vuln/cmd/govulncheck@latest
To fix vulnerability : go get -u=patch gopkg.in/yaml.v2
govulncheck ./...
Ideally should be randomly changed or updated as it may break compatibility for your package.

Embedding Content in Your Program🔗

Ideally all required files might be put in a directory and binary that go compiles can read from the directory.
In some scenarios you may want to embed those files for distribution in the binary using go:embed

Example: embedding list of most common 1000 passwords, * import embed package * magic comment //go:embed <file_name> embeds the content of a file in the variables

package main

import (
    _ "embed"
    "fmt"
    "os"
    "strings"
)

//go:embed passwords.txt
var passwords string

func main() {
    pwds := strings.Split(passwords, "\n")
    if len(os.Args) > 1 {
        for _, v := range pwds {
            if v == os.Args[1] {
                fmt.Println("true")
                os.Exit(0)
            }
        }
        fmt.Println("false")
    }
}

To embed one or more directories of files into your program, use a variable of type embed.FS which implements three interfaces defined in io/fs package : FS, ReadDirFS and ReadFileFS.
embed.FS can represent a virtual file system this way.

In additional to exact file and directory names, we can use wildcards and ranges as well in embed

// Example of hel based on the file present
package main

import (
    "embed"
    "fmt"
    "io/fs"
    "os"
    "strings"
)

//go:embed help
var helpInfo embed.FS

func main() {
    if len(os.Args) == 1 {
        printHelpFiles()
        os.Exit(0)
    }
    data, err := helpInfo.ReadFile("help/" + os.Args[1])
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println(string(data))
}

$ **go build**
$ **./help_system**
contents:
advanced/topic1.txt
advanced/topic2.txt
info.txt

$ **./help_system advanced/topic1.txt**
This is advanced topic 1.

$ **./help_system advanced/topic3.txt**
open help/advanced/topic3.txt: file does not exist

Embedding Hidden Files🔗

hidden files in directory tree that start with . or _ are difficult to embed. Default Embedding ignores them.
This behaviour can be override by 2 methods * put /* after the name of a directory you want to embed (does not include hidden files in subdirectory) * all: includes all files
```
//go:embed parent_dir
var noHidden embed.FS

//go:embed parent_dir/*
var parentHiddenOnly embed.FS

//go:embed all:parent_dir
var allHidden embed.FS
```

Using go generate🔗

go generate scans Go source files for special comments (`//go:generate ...) and executes the specified commands
Typically used for code generation tasks, such as creating Go source files from schemas or definitions
Example: Generating Go Code from Protobuf * Protobuf (Protocol Buffers) is a binary format used for data serialization. * Define a schema (.proto file), then use protoc and protoc-gen-go to generate Go code. * //go:generate protoc -I=. --go_out=. --go_opt=module=github.com/learning-go/proto_generate person.proto * Run with $ go generate ./..., which generates a .pb.go file with the necessary structs and methods.
Using stringer for Enums * Go’s iota does not provide automatic string representations for enums. * stringer generates a .go file that implements String() for enum values. * Example command: //go:generate stringer -type=Direction * Running $ go generate ./... creates direction_string.go, allowing enums to be printed as strings.
Other Use Cases for go generate * Generating mocks for testing. * Embedding assets or templates. * Automating repetitive code transformations.
Blog Post

Working with go generate and Makefiles🔗

go generate is used to mechanically create source code (e.g., for protobufs, stringer).
It should be included in version control for transparency and easier builds.
Best practice: Automate go generate in the Makefile to avoid forgetting to update generated code.
Avoid automating it if it generates different outputs for identical inputs or takes too long.

Reading the Build Info Inside a Go Binary🔗

go build embeds build info in the binary, including module versions and Git revision.
Use go version -m <binary> to inspect this metadata.
govulncheck can scan Go binaries for known vulnerabilities.
This helps in tracking software versions and dependencies in production environments.

Building Go Binary for Other Platforms🔗

Go supports cross-compilation using GOOS and GOARCH environment variables.
Example: GOOS=linux GOARCH=amd64 go build builds a Linux binary on macOS.
Supported OS/architecture combinations can be found in Go’s documentation.

Using Build Tags🔗

Used for conditional compilation based on OS, architecture, Go version, or custom flags.
Two methods: * Filename convention (e.g., file_linux.go for Linux-specific code). * Build tags (//go:build <condition> before package declaration).
Custom build tags allow selective compilation with -tags flag (e.g., go build -tags customtag).

Testing Version of Go🔗

Use go install golang.org/dl/go<version>@latest to install different Go versions.
Run go<version> download and use go<version> build to test compatibility. Ex : go1.19.2 build
Uninstall by deleting the Go version from the sdk directory.

Using go help to Learn more about Go Tooling🔗

you can get information on import path syntax by typing go help importpath
you can get information about any tooling using go help