Go Programming Expert (Go 1.24 / 1.25 Edition)

English | Bahasa Indonesia

---

<a name="english"></a>

English

Orchestration & Integration

Connects and orchestrates with domain skills:

• API Design & Protocols: api-design-expert, openapi-swagger-codegen-expert, and spec-driven-development-expert for gRPC/protobuf contract design, REST endpoints, and RFC 9457 Problem Details.
• Data Persistence: database-orm-expert for sqlc type-safe query generation, pgx/v5 connection pooling, and transactional data integrity.
• Realtime & Streaming: sse-websocket-streaming-expert for goroutine-backed streaming pipelines and low-latency WebSocket hubs.
• Testing & Quality: autonomous-tdd-debugger, e2e-testing-expert, and anti-slop for executing go test -v ./..., synthetic clock testing via testing/synctest, and strict error checking (if err != nil).
• Orchestration: brainstorming and zero-to-prod-orchestrator (Phase 4: Backend & APIs).

Description

Expert-level Go development for building high-performance microservices, concurrent pipelines, and production CLI tools. Covers Go 1.24+ and 1.25 features (Swiss Table maps, weak pointers, testing/synctest deterministic concurrency testing, tool directives in go.mod), structured logging with slog, enhanced ServeMux pattern routing, sqlc type-safe SQL, and robust worker pools.

Trigger Conditions

• Writing Go 1.24+ / 1.25+ microservices, APIs, or high-throughput distributed workers.
• Utilizing Go 1.24+ Swiss Table optimizations, weak pointers (weak.Pointer), or generic type aliases.
• Running deterministic concurrency tests using testing/synctest without flaky time.Sleep.
• Managing tool dependencies using the official tool directive in go.mod.
• Writing type-safe SQL with sqlc or connection-pooled PostgreSQL with pgx/v5.
• Building HTTP servers using standard net/http ServeMux method & wildcard routing.

---

Go 1.24 / 1.25 Core Architectural Features

1. Go 1.24+ Tool Dependencies in go.mod

Go 1.24 standardizes executable developer tooling dependencies directly in go.mod, eliminating legacy tools.go boilerplate:

# Add a tool dependency
go get -tool github.com/sqlc-dev/sqlc/cmd/sqlc@latest
go get -tool github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Run the tool directly
go tool sqlc generate
go tool golangci-lint run

// go.mod snippet
tool (
    github.com/sqlc-dev/sqlc/cmd/sqlc
    github.com/golangci/golangci-lint/cmd/golangci-lint
)

2. Weak Pointers (weak.Pointer) & In-Memory Caching

Go 1.24 introduces weak.Make() and weak.Pointer to reference heap objects without preventing the Garbage Collector from freeing them:

package cache

import (
    "sync"
    "weak"
)

type Session struct {
    UserID    string
    AuthToken string
}

type WeakSessionCache struct {
    mu    sync.RWMutex
    store map[string]weak.Pointer[Session]
}

func NewWeakSessionCache() *WeakSessionCache {
    return &WeakSessionCache{
        store: make(map[string]weak.Pointer[Session]),
    }
}

func (c *WeakSessionCache) Set(key string, session *Session) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.store[key] = weak.Make(session)
}

func (c *WeakSessionCache) Get(key string) (*Session, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()

    ptr, ok := c.store[key]
    if !ok {
        return nil, false
    }

    // Dereference: returns nil if GC reclaimed the session
    val := ptr.Value()
    if val == nil {
        return nil, false
    }
    return val, true
}

3. Deterministic Concurrency Testing with testing/synctest

Go 1.24 introduces testing/synctest (GOEXPERIMENT=synctest) to test concurrent code with virtual clocks:

package queue_test

import (
    "context"
    "testing"
    "testing/synctest"
    "time"
)

func TestWorkerTimeout(t *testing.T) {
    synctest.Run(func() {
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()

        resultChan := make(chan string, 1)

        go func() {
            // Virtual time advances instantaneously when all goroutines in the bubble are idle
            time.Sleep(10 * time.Second)
            resultChan <- "completed"
        }()

        select {
        case res := <-resultChan:
            t.Fatalf("unexpected success: %s", res)
        case <-ctx.Done():
            // Successfully verified timeout without waiting 5 real seconds!
            t.Log("Worker timed out deterministically")
        }
    })
}

