if Statement — Optimization Exercises¶

package main

import "fmt"

func isEligible(age int, hasLicense bool) bool {
    return hasLicense && age >= 18
}

func main() {
    fmt.Println(isEligible(20, true))  // true
    fmt.Println(isEligible(16, true))  // false
    fmt.Println(isEligible(20, false)) // false
}

func createOrder(w http.ResponseWriter, r *http.Request) {
    user := getUser(r)
    if user == nil {
        http.Error(w, "unauthorized", 401)
        return
    }
    if !user.IsActive {
        http.Error(w, "user is inactive", 403)
        return
    }
    var req OrderRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "invalid JSON", 400)
        return
    }
    if len(req.Items) == 0 {
        http.Error(w, "items cannot be empty", 400)
        return
    }
    if req.Total <= 0 {
        http.Error(w, "total must be positive", 400)
        return
    }
    // Happy path — all guards passed
    order := processOrder(user, req)
    json.NewEncoder(w).Encode(order)
}

func loadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("loadConfig: %w", err)
    }

    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("loadConfig: %w", err)
    }

    return &cfg, nil
}

func processRequest(r *http.Request) {
    if body, err := io.ReadAll(r.Body); err != nil {
        log.Printf("read error: %v", err)
        return
    } else {
        _ = body
    }
}

func processRequest(r *http.Request) {
    body, err := io.ReadAll(r.Body)
    if err != nil {
        log.Printf("read error: %v", err)
        return
    }
    process(body)
}

func shouldProcessRecord(db *sql.DB, id int, input string) bool {
    // Cheapest first: in-memory O(1) check
    if strings.TrimSpace(input) == "" {
        return false
    }

    // Medium: string length check (O(1))
    if !isValidFormat(input) {
        return false
    }

    // Most expensive last: database I/O
    exists, err := recordExistsInDB(db, id)
    if err != nil || !exists {
        return false
    }

    return true
}

func shouldProcessRecord(db *sql.DB, id int, input string) bool {
    trimmed := strings.TrimSpace(input)
    if trimmed == "" || !isValidFormat(trimmed) {
        return false
    }
    exists, err := recordExistsInDB(db, id)
    return err == nil && exists
}

// Option A: map-based dispatch (O(1), extensible)
var statusMessages = map[int]string{
    200: "OK",
    201: "Created",
    204: "No Content",
    301: "Moved Permanently",
    302: "Found",
    400: "Bad Request",
    401: "Unauthorized",
    403: "Forbidden",
    404: "Not Found",
    500: "Internal Server Error",
    503: "Service Unavailable",
}

func statusMessage(code int) string {
    if msg, ok := statusMessages[code]; ok {
        return msg
    }
    return "Unknown"
}

// Option B: switch statement (O(1) jump table for dense int cases)
func statusMessageSwitch(code int) string {
    switch code {
    case 200:
        return "OK"
    case 201:
        return "Created"
    case 204:
        return "No Content"
    case 301:
        return "Moved Permanently"
    case 400:
        return "Bad Request"
    case 401:
        return "Unauthorized"
    case 403:
        return "Forbidden"
    case 404:
        return "Not Found"
    case 500:
        return "Internal Server Error"
    case 503:
        return "Service Unavailable"
    default:
        return "Unknown"
    }
}

// Option A: Pipeline pattern with errWriter-style struct
type reportBuilder struct {
    db     *sql.DB
    userID int
    user   *User
    orders []Order
    summary Summary
    report Report
    err    error
}

func (b *reportBuilder) fetchUser() {
    if b.err != nil {
        return
    }
    b.user, b.err = fetchUser(b.db, b.userID)
    if b.err != nil {
        b.err = fmt.Errorf("fetch user: %w", b.err)
    }
}

func (b *reportBuilder) fetchOrders() {
    if b.err != nil {
        return
    }
    b.orders, b.err = fetchOrders(b.db, b.userID)
    if b.err != nil {
        b.err = fmt.Errorf("fetch orders: %w", b.err)
    }
}

func (b *reportBuilder) computeSummary() {
    if b.err != nil {
        return
    }
    b.summary, b.err = computeSummary(b.orders)
    if b.err != nil {
        b.err = fmt.Errorf("compute summary: %w", b.err)
    }
}

