Installation & Setup

# Method 1: Homebrew (recommended)
brew install go

# Method 2: Official installer
# Download from https://go.dev/dl/
# Run the .pkg installer → Go installs to /usr/local/go

# Verify installation
go version
# Output: go version go1.22.0 darwin/arm64

# Download the latest tarball (check go.dev/dl for the latest version)
wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz

# Remove any previous Go installation & extract
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz

# Add Go to PATH — add this to ~/.bashrc or ~/.zshrc
export PATH=$PATH:/usr/local/go/bin

# Reload your shell
source ~/.bashrc   # or source ~/.zshrc

# Verify
go version
# go version go1.22.0 linux/amd64

# Method 1: winget (Windows Package Manager)
winget install GoLang.Go

# Method 2: Official installer
# Download go1.22.0.windows-amd64.msi from go.dev/dl
# Run the installer — it automatically sets PATH

# Method 3: Chocolatey
choco install golang

# Verify in PowerShell or Command Prompt
go version
# go version go1.22.0 windows/amd64

# Inspect all Go environment variables
go env

# Check specific variables
go env GOROOT    # /usr/local/go
go env GOPATH    # /Users/you/go
go env GOBIN     # /Users/you/go/bin
go env GOPROXY   # https://proxy.golang.org,direct
go env GOMAXPROCS # number of CPU cores (default for concurrency)

# Add $GOPATH/bin to PATH so installed tools are executable
# Add this to ~/.zshrc or ~/.bashrc:
export PATH=$PATH:$(go env GOPATH)/bin

# Create a new project directory
mkdir myapp && cd myapp

# Initialise the module
go mod init github.com/yourname/myapp
# Creates go.mod with module path and Go version

# go.mod contents:
# module github.com/yourname/myapp
#
# go 1.22.0

# Add a dependency
go get github.com/pkg/errors@v0.9.1
# Updates go.mod and creates/updates go.sum

# Download all dependencies (if cloning a project)
go mod download

# Remove unused dependencies, add missing ones
go mod tidy

module github.com/yourname/myapp   // Module path — globally unique identifier

go 1.22.0                          // Minimum Go version required

require (
    github.com/pkg/errors v0.9.1           // Direct dependency
    github.com/stretchr/testify v1.9.0     // Direct dependency (for tests)
)

require (
    github.com/davecgh/go-spew v1.1.1  // indirect — pulled by testify
    github.com/pmezard/go-difflib v1.0.0 // indirect
) 

# Format:  /go.mod 
#           
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt38=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

v1.2.3
 │ │ └── Patch: backward-compatible bug fixes
 │ └──── Minor: backward-compatible new features
 └────── Major: breaking changes (v2+ requires a module path change)

// go.mod for v2
module github.com/yourname/myapp/v2

// Import path in code also includes /v2
import "github.com/yourname/myapp/v2/pkg/something"

# Step 1: Create project
mkdir hello-go && cd hello-go
go mod init hello

# Step 2: Create main.go
cat > main.go << 'EOF'
package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}
EOF

# Step 3: Run it
go run main.go

package main           // Every Go file belongs to a package
                       // "main" is special: it defines an executable program

import "fmt"           // Import the fmt package from the standard library
                       // Unused imports are compile errors

func main() {          // Entry point — Go programs always start here
                       // No arguments, no return value
    fmt.Println("Hello, Go!")
    // Println: prints with a newline
    // fmt.Printf: formatted printing (like C's printf)
    // fmt.Fprintf: write to an io.Writer
}

go run main.go           # Run a single file
go run .                 # Run the package in the current directory
go run ./cmd/server/     # Run a specific package by directory path
go run -race main.go     # Run with the race detector enabled

# go run compiles every time — not cached for execution
# Use for development and quick experiments only

go build                      # Build current package, put binary here
go build -o myserver .        # Name the output binary
go build ./...                # Build all packages in all subdirectories

