# Using official installer
# Download .pkg from golang.org/dl and install

# Or using Homebrew (alternative)
brew install go

# Remove any existing Go installation
sudo rm -rf /usr/local/go

# Download and extract
wget https://golang.org/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

# Add to PATH (add to ~/.bashrc or ~/.zshrc)
export PATH=$PATH:/usr/local/go/bin

# Using dnf/yum
sudo dnf install golang
# or
sudo yum install golang

# Manual installation (recommended for latest version)
wget https://golang.org/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

# Install g (Go version manager)
curl -sSL https://git.io/g-install | sh -s

# Install latest Go
g install latest

# Install specific version
g install 1.21.5

# Switch versions
g use 1.21.5

# Check GOROOT
go env GOROOT
# Output: /usr/local/go (Linux/macOS) or C:\Go (Windows)

# Set GOPATH (optional in module mode)
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

# Enable module mode (default in Go 1.16+)
export GO111MODULE=on

# PowerShell (permanent)
[Environment]::SetEnvironmentVariable("GOPATH", "C:\Users\YourName\go", "User")
[Environment]::SetEnvironmentVariable("PATH", $env:PATH + ";C:\Program Files\Go\bin", "User")

# Command Prompt (session only)
set GOPATH=C:\Users\YourName\go
set PATH=%PATH%;C:\Program Files\Go\bin

# Add to ~/.bashrc, ~/.zshrc, or ~/.profile
export GOPATH=$HOME/go
export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
export GO111MODULE=on

# Reload configuration
source ~/.bashrc

# Verify Go installation
go version
# Expected output: go version go1.21.5 linux/amd64

# Check environment
go env

# Test compilation
echo 'package main
import "fmt"
func main() {
    fmt.Println("Go is working!")
}' > test.go

go run test.go
# Output: Go is working!

rm test.go

#!/bin/bash
echo "=== Go Environment Check ==="
echo "Go Version: $(go version)"
echo "GOROOT: $(go env GOROOT)"
echo "GOPATH: $(go env GOPATH)"
echo "GOOS: $(go env GOOS)"
echo "GOARCH: $(go env GOARCH)"
echo "Module Mode: $(go env GO111MODULE)"
echo "Proxy: $(go env GOPROXY)"

# Create project directory (anywhere)
mkdir ~/projects/my-go-app
cd ~/projects/my-go-app

# Initialize Go module
go mod init github.com/username/my-go-app

# Create main.go
cat > main.go << 'EOF'
package main

import "fmt"

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

# Run the application
go run main.go

# Create GOPATH structure
mkdir -p $GOPATH/src/github.com/username
mkdir -p $GOPATH/bin
mkdir -p $GOPATH/pkg

# Project structure
$GOPATH/
├── bin/          # Compiled binaries
├── pkg/          # Package objects
└── src/          # Source code
    └── github.com/username/
        └── myproject/
            └── main.go

# Install extension
code --install-extension golang.go

# Install Go tools (run in VS Code terminal)
go install -a github.com/cweill/gotests/gotests@latest
go install -a github.com/fatih/gomodifytags@latest
go install -a github.com/josharian/impl@latest
go install -a github.com/haya14busa/goplay/cmd/goplay@latest
go install -a github.com/go-delve/delve/cmd/dlv@latest
go install -a honnef.co/go/tools/cmd/staticcheck@latest

// settings.json
{
    "go.useLanguageServer": true,
    "go.formatTool": "goimports",
    "go.lintTool": "golangci-lint",
    "go.testFlags": ["-v"],
    "go.coverOnSave": true,
    "go.coverageDecorator": {
        "type": "highlight",
        "coveredHighlightColor": "rgba(64,128,128,0.5)",
        "uncoveredHighlightColor": "rgba(128,64,64,0.25)"
    }
}

" Install vim-go plugin
Plug 'fatih/vim-go', { 'do': ':GoUpdateBinaries' }

" Configuration
let g:go_fmt_command = "goimports"
let g:go_highlight_types = 1
let g:go_highlight_fields = 1
let g:go_highlight_functions = 1