func buildReport(db *sql.DB, userID int) ([]byte, error) {
    rb := &reportBuilder{db: db, userID: userID}
    rb.fetchUser()
    rb.fetchOrders()
    rb.computeSummary()
    if rb.err != nil {
        return nil, fmt.Errorf("buildReport: %w", rb.err)
    }
    report, err := renderReport(rb.user, rb.summary)
    if err != nil {
        return nil, fmt.Errorf("buildReport: render: %w", err)
    }
    data, err := json.Marshal(report)
    if err != nil {
        return nil, fmt.Errorf("buildReport: marshal: %w", err)
    }
    return data, nil
}

// Option B: Accept sequential pattern but use consistent wrapping
// The original is already idiomatic — this is a style note, not a bug.
// Go's philosophy: explicit error handling is intentional.
// Optimize for clarity, not brevity.

package main

import (
    "errors"
    "fmt"
    "os"
)

func readConfig(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("readConfig: %w", err)
    }
    return data, nil
}

func main() {
    data, err := readConfig("/etc/myapp/config.json")
    if err != nil {
        switch {
        case errors.Is(err, os.ErrNotExist):
            fmt.Println("Config file not found, using defaults")
        case errors.Is(err, os.ErrPermission):
            fmt.Println("Permission denied reading config")
        default:
            // Extract detailed path info if available
            var pathErr *os.PathError
            if errors.As(err, &pathErr) {
                fmt.Printf("File operation %q failed on %q: %v\n",
                    pathErr.Op, pathErr.Path, pathErr.Err)
            } else {
                fmt.Printf("Unexpected error: %v\n", err)
            }
        }
        return
    }
    _ = data
}

package main

import (
    "sync"
    "golang.org/x/sync/singleflight"
)

// Option A: Write-lock the entire check-and-set operation
type Cache struct {
    mu   sync.Mutex
    data map[string]string
}

func NewCache() *Cache {
    return &Cache{data: make(map[string]string)}
}

func (c *Cache) GetOrCompute(key string, compute func() string) string {
    c.mu.Lock()
    defer c.mu.Unlock()

    // Check inside the write lock — atomically safe
    if v, ok := c.data[key]; ok {
        return v
    }

    // Only one goroutine reaches here per key
    value := compute()
    c.data[key] = value
    return value
}

// Option B: singleflight — allows concurrent reads, deduplicates computation
type CacheWithSingleflight struct {
    mu   sync.RWMutex
    data map[string]string
    sg   singleflight.Group
}

func (c *CacheWithSingleflight) GetOrCompute(key string, compute func() string) string {
    // Fast path: read lock
    c.mu.RLock()
    if v, ok := c.data[key]; ok {
        c.mu.RUnlock()
        return v
    }
    c.mu.RUnlock()

    // Slow path: singleflight deduplicates concurrent misses for the same key
    v, _, _ := c.sg.Do(key, func() (interface{}, error) {
        // Double-check after acquiring singleflight token
        c.mu.RLock()
        if v, ok := c.data[key]; ok {
            c.mu.RUnlock()
            return v, nil
        }
        c.mu.RUnlock()

        value := compute()

        c.mu.Lock()
        c.data[key] = value
        c.mu.Unlock()

        return value, nil
    })
    return v.(string)
}

package main

import (
    "sort"
    "testing"
)

// Option A: Sort first — predictable branch, fastest on repeated calls
func countAboveThresholdSorted(data []int, threshold int) int {
    // After sorting, all values <= threshold come first.
    // Once we pass the threshold, the condition is always true.
    // Branch predictor achieves ~100% accuracy.
    count := 0
    for _, v := range data {
        if v > threshold {
            count++
        }
    }
    return count
}

// Option B: Branchless using bit manipulation
// (v > threshold) is equivalent to: (threshold - v) has high bit set
func countAboveThresholdBranchless(data []int, threshold int) int {
    count := 0
    for _, v := range data {
        // Arithmetic right shift: (threshold - v) >> 63
        // If v > threshold: threshold - v < 0, so high bit = 1, result = -1
        // If v <= threshold: threshold - v >= 0, so high bit = 0, result = 0
        // ^(threshold-v)>>63 gives 0 (false) or -1 (true), negate to get 0 or 1...
        // Simpler: use the Go compiler's own optimization
        diff := threshold - v
        count += int(uint(diff) >> 63) // 1 if v > threshold, 0 otherwise
    }
    return count
}

// Option C: Let the compiler do it — check with: go tool compile -S
// The compiler may already emit CMOV for the original simple if
func countAboveThreshold(data []int, threshold int) int {
    count := 0
    for _, v := range data {
        if v > threshold {
            count++
        }
    }
    return count
}