4. Range-Over-Func Iterators (Go 1.24+ Standard)

Stream sequence processing with zero slice allocations:

package iterator

import "iter"

type Transaction struct {
    ID     string
    Amount int64
    Failed bool
}

// Custom iterator filtering successful transactions
func SuccessfulTransactions(txs []Transaction) iter.Seq[Transaction] {
    return func(yield func(Transaction) bool) {
        for _, tx := range txs {
            if !tx.Failed {
                if !yield(tx) {
                    return // Stop iteration early if consumer breaks
                }
            }
        }
    }
}

// Consumer loop
func TotalRevenue(txs []Transaction) int64 {
    var total int64
    for tx := range SuccessfulTransactions(txs) {
        total += tx.Amount
    }
    return total
}

5. HTTP Microservice with net/http ServeMux & log/slog

Zero-dependency HTTP server with method routing, path parameters, and structured JSON telemetry:

package main

import (
    "encoding/json"
    "log/slog"
    "net/http"
    "os"
)

type UserResponse struct {
    ID   string `json:"id"`
    Role string `json:"role"`
}

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
    slog.SetDefault(logger)

    mux := http.NewServeMux()

    // Method and path parameter matching
    mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"status":"healthy"}`))
    })

    mux.HandleFunc("GET /api/v1/users/{id}", func(w http.ResponseWriter, r *http.Request) {
        userID := r.PathValue("id")
        slog.Info("retrieving user profile", "user_id", userID, "remote_addr", r.RemoteAddr)

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(UserResponse{ID: userID, Role: "member"})
    })

    slog.Info("starting production server", "port", 8080)
    if err := http.ListenAndServe(":8080", mux); err != nil {
        slog.Error("server exited", "error", err)
        os.Exit(1)
    }
}

6. Type-Safe SQL with sqlc & pgx/v5

-- queries/users.sql
-- name: GetUser :one
SELECT id, name, email, created_at FROM users WHERE id = $1 LIMIT 1;

-- name: CreateUser :one
INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email, created_at;

// Consuming generated sqlc code
package handler

import (
    "context"
    "example/internal/db"
    "github.com/jackc/pgx/v5/pgxpool"
)

type UserHandler struct {
    queries *db.Queries
    pool    *pgxpool.Pool
}

func (h *UserHandler) Create(ctx context.Context, name, email string) (*db.User, error) {
    user, err := h.queries.CreateUser(ctx, db.CreateUserParams{
        Name:  name,
        Email: email,
    })
    if err != nil {
        return nil, err
    }
    return &user, nil
}

---

<a name="bahasa-indonesia"></a>

Bahasa Indonesia

Integrasi Orkestrasi

Terhubung dan mengorkestrasi bersama skill domain:

• Desain & Protokol API: api-design-expert, openapi-swagger-codegen-expert, dan spec-driven-development-expert untuk kontrak gRPC/protobuf, endpoint REST, dan spesifikasi RFC 9457 Problem Details.
• Persistensi Data: database-orm-expert untuk pembuatan query type-safe via sqlc, connection pooling pgx/v5, dan integritas transaksi database.
• Realtime & Streaming: sse-websocket-streaming-expert untuk pipeline streaming berbasis channel goroutine dan hub WebSocket berlatensi rendah.
• Pengujian & Kualitas: autonomous-tdd-debugger, e2e-testing-expert, dan anti-slop untuk eksekusi go test -v ./..., pengujian jam sintetis dengan testing/synctest, dan penegakan penanganan error ketat (if err != nil).
• Orkestrator Utama: brainstorming dan zero-to-prod-orchestrator (Fase 4: Backend & APIs).

Deskripsi

Panduan Go tingkat ahli untuk membangun microservices, pipeline konkurensi, dan CLI tool berkinerja tinggi. Mencakup fitur Go 1.24+ dan 1.25 (optimasi hash map Swiss Table, weak pointer, pengujian deterministik testing/synctest, direktif tool di go.mod), structured logging dengan slog, ServeMux net/http dengan pola pencocokan rute modern, sqlc untuk SQL type-safe, dan worker pool tangguh.

Kondisi Pemicu

• Menulis microservices atau backend API Go 1.24+/1.25+ berthroughput tinggi.
• Menggunakan optimasi hash map Swiss Table, weak pointer (weak.Pointer), atau generic type alias.
• Menjalankan pengujian konkurensi deterministik menggunakan testing/synctest tanpa time.Sleep yang rapuh.
• Mengelola dependensi perkakas pengembang secara resmi melalui direktif tool di go.mod.
• Menulis SQL type-safe dengan sqlc atau koneksi database PostgreSQL dengan pgx/v5.

---

Fitur Arsitektur Inti Go 1.24 / 1.25

1. Direktif Perkakas tool di go.mod (Standar Go 1.24+)

Go 1.24 menstandardisasi pelacakan perkakas dependensi biner langsung di dalam go.mod, menghapus trik lawas tools.go:

# Menambahkan dependensi tool
go get -tool github.com/sqlc-dev/sqlc/cmd/sqlc@latest
go get -tool github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Menjalankan tool langsung
go tool sqlc generate
go tool golangci-lint run

2. Weak Pointer (weak.Pointer) untuk Cache Memori Ramah GC

Go 1.24 menyediakan weak.Make() dan weak.Pointer untuk menunjuk memori tanpa menghalangi Garbage Collector membersihkannya:

package cache

import (
    "sync"
    "weak"
)

type SesiPengguna struct {
    UserID    string
    AuthToken string
}

type CacheSesiWeak struct {
    mu    sync.RWMutex
    store map[string]weak.Pointer[SesiPengguna]
}

func NewCacheSesiWeak() *CacheSesiWeak {
    return &CacheSesiWeak{
        store: make(map[string]weak.Pointer[SesiPengguna]),
    }
}

func (c *CacheSesiWeak) Set(kunci string, sesi *SesiPengguna) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.store[kunci] = weak.Make(sesi)
}

func (c *CacheSesiWeak) Get(kunci string) (*SesiPengguna, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()

    ptr, ada := c.store[kunci]
    if !ada {
        return nil, false
    }

    // Dereferensi: mengembalikan nil jika GC telah mengumpulkan memori sesi
    nilai := ptr.Value()
    if nilai == nil {
        return nil, false
    }
    return nilai, true
}

3. Pengujian Konkurensi Determinis Menggunakan testing/synctest

Go 1.24 memperkenalkan testing/synctest untuk menguji alur waktu asinkron dengan jam virtual seketika:

package antrean_test

import (
    "context"
    "testing"
    "testing/synctest"
    "time"
)

func TestBatasWaktuPekerja(t *testing.T) {
    synctest.Run(func() {
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()

        hasilChan := make(chan string, 1)

        go func() {
            // Waktu virtual maju seketika saat seluruh goroutine menganggur
            time.Sleep(10 * time.Second)
            hasilChan <- "sukses"
        }()

        select {
        case hasil := <-hasilChan:
            t.Fatalf("alur gagal: menerima data di luar batas waktu %s", hasil)
        case <-ctx.Done():
            // Berhasil diverifikasi tanpa menunggu 5 detik waktu riil!
            t.Log("Pekerja berhasil timeout secara deterministik")
        }
    })
}

4. Iterator Range-Over-Func

Pemrosesan koleksi secara streaming tanpa alokasi memori berlebih:

package iterator

import "iter"

type Transaksi struct {
    ID     string
    Nominal int64
    Gagal   bool
}

func TransaksiSukses(daftar []Transaksi) iter.Seq[Transaksi] {
    return func(yield func(Transaksi) bool) {
        for _, tx := range daftar {
            if !tx.Gagal {
                if !yield(tx) {
                    return
                }
            }
        }
    }
}