Try These Under The Radar Golang Features to Do More With Less

Hi, I'm Shrijith Venkatramana. Right now, I'm building on an aggregation of 50,000+ resources on my site Free DevTools. This site hosts many free developer tools, manuals, cheatsheets and icon sets - which you can download or use without any login. Do give it a try here

Go's simplicity is one of its biggest strengths, but it packs some under-the-radar features that can shave hours off your development time. In this post, we'll explore capabilities like build constraints, object pooling, and advanced error handling. These aren't always front-and-center in tutorials, but they solve real-world problems efficiently. Whether you're optimizing performance or streamlining workflows, these tools can make your code cleaner and faster. Let's get into the details.

Customize Builds with Constraints for Platform-Specific Code

Build constraints let you include or exclude code based on conditions like OS, architecture, or custom tags. This keeps your codebase clean without runtime checks, which is great for cross-platform apps.

For example, you might have platform-specific implementations. Add a comment like //go:build darwin at the top of a file to make it compile only on macOS.

Here's a complete example. Create two files: hello_darwin.go and hello_linux.go, plus a main file.

hello_darwin.go:

//go:build darwin

package main

import "fmt"

func main() {
    fmt.Println("Hello from macOS!")
}

No, that's not right. Build constraints apply to files, and main should be separate.

Better:

main.go:

package main

import "fmt"

func main() {
    greet()
}

darwin.go:

//go:build darwin

package main

func greet() {
    fmt.Println("Hello from macOS!")
}

No, package main in both? Actually, for same package.

Correct way: files in same package.

Let's do:

main.go:

package main

import "fmt"

func main() {
    fmt.Println(getMessage())
}

message_darwin.go:

//go:build darwin

package main

func getMessage() string {
    return "Hello from macOS!"
}

message_linux.go:

//go:build linux

package main

func getMessage() string {
    return "Hello from Linux!"
}

To compile: go build on respective OS.

Output on macOS: // Hello from macOS!

On Linux: // Hello from Linux!

You can also use custom tags like //go:build prod and compile with go build -tags prod.

This avoids if-else bloat in code. For more on syntax, check the official build constraints doc.

Key points:

• Reduces binary size by excluding unused code.
• Improves readability without conditional logic.
• Works with modules seamlessly.

Reuse Objects Efficiently Using sync.Pool

sync.Pool provides a way to reuse temporary objects, reducing garbage collection pressure in high-throughput apps like servers.

It's ideal for allocating buffers or structs that are created and discarded frequently. The pool manages a cache of objects, and you can put/get them as needed.

Example: In a web server, reuse byte slices for responses.

Complete code:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var pool = sync.Pool{
        New: func() any {
            return make([]byte, 1024)
        },
    }

    // Get from pool
    buf := pool.Get().([]byte)
    copy(buf, "Hello, World!")
    fmt.Println(string(buf[:13])) // Output: Hello, World!

    // Put back
    pool.Put(buf)

    // Get again, should reuse
    buf2 := pool.Get().([]byte)
    fmt.Println(len(buf2)) // Output: 1024 (reused)
}

This runs without errors. The New func creates objects on miss.

Pools are goroutine-safe but cleared during GC, so use for short-lived objects.

Key points:

• Cuts allocation overhead in loops or handlers.
• Thread-safe by design.
• Avoid storing stateful objects.

For benchmarks showing gains, see Go's sync package docs.

Handle Timeouts and Cancellations with Context

The context package lets you propagate cancellation signals, deadlines, and values across API boundaries, preventing resource leaks in concurrent code.

Use it for HTTP requests, database queries, or goroutines that might outlive their usefulness.

Example: A function that simulates work with timeout.

Complete code:

package main

import (
    "context"
    "fmt"
    "time"
)