// Benchmark comparison
func BenchmarkUnsorted(b *testing.B) {
    data := makeRandomData(10000)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        countAboveThreshold(data, 5000)
    }
}

func BenchmarkSorted(b *testing.B) {
    data := makeRandomData(10000)
    sort.Ints(data)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        countAboveThreshold(data, 5000)
    }
}

func BenchmarkBranchless(b *testing.B) {
    data := makeRandomData(10000)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        countAboveThresholdBranchless(data, 5000)
    }
}

package main

import (
    "regexp"
    "strings"
    "unicode"
)

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)

type RegistrationRequest struct {
    Username string
    Email    string
    Password string
    Age      int
}

type ValidationResult struct {
    Valid  bool
    Errors []string
}

func validateRegistration(req RegistrationRequest) ValidationResult {
    var errs []string

    // Username: O(1) length checks first, then O(n) rune iteration
    uLen := len(req.Username)
    if uLen < 3 || uLen > 20 || !isAlphanumeric(req.Username) {
        errs = append(errs, "username: must be 3-20 alphanumeric characters")
    }

    // Email: empty check (O(1)) before regex (O(n))
    if req.Email == "" || !emailRegex.MatchString(req.Email) {
        errs = append(errs, "email: invalid format")
    }

    // Password: O(1) length bounds first, then O(n) character checks
    pLen := len(req.Password)
    if pLen < 8 || pLen > 128 {
        errs = append(errs, "password: must be 8-128 chars with uppercase, digit, and special char")
    } else if !hasUppercase(req.Password) || !hasDigit(req.Password) || !hasSpecialChar(req.Password) {
        errs = append(errs, "password: must contain uppercase, digit, and special char")
    }

    // Age: pure arithmetic — always cheap, no ordering concern
    if req.Age < 13 || req.Age > 120 {
        errs = append(errs, "age: must be between 13 and 120")
    }

    return ValidationResult{Valid: len(errs) == 0, Errors: errs}
}

// Single-pass validation for all password properties (O(n) total, not O(3n))
func validatePasswordChars(s string) (hasUpper, hasDigitChar, hasSpecial bool) {
    specials := "!@#$%^&*()-_=+[]{}|;:,.<>?"
    for _, r := range s {
        switch {
        case unicode.IsUpper(r):
            hasUpper = true
        case unicode.IsDigit(r):
            hasDigitChar = true
        case strings.ContainsRune(specials, r):
            hasSpecial = true
        }
        if hasUpper && hasDigitChar && hasSpecial {
            return // early exit: all conditions met
        }
    }
    return
}

// Optimized validation using single-pass character check
func validateRegistrationOptimized(req RegistrationRequest) ValidationResult {
    var errs []string

    uLen := len(req.Username)
    if uLen < 3 || uLen > 20 || !isAlphanumeric(req.Username) {
        errs = append(errs, "username: must be 3-20 alphanumeric characters")
    }

    if req.Email == "" || !emailRegex.MatchString(req.Email) {
        errs = append(errs, "email: invalid format")
    }

    pLen := len(req.Password)
    if pLen < 8 || pLen > 128 {
        errs = append(errs, "password: must be 8-128 chars with uppercase, digit, and special char")
    } else {
        hasUpper, hasDigit, hasSpecial := validatePasswordChars(req.Password)
        if !hasUpper || !hasDigit || !hasSpecial {
            errs = append(errs, "password: must contain uppercase, digit, and special char")
        }
    }

    if req.Age < 13 || req.Age > 120 {
        errs = append(errs, "age: must be between 13 and 120")
    }

    return ValidationResult{Valid: len(errs) == 0, Errors: errs}
}

// debug_off.go — compiled in production builds
//go:build !debug

package main

const debugMode = false

// debug.go — compiled only with: go build -tags debug
//go:build debug

package main

const debugMode = true

// main.go — same for both builds
package main

import "fmt"

func processEvent(event Event, id int) {
    if debugMode {
        // This entire block is ELIMINATED from the binary in production.
        // The compiler sees: if false { ... } → dead code → removed.
        fmt.Printf("[DEBUG] processing event %d: %+v\n", id, event)
    }

    result := transform(event)

    if debugMode {
        fmt.Printf("[DEBUG] event %d result: %+v\n", id, result)
    }

    store(result)
}