# Remove any existing Go installation
sudo pacman -R go  # if installed via pacman
sudo rm -rf /usr/local/go  # remove any manual installations

# Download latest Go (check https://golang.org/dl/ for current version)
wget https://go.dev/dl/go1.24.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.24.5.linux-amd64.tar.gz

# Add to ~/.zshrc (or ~/.bashrc if using bash)
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.zshrc
echo 'export PATH=$PATH:$(go env GOPATH)/bin' >> ~/.zshrc
source ~/.zshrc

# Verify installation
go version  # Should show go version go1.24.5 linux/amd64

# Modern module-based development
go env -w GO111MODULE=on

# Faster dependency resolution
go env -w GOPROXY=https://proxy.golang.org,direct
go env -w GOSUMDB=sum.golang.org

# Private repository support (if needed)
go env -w GOPRIVATE=github.com/yourcompany/*

# Performance optimizations
go env -w GOCACHE=$HOME/.cache/go-build
go env -w GOMODCACHE=$HOME/go/pkg/mod

# Language server (provides IntelliSense, go-to-definition, etc.)
go install golang.org/x/tools/gopls@latest

# Debugger (essential for complex applications)  
go install github.com/go-delve/delve/cmd/dlv@latest

# Code formatting and imports
go install golang.org/x/tools/cmd/goimports@latest

# Advanced development tools
go install github.com/fatih/gomodifytags@latest    # Struct tag management
go install github.com/josharian/impl@latest        # Interface implementation generator
go install honnef.co/go/tools/cmd/staticcheck@latest # Advanced static analysis
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest # Comprehensive linting

{
    // Editor foundation
    "editor.fontFamily": "JetBrains Mono, Cascadia Code, Fira Code",
    "editor.fontSize": 14,
    "editor.fontWeight": "500",
    "editor.fontLigatures": true,
    
    // Theme optimized for Go syntax
    "workbench.colorTheme": "Monokai Pro",
    "workbench.iconTheme": "Material Icon Theme",
    
    // Automatic productivity features
    "files.autoSave": "afterDelay",
    "files.autoSaveDelay": 1000,
    "editor.formatOnSave": true,
    "editor.formatOnType": true,
    
    // Go-specific optimizations
    "go.useLanguageServer": true,
    "go.languageServerExperimentalFeatures": {
        "diagnostics": true,
        "documentLink": true
    },
    
    // Automatic code quality
    "go.formatTool": "goimports",
    "go.lintOnSave": "workspace",
    "go.vetOnSave": "workspace", 
    "go.buildOnSave": "workspace",
    
    // Testing integration
    "go.testFlags": ["-v", "-race"],
    "go.testTimeout": "30s",
    "go.coverOnSave": true,
    
    // Performance exclusions
    "files.watcherExclude": {
        "**/vendor/**": true,
        "**/bin/**": true,
        "**/.git/**": true
    },
    
    // GitHub Copilot optimization
    "github.copilot.enable": {
        "go": true,
        "go.mod": true
    }
}

{
    "go.delveConfig": {
        "dlvLoadConfig": {
            "followPointers": true,
            "maxVariableRecurse": 1,
            "maxStringLen": 64,
            "maxArrayValues": 64,
            "maxStructFields": -1
        },
        "apiVersion": 2,
        "showGlobalVariables": true
    }
}

my-go-service/
├── cmd/
│   └── server/
│       └── main.go          # Application entry point
├── internal/
│   ├── api/                 # HTTP handlers
│   ├── service/             # Business logic
│   └── repository/          # Data access
├── pkg/
│   └── utils/               # Reusable packages
├── configs/
│   └── config.yaml          # Configuration files
├── docker/
│   └── Dockerfile           # Container definition
├── go.mod                   # Module definition
├── go.sum                   # Dependency checksums
├── Makefile                 # Build automation
└── README.md               # Project documentation

build:
	go build -o bin/server cmd/server/main.go

test:
	go test -v -race ./...

coverage:
	go test -race -coverprofile=coverage.out ./...
	go tool cover -html=coverage.out

lint:
	golangci-lint run

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch Server",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${workspaceFolder}/cmd/server/main.go",
            "env": {
                "GO_ENV": "development"
            }
        }
    ]
}

"files.watcherExclude": {
    "**/vendor/**": true,
    "**/bin/**": true,
    "**/.git/**": true
}

"go.formatTool": "goimports",
"editor.formatOnSave": true

"go.testFlags": ["-v", "-race"],
"go.coverOnSave": true

{
    "go.experiments": {
        "workspaceModule": true
    },
    "go.useLanguageServer": true
}

{
    "name": "Go Development",
    "image": "mcr.microsoft.com/vscode/devcontainers/go:1.21",
    "features": {
        "ghcr.io/devcontainers/features/docker-in-docker:2": {}
    },
    "customizations": {
        "vscode": {
            "extensions": [
                "golang.go",
                "github.copilot"
            ]
        }
    }
}

# Update Go tools
go install golang.org/x/tools/gopls@latest
go install github.com/go-delve/delve/cmd/dlv@latest
go install golang.org/x/tools/cmd/goimports@latest

# Update linters
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Clean module cache if needed
go clean -modcache

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "go: build",
            "type": "shell",
            "command": "go",
            "args": ["build", "-o", "bin/server", "cmd/server/main.go"],
            "group": "build",
            "presentation": {
                "reveal": "silent"
            }
        },
        {
            "label": "go: run",
            "type": "shell",
            "command": "go",
            "args": ["run", "cmd/server/main.go"],
            "group": "build",
            "presentation": {
                "reveal": "always"
            }
        },
        {
            "label": "go: test",
            "type": "shell",
            "command": "go",
            "args": ["test", "-v", "./..."],
            "group": "test",
            "presentation": {
                "reveal": "always"
            }
        },
        {
            "label": "go: test with coverage",
            "type": "shell",
            "command": "go",
            "args": ["test", "-v", "-race", "-coverprofile=coverage.out", "./..."],
            "group": "test"
        },
        {
            "label": "go: mod tidy",
            "type": "shell",
            "command": "go",
            "args": ["mod", "tidy"],
            "group": "build"
        }
    ]
}

# Development Dockerfile
FROM golang:1.21-alpine AS development

# Install development dependencies
RUN apk add --no-cache git make bash curl

# Install development tools
RUN go install github.com/cosmtrek/air@latest
RUN go install github.com/go-delve/delve/cmd/dlv@latest

WORKDIR /app

# Copy go mod files
COPY go.mod go.sum ./
RUN go mod download

# Copy source code
COPY . .

# Expose ports
EXPOSE 8080 2345

# Use air for hot reload
CMD ["air"]

version: '3.8'
services:
  app:
    build:
      context: .
      target: development
    volumes:
      - .:/app
      - go-modules:/go/pkg/mod
    ports:
      - "8080:8080"
      - "2345:2345"  # Delve debugger
    environment:
      - GO_ENV=development
      - DATABASE_URL=postgres://dev:devpass@postgres:5432/myapp
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: devpass
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  go-modules:
  postgres_data:

{
    "go.inlayHints.assignVariableTypes": true,
    "go.inlayHints.compositeLiteralFields": true,
    "go.inlayHints.compositeLiteralTypes": true,
    "go.inlayHints.constantValues": true,
    "go.inlayHints.functionTypeParameters": true,
    "go.inlayHints.parameterNames": true,
    "go.inlayHints.rangeVariableTypes": true
}

{
    "github.copilot.enable": {
        "go": true,
        "go.mod": true,
        "go.sum": false
    },
    "github.copilot.advanced": {
        "listCount": 10,
        "inlineSuggestCount": 5
    }
}

// cmd/server/main.go
package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/iamdhakrey/myapi/internal/handler"
    "github.com/iamdhakrey/myapi/internal/service"
)

func main() {
    // Initialize services
    userService := service.NewUserService()
    userHandler := handler.NewUserHandler(userService)

    // Setup router
    r := gin.Default()
    api := r.Group("/api/v1")
    {
        api.POST("/users", userHandler.CreateUser)
        api.GET("/users/:id", userHandler.GetUser)
        api.PUT("/users/:id", userHandler.UpdateUser)
        api.DELETE("/users/:id", userHandler.DeleteUser)
    }

    // Graceful shutdown
    srv := &http.Server{
        Addr:    ":8080",
        Handler: r,
    }

    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("listen: %s\n", err)
        }
    }()

    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatal("Server forced to shutdown:", err)
    }
}

// cmd/root.go
package cmd

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var rootCmd = &cobra.Command{
    Use:   "mytool",
    Short: "A brief description of your application",
    Long:  `A longer description...`,
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

func init() {
    cobra.OnInitialize(initConfig)
    rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file")
}

func initConfig() {
    if cfgFile != "" {
        viper.SetConfigFile(cfgFile)
    } else {
        home, err := os.UserHomeDir()
        cobra.CheckErr(err)
        
        viper.AddConfigPath(home)
        viper.SetConfigType("yaml")
        viper.SetConfigName(".mytool")
    }

    viper.AutomaticEnv()

    if err := viper.ReadInConfig(); err == nil {
        fmt.Fprintln(os.Stderr, "Using config file:", viper.ConfigFileUsed())
    }
}

// Use object pools for frequently allocated objects
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 0, 1024)
    },
}

func processData(data []byte) {
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf[:0])
    
    // Use buf for processing
}

// Avoid memory leaks with slices
func safeSub(slice []int, start, end int) []int {
    result := make([]int, end-start)
    copy(result, slice[start:end])
    return result
}

// Worker pool pattern
func workerPool(jobs <-chan Job, results chan<- Result) {
    const numWorkers = 10
    
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processJob(job)
            }
        }()
    }
    
    go func() {
        wg.Wait()
        close(results)
    }()
}

# Reset Go extension
# Command Palette: "Go: Reset gopls workspace"

# Reinstall language server
go install -a golang.org/x/tools/gopls@latest

# Check Go environment
go env

# Verify GOPATH and GOROOT
echo $GOPATH
echo $GOROOT

# Clean module cache
go clean -modcache

# Verify module integrity
go mod verify

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

# Vendor dependencies (if needed)
go mod vendor

# Profile your application
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# Check for race conditions
go test -race ./...

# Memory profiling
go tool pprof http://localhost:6060/debug/pprof/heap

{
    "HTTP Handler": {
        "prefix": "httphandler",
        "body": [
            "func ${1:handlerName}(w http.ResponseWriter, r *http.Request) {",
            "    ${2:// Implementation}",
            "    w.Header().Set(\"Content-Type\", \"application/json\")",
            "    w.WriteHeader(http.StatusOK)",
            "    json.NewEncoder(w).Encode(${3:response})",
            "}"
        ]
    },
    "Error Check": {
        "prefix": "iferr",
        "body": [
            "if err != nil {",
            "    ${1:return err}",
            "}"
        ]
    },
    "Table Test": {
        "prefix": "tabletest",
        "body": [
            "tests := []struct {",
            "    name string",
            "    ${2:args}",
            "    want ${3:type}",
            "    wantErr bool",
            "}{",
            "    {",
            "        name: \"${4:test case}\",",
            "        ${5:// test data}",
            "    },",
            "}",
            "",
            "for _, tt := range tests {",
            "    t.Run(tt.name, func(t *testing.T) {",
            "        ${6:// test implementation}",
            "    })",
            "}"
        ]
    }
}