go-programming-expert

Go Programming Expert (Go 1.25 Edition)

English | Bahasa Indonesia

---

English

Orchestration & Integration

Connects and orchestrates with relevant domain skills like brainstorming, zero-to-prod-orchestrator, and project-context-mapper to ensure cohesive execution.

Description

Expert-level Go development for building high-performance microservices, APIs, and CLI tools. Covers Go 1.25 features (range-over-func iterators, generic type aliases, weak pointers), structured logging with slog, net/http with the new ServeMux patterns, Gin/Echo/Fiber frameworks, sqlc for type-safe SQL, gRPC, and production testing patterns.

Trigger Conditions

• Writing Go 1.24+ / 1.25+ microservices or APIs.
• Implementing concurrency patterns with goroutines, channels, and sync primitives.
• Using structured logging with log/slog.
• Building HTTP servers with net/http ServeMux (Go 1.22+) or Gin/Echo/Fiber.
• Writing type-safe SQL with sqlc or using GORM.
• Implementing gRPC services with protobuf.
• Writing Go tests with the standard testing package + testify.

Go 1.25 — Key Features

Range-Over-Func (Go 1.22 → Stable in 1.24/1.25)

Range over custom iterators — enables functional-style collection operations:

// Define an iterator function
func Fibonacci() iter.Seq[int] {
    return func(yield func(int) bool) {
        a, b := 0, 1
        for {
            if !yield(a) {
                return
            }
            a, b = b, a+b
        }
    }
}

// Range over it naturally
for n := range Fibonacci() {
    if n > 100 {
        break
    }
    fmt.Println(n)
}

Generic Type Aliases (Go 1.24/1.25)

// Type alias with generic parameters
type Set[T comparable] = map[T]struct{}
type Result[T any] = struct{ Value T; Err error }

// Usage
var s Set[string] = make(map[string]struct{})

Weak Pointers (Go 1.24/1.25)

import "weak"

// Weak pointer — does not prevent GC collection
ptr := weak.Make(&myStruct{})
if val := ptr.Value(); val != nil {
    // Still alive
}