Go Command — Optimize the Code¶

#!/bin/bash
# Fast version — leverage Go's build cache

# Use a persistent cache directory in CI
export GOCACHE="/tmp/go-build-cache"

# Build with cache (only recompiles changed packages)
go build ./...

# Run tests (use cache for unchanged tests)
go test ./...

#!/bin/bash
# Fast version — let the test cache work for you

# Run all tests with caching (only re-runs tests for changed packages)
go test ./...

# Only use -count=1 when you specifically need uncached results
# e.g., tests that depend on external services or time
go test -count=1 ./internal/integration/...

# For flaky test investigation only:
# go test -count=3 ./internal/parser/... -run TestFlakyFunction

#!/bin/bash
# Fast version — clean dependency management

# Step 1: Remove unused dependencies and add missing ones
go mod tidy

# Step 2: Verify the module graph is consistent
go mod verify

# Step 3: Download only what's needed
go mod download

# Step 4: Check for any remaining issues
go mod graph | wc -l    # should show fewer nodes

# Optional: vendor dependencies for reproducible builds
# go mod vendor

#!/bin/bash
# Fast version — maximize parallelism for independent tests

# Use -p to control package-level parallelism (default is GOMAXPROCS)
# Use -parallel to control test-level parallelism within each package
go test -p 8 -parallel 4 ./...

# For CI with known core count:
# go test -p $(nproc) -parallel $(( $(nproc) / 2 )) ./...

#!/bin/bash
# Fast version — lean production binary

# Strip debug info, symbols, and filesystem paths
go build -trimpath -ldflags="-s -w" -o myapp ./cmd/myapp

# Check the binary size
ls -lh myapp
# -rwxr-xr-x  1 user  staff  19M  myapp

# Optional: compress with UPX for even smaller binaries
# upx --best myapp
# -rwxr-xr-x  1 user  staff  6.8M  myapp

# Deploy to 50 containers
docker build -t myapp:latest .
# Each container ships a 19MB binary (or 6.8MB with UPX)

#!/bin/bash
# Fast version — parallel cross-compilation with shared cache

PLATFORMS=(
    "linux/amd64"
    "linux/arm64"
    "darwin/amd64"
    "darwin/arm64"
    "windows/amd64"
    "windows/arm64"
)

# Ensure output directory exists
mkdir -p dist

# Pre-compile shared dependencies (platform-independent analysis)
go build -v ./cmd/myapp 2>/dev/null

# Run all cross-compilations in parallel
PIDS=()
for platform in "${PLATFORMS[@]}"; do
    IFS='/' read -r GOOS GOARCH <<< "$platform"
    (
        GOOS=$GOOS GOARCH=$GOARCH CGO_ENABLED=0 \
        go build -trimpath -ldflags="-s -w" \
            -o "dist/myapp-${GOOS}-${GOARCH}" ./cmd/myapp
    ) &
    PIDS+=($!)
done

# Wait for all builds to complete
FAILED=0
for pid in "${PIDS[@]}"; do
    wait "$pid" || FAILED=$((FAILED + 1))
done

if [ $FAILED -gt 0 ]; then
    echo "ERROR: $FAILED build(s) failed"
    exit 1
fi

echo "All builds completed successfully"
ls -lh dist/

#!/bin/bash
# Fast version — single-pass coverage collection

mkdir -p coverage

# Collect coverage across ALL packages in a single invocation
# -coverpkg=./... ensures coverage is tracked across package boundaries
go test -coverprofile=coverage/total.out \
        -covermode=atomic \
        -coverpkg=./... \
        -p 4 \
        ./...

# Generate HTML report directly
go tool cover -html=coverage/total.out -o coverage/report.html

# Generate function coverage summary
go tool cover -func=coverage/total.out | tail -1

# Alternative: Use Go 1.20+ binary coverage format for even faster processing
# go test -cover -covermode=atomic -coverpkg=./... \
#         -args -test.gocoverdir=coverage/binary ./...
# go tool covdata textfmt -i=coverage/binary -o=coverage/total.out

#!/bin/bash
# Fast CI stage — runs on every commit (< 30 seconds)
go test -short ./...

# Full CI stage — runs on PR merge or nightly
# go test -v ./...

#!/bin/bash
# Fast version — tuned GC for large builds

# Option 1: Increase GOGC to reduce GC frequency
# GOGC=300 means GC triggers when heap grows to 4x live data
export GOGC=300

# Option 2 (Go 1.19+): Use GOMEMLIMIT for memory-based GC control
# Set to 80% of available memory to prevent OOM while reducing GC
export GOMEMLIMIT=6GiB    # on an 8GB CI runner

# Option 3: For maximum build speed with plenty of RAM
# GOGC=off disables GC entirely (use only with GOMEMLIMIT!)
# export GOGC=off
# export GOMEMLIMIT=12GiB

# Build with tuned GC
go build ./...

# Tests also benefit from GOGC tuning
go test ./...

# Reset for normal operation
unset GOGC
unset GOMEMLIMIT

#!/bin/bash
# Fast version — batched, cached, parallel code generation

set -euo pipefail

CACHE_DIR=".generate-cache"
mkdir -p "$CACHE_DIR"