# Cross-compilation — build for a different OS/arch
GOOS=linux   GOARCH=amd64  go build -o myapp-linux .
GOOS=windows GOARCH=amd64  go build -o myapp.exe .
GOOS=darwin  GOARCH=arm64  go build -o myapp-mac-arm .

# Build flags for production
go build \
    -ldflags="-s -w" \     # Strip debug symbols (smaller binary)
    -trimpath \            # Remove local file paths from binary
    -o myserver \
    .

# -s: omit symbol table
# -w: omit DWARF debug info
# Result: ~30% smaller binary

# Install a tool from a remote module
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
# Binary goes to $GOPATH/bin/golangci-lint

# Install a specific version
go install golang.org/x/tools/gopls@v0.15.0

# Install the current module's binary
go install .   # compiles and puts binary in $GOPATH/bin

go test ./...                   # Run all tests in all packages
go test -v ./...                # Verbose: show each test name
go test -run TestMyFunc ./...   # Run only tests matching a pattern
go test -race ./...             # Run with race detector
go test -count=1 ./...          # Disable test caching (always re-run)
go test -cover ./...            # Show code coverage percentage
go test -coverprofile=c.out ./...  # Write coverage profile to file
go tool cover -html=c.out       # Open coverage in browser

# Benchmarks
go test -bench=. ./...          # Run all benchmarks
go test -bench=BenchmarkFoo -benchmem ./...  # With memory stats

# Run a specific test file
go test -v -run TestSpecific ./pkg/mypackage/

go fmt ./...        # Format all .go files in project (modifies in place)
gofmt -d main.go    # Show diff of what would change (don't modify)
gofmt -l ./...      # List files that need formatting
gofmt -w main.go    # Write changes to file

# goimports: also manages imports (adds/removes) — install separately
go install golang.org/x/tools/cmd/goimports@latest
goimports -w main.go

go vet ./...     # Run all built-in static analysis checks

// go vet catches bugs like:
// - Wrong Printf format strings: Printf("%d", "hello") // ← wrong type
// - Unreachable code
// - Mutex copied by value
// - Calls to sync.Mutex in wrong order
// - Struct tags with invalid syntax
// - Incorrect use of sync.Locker

// Example of what go vet catches:
package main

import "fmt"

func main() {
    name := "Alice"
    fmt.Printf("Hello %d\n", name) // go vet: Printf format %d has arg name of wrong type string
}

go mod init github.com/user/project   # Create go.mod
go mod tidy                           # Add missing, remove unused deps
go mod download                       # Download all deps to module cache
go mod verify                         # Verify checksums in go.sum
go mod graph                          # Print dependency graph
go mod why -m github.com/pkg/errors   # Why is this dependency needed?
go mod vendor                         # Copy deps to ./vendor/ directory

# Upgrading dependencies
go get github.com/some/package@latest      # Latest version
go get github.com/some/package@v1.2.3     # Specific version
go get -u ./...                            # Upgrade all deps to latest minor/patch
go get -u=patch ./...                      # Upgrade all deps to latest patch only

go doc fmt              # Show package-level docs for fmt
go doc fmt.Printf       # Show docs for a specific function
go doc -all fmt         # Show all exported symbols with docs
go doc net/http.Server  # Show docs for a type
go doc -src fmt.Println # Show the actual source code

# Start local doc server (browse stdlib like godoc.org)
go install golang.org/x/tools/cmd/godoc@latest
godoc -http=:6060
# Open http://localhost:6060 in browser

{
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.organizeImports": "explicit"
  },
  "[go]": {
    "editor.defaultFormatter": "golang.go",
    "editor.tabSize": 4,
    "editor.insertSpaces": false   // Go uses tabs, not spaces!
  },
  "go.useLanguageServer": true,
  "go.lintTool": "golangci-lint",
  "go.lintOnSave": "workspace",
  "go.testFlags": ["-v", "-race"],
  "go.coverOnSave": false,
  "go.toolsManagement.autoUpdate": true
}