func doWork(ctx context.Context) error {
    select {
    case <-time.After(2 * time.Second):
        fmt.Println("Work completed")
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()

    err := doWork(ctx)
    if err != nil {
        fmt.Println(err) // Output: context deadline exceeded
    }
}

Here, the timeout triggers cancellation.

You can nest contexts or pass values like user IDs.

Key points:

• Prevents goroutine leaks by signaling done.
• Composable with WithValue, WithDeadline.
• Standard in libraries like net/http.

Improve Error Handling with errors.Is and errors.As

The errors package offers Is and As for checking wrapped errors, making it easier to handle specific error types without string matching.

This is useful in layered apps where errors get wrapped with context.

Example: Wrap an error and check it later.

Complete code:

package main

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("not found")

func findItem() error {
    return fmt.Errorf("failed to find: %w", ErrNotFound)
}

func main() {
    err := findItem()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("Item not found") // Output: Item not found
    }

    var target *os.PathError // Assuming import "os"
    if errors.As(err, &target) {
        // Would work if wrapped error is PathError
    }
}

Wait, in this example, it's not PathError, but shows As usage.

Import "os" for PathError.

But to keep simple, the Is works.

Key points:

• Chainable with %w in fmt.Errorf.
• Type-safe checks with As.
• Reduces brittle string comparisons.

See errors package docs for unwrap details.

Speed Up Tests with Parallel Execution

In testing, t.Parallel() lets tests run concurrently, cutting down suite time on multi-core machines.

Mark independent tests to run in parallel, while setup can stay serial.

Example: Two tests that can run together.

Complete code (save as example_test.go):

package main

import (
    "testing"
    "time"
)

func TestSlowOne(t *testing.T) {
    t.Parallel()
    time.Sleep(1 * time.Second)
    // Assert something
}

func TestSlowTwo(t *testing.T) {
    t.Parallel()
    time.Sleep(1 * time.Second)
    // Assert something
}

func TestMain(m *testing.M) {
    // Run tests
    m.Run()
}

Run with go test -v. Without parallel, ~2s; with, ~1s.

Key points:

• Boosts CI/CD speed for large suites.
• Safe for independent tests; avoid shared state.
• Use with -parallel flag for control.

Embed Files Directly into Binaries

The embed package (Go 1.16+) lets you include files like templates or assets in your binary, simplifying deployment.

No need for separate assets folders in production.

Example: Embed a text file and read it.

Complete code:

package main

import (
    "embed"
    "fmt"
)

//go:embed hello.txt
var content embed.FS

func main() {
    data, err := content.ReadFile("hello.txt")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data)) // Output: assuming hello.txt contains "Hello, Embedded!"
}

Create hello.txt with "Hello, Embedded!".

Build and run; file is inside binary.

You can embed directories too.

Key points:

• Single-file deploys for CLIs or servers.
• Read-only access via embed.FS.
• Works with http.FileServer.

Check embed package docs for patterns.

Achieve Lock-Free Updates with Atomic Operations

The sync/atomic package provides functions for atomic reads/writes, avoiding mutexes for simple concurrent updates.

Useful for counters or flags in high-concurrency scenarios.

Example: Atomic counter in goroutines.

Complete code:

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var counter int64
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            atomic.AddInt64(&counter, 1)
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println(counter) // Output: 1000
}

Without atomic, race conditions possible.

Key points:

• Faster than mutexes for primitives.
• Operations like Load, Store, CompareAndSwap.
• Detect races with -race flag.

Tailor JSON Handling with Custom Marshaling

Implement json.Marshaler/Unmarshaler for custom JSON logic, like formatting dates or validating fields.

This keeps structs clean while handling edge cases.

Example: Custom time format.

Complete code:

package main

import (
    "encoding/json"
    "fmt"
    "time"
)

type CustomTime struct {
    time.Time
}

func (ct CustomTime) MarshalJSON() ([]byte, error) {
    return json.Marshal(ct.Format("2006-01-02"))
}

type Event struct {
    When CustomTime `json:"when"`
}

func main() {
    e := Event{When: CustomTime{time.Now()}}
    data, _ := json.Marshal(e)
    fmt.Println(string(data)) // Output: {"when":"2025-09-27"} (approx, based on date)
}

This overrides default time format.

Key points:

• Flexible serialization without extra code.
• Pairs with struct tags for field names.
• Use for enums or computed fields.

Incorporating these features into your daily Go work can lead to more efficient codebases and quicker iterations. Start with one or two in your next project—build constraints for multi-platform tweaks or sync.Pool for performance hotspots—and measure the impact. Over time, they'll become go-to tools in your toolkit, helping you focus on logic rather than boilerplate.