# Function: check if source file changed since last generation
needs_regen() {
    local src="$1"
    local cache_file="$CACHE_DIR/$(echo "$src" | tr '/' '_').hash"
    local current_hash=$(sha256sum "$src" | cut -d' ' -f1)

    if [ -f "$cache_file" ] && [ "$(cat "$cache_file")" = "$current_hash" ]; then
        return 1  # no regeneration needed
    fi
    echo "$current_hash" > "$cache_file"
    return 0  # needs regeneration
}

# Step 1: Batch protobuf generation (single protoc invocation)
PROTO_FILES=()
for proto in api/proto/*.proto; do
    if needs_regen "$proto"; then
        PROTO_FILES+=("$proto")
    fi
done

if [ ${#PROTO_FILES[@]} -gt 0 ]; then
    echo "Generating protobuf for ${#PROTO_FILES[@]} files..."
    protoc --go_out=. --go-grpc_out=. "${PROTO_FILES[@]}" &
    PROTO_PID=$!
else
    echo "Protobuf: no changes detected, skipping"
    PROTO_PID=""
fi

# Step 2: Batch mock generation
MOCK_CHANGED=false
for src in internal/service/*_service.go; do
    if needs_regen "$src"; then
        MOCK_CHANGED=true
        break
    fi
done

if [ "$MOCK_CHANGED" = true ]; then
    echo "Generating mocks..."
    # Use mockgen with multiple source files
    go run go.uber.org/mock/mockgen@latest \
        -source=internal/service/user_service.go \
        -destination=internal/service/mock_service.go \
        -package=service &
    MOCK_PID=$!
else
    echo "Mocks: no changes detected, skipping"
    MOCK_PID=""
fi

# Step 3: Batch stringer generation
STRINGER_CHANGED=false
for src in internal/model/*.go; do
    if needs_regen "$src"; then
        STRINGER_CHANGED=true
        break
    fi
done

if [ "$STRINGER_CHANGED" = true ]; then
    echo "Generating stringers..."
    go run golang.org/x/tools/cmd/stringer@latest \
        -type=Status,OrderStatus,PaymentStatus \
        ./internal/model/ &
    STRINGER_PID=$!
else
    echo "Stringers: no changes detected, skipping"
    STRINGER_PID=""
fi

# Wait for all parallel generators
for pid in $PROTO_PID $MOCK_PID $STRINGER_PID; do
    [ -n "$pid" ] && wait "$pid"
done

echo "Code generation complete"

#!/bin/bash
# Fast version — smart tag matrix with pairwise coverage

set -euo pipefail

RESULTS_DIR="test-results"
mkdir -p "$RESULTS_DIR"
PIDS=()
FAILED=0

run_test() {
    local name="$1"
    local tags="$2"
    local run_filter="${3:-}"

    local args=(-tags "$tags" -count=1)
    [ -n "$run_filter" ] && args+=(-run "$run_filter")

    echo "Testing: $name (tags: $tags)"
    if go test "${args[@]}" ./... > "$RESULTS_DIR/$name.log" 2>&1; then
        echo "  PASS: $name"
    else
        echo "  FAIL: $name"
        return 1
    fi
}

# Phase 1: Test each tag independently (runs in parallel)
# This catches single-tag bugs: 3 + 3 + 3 = 9 runs (not 27)
echo "=== Phase 1: Independent tag testing ==="

# Storage backends (test only storage-related tests)
for tag in sqlite postgres mysql; do
    run_test "storage-$tag" "$tag" "TestStorage|TestDB|TestStore" &
    PIDS+=($!)
done

# Cache backends (test only cache-related tests)
for tag in redis memcached inmemory; do
    run_test "cache-$tag" "$tag" "TestCache|TestSession" &
    PIDS+=($!)
done

# Crypto backends (test only crypto-related tests)
for tag in openssl boringcrypto standard; do
    run_test "crypto-$tag" "$tag" "TestCrypto|TestEncrypt|TestHash" &
    PIDS+=($!)
done

# Wait for Phase 1
for pid in "${PIDS[@]}"; do
    wait "$pid" || FAILED=$((FAILED + 1))
done
PIDS=()

echo ""
echo "=== Phase 2: Critical cross-cutting combinations ==="

# Phase 2: Test only combinations that are known to interact
# Based on pairwise testing — cover all pairs with minimum combinations
CRITICAL_COMBOS=(
    "sqlite,redis,standard"          # default/common combo
    "postgres,memcached,openssl"     # production combo
    "mysql,inmemory,boringcrypto"    # alternative combo
    "postgres,redis,boringcrypto"    # high-security production
)

for combo in "${CRITICAL_COMBOS[@]}"; do
    combo_name=$(echo "$combo" | tr ',' '-')
    run_test "combo-$combo_name" "$combo" &
    PIDS+=($!)
done

# Wait for Phase 2
for pid in "${PIDS[@]}"; do
    wait "$pid" || FAILED=$((FAILED + 1))
done

echo ""
echo "=== Results ==="
echo "Total test configurations: 13 (was 27)"
echo "Failed: $FAILED"

if [ $FAILED -gt 0 ]; then
    echo "Check logs in $RESULTS_DIR/ for details"
    exit 1
fi