;; Install go-mode
(use-package go-mode
  :ensure t
  :hook (go-mode . lsp-deferred))

;; Install lsp-mode for Language Server Protocol
(use-package lsp-mode
  :ensure t
  :commands (lsp lsp-deferred))

# Format code
go fmt ./...

# Import management
go get golang.org/x/tools/cmd/goimports
goimports -w .

# Vet (static analysis)
go vet ./...

# Testing
go test ./...

# Build
go build

# Install
go install

# Air (live reload)
go install github.com/cosmtrek/air@latest

# gotests (generate tests)
go install github.com/cweill/gotests/gotests@latest

# impl (interface implementation)
go install github.com/josharian/impl@latest

# golangci-lint (comprehensive linter)
curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.54.2

# staticcheck
go install honnef.co/go/tools/cmd/staticcheck@latest

# ineffassign
go install github.com/gordonklaus/ineffassign@latest

# Delve debugger
go install github.com/go-delve/delve/cmd/dlv@latest

# Usage
dlv debug main.go

linters-settings:
  govet:
    check-shadowing: true
  golint:
    min-confidence: 0
  dupl:
    threshold: 100
  goconst:
    min-len: 2
    min-occurrences: 2

linters:
  enable:
    - megacheck
    - govet
    - golint
    - ineffassign
    - misspell
    - gocyclo
    - dupl
    - goconst
    - goimports

# .air.toml
root = "."
cmd = "go build -o ./tmp/main ."
bin = "./tmp/main"
full_bin = "./tmp/main"
include_ext = ["go", "tpl", "tmpl", "html"]
exclude_dir = ["assets", "tmp", "vendor"]
include_dir = []
exclude_file = []
delay = 1000
stop_on_exit = false
log = "air_errors.log"

my-go-project/
├── cmd/                    # Main applications
│   └── myapp/
│       └── main.go
├── internal/               # Private application code
│   ├── app/
│   ├── pkg/
│   └── models/
├── pkg/                    # Public library code
│   └── utils/
├── api/                    # API definitions
├── web/                    # Web assets
├── configs/                # Configuration files
├── deployments/            # Deployment configurations
├── test/                   # Additional test data
├── docs/                   # Documentation
├── scripts/                # Build and development scripts
├── .gitignore
├── .golangci.yml
├── .air.toml
├── Dockerfile
├── Makefile
├── README.md
├── go.mod
└── go.sum

.PHONY: build test clean lint run

# Build the application
build:
	go build -o bin/myapp cmd/myapp/main.go

# Run tests
test:
	go test -v ./...

# Run tests with coverage
test-coverage:
	go test -v -coverprofile=coverage.out ./...
	go tool cover -html=coverage.out -o coverage.html

# Lint the code
lint:
	golangci-lint run

# Format code
fmt:
	gofmt -s -w .
	goimports -w .

# Run the application
run:
	go run cmd/myapp/main.go

# Clean build artifacts
clean:
	rm -rf bin/
	rm -f coverage.out coverage.html

# Install dependencies
deps:
	go mod download
	go mod tidy

# Update dependencies
update:
	go get -u ./...
	go mod tidy

# Multi-stage build
FROM golang:1.21-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main cmd/myapp/main.go

# Final stage
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
CMD ["./main"]

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - GO_ENV=development
    volumes:
      - .:/app
    working_dir: /app
    command: air
  
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"

# Error: package is not in GOPATH
# Solution: Use modules instead
go mod init myproject

# Or set GOPATH correctly
export GOPATH=$HOME/go

# Clear module cache
go clean -modcache

# Sync dependencies
go mod tidy

# Verify modules
go mod verify

# Fix Go bin directory permissions
sudo chown -R $(whoami) $(go env GOPATH)/bin

# Or install to user directory
export GOBIN=$HOME/go/bin

# Optimized build
go build -ldflags="-s -w" -o myapp

# Static binary
CGO_ENABLED=0 go build -a -ldflags '-extldflags "-static"' .

# Cross-compilation
GOOS=linux GOARCH=amd64 go build -o myapp-linux
GOOS=windows GOARCH=amd64 go build -o myapp.exe