Go on Nalar

Atomic File Writes in Go: Prevent Partial and Corrupted Files

Tue, 01 Sep 2026 00:00:00 +0700

Writing a file with os.WriteFile is simple, but it is not always the safest choice for configuration files, generated metadata, caches, state files, or other data that must never be left half-written.

If a process crashes or the machine loses power while a file is being replaced, readers may observe incomplete content. A common way to reduce this risk is an atomic file write: write the new content to a temporary file first, then replace the destination with a rename.

Bounded Concurrency in Go with a Worker Pool

Tue, 01 Sep 2026 00:00:00 +0700

Goroutines are cheap, but the resources they call are often not. Starting one goroutine for every item in a large batch can overwhelm a database connection pool, trigger API rate limits, exhaust file descriptors, or create avoidable memory pressure.

Bounded concurrency solves this by allowing only a fixed number of operations to run at the same time. A worker pool is one of the simplest standard-library patterns for implementing that limit in Go.

Coalesce Duplicate Work with Single-Flight Patterns in Go

Tue, 01 Sep 2026 00:00:00 +0700

Concurrent services often receive bursts of requests for the same expensive value: configuration, a database row, a rendered artifact, or a remote API response. A cache helps after the first request completes, but it does not stop ten simultaneous cache misses from doing the same work ten times.

A single-flight pattern lets one caller perform the work while other callers wait for that result.

The cache-miss stampede problem

Without coordination, several callers can observe the same miss and all call the dependency. Single-flight changes that behavior so one request becomes the leader and later requests for the same key become followers.

Exponential Backoff with Jitter in Go

Tue, 01 Sep 2026 00:00:00 +0700

Retries can make distributed systems more resilient, but immediate retries can also make an outage worse. If thousands of clients retry at the same moment, a recovering dependency receives another synchronized burst of traffic before it has time to stabilize.

A common solution is exponential backoff with jitter: increase the maximum delay after each failure, then randomize the actual wait. This article builds that pattern with Go’s standard library and shows where retry logic belongs—and where it does not.

Go Context Timeouts and Request Cancellation

Tue, 01 Sep 2026 00:00:00 +0700

A Go HTTP handler can outlive the request that started it unless the work inside the handler pays attention to cancellation. That matters when a client disconnects, an upstream request takes too long, or a database query is no longer useful.

Go solves this with context.Context. Every incoming *http.Request already has a context, and that context is canceled when the client connection closes, the request is canceled by HTTP/2, or the handler returns. You can also derive a shorter deadline for work that should not consume the entire request lifetime.

Go Error Wrapping with errors.Is and errors.As

Tue, 01 Sep 2026 00:00:00 +0700

Errors often cross several layers of a Go application. A low-level function may know that a file is missing, while a higher-level function needs to add context about which operation failed. Go error wrapping lets you add that context without losing information callers need for reliable handling.

Why error strings are fragile

Do not make program logic depend on error wording. Adding a filename or changing punctuation can break string comparisons even when the underlying condition is unchanged. Prefer semantic checks:

Graceful HTTP Server Shutdown in Go

Tue, 01 Sep 2026 00:00:00 +0700

Stopping a web server with Ctrl+C looks harmless during development, but production deployments need a more careful shutdown process. If a process exits immediately, active HTTP requests can be interrupted, clients may receive connection errors, and in-flight work can be left unfinished.

Go’s standard library already provides the pieces needed for a clean shutdown. The main tools are os/signal, context, and http.Server.Shutdown.

This guide shows a practical pattern for shutting down an HTTP server when the process receives SIGINT or SIGTERM.

Reliable Application Configuration from Environment Variables in Go

Tue, 01 Sep 2026 00:00:00 +0700

Environment variables are a convenient way to configure deployed Go services, but calling os.Getenv throughout an application makes configuration difficult to validate and test.

A stronger pattern is to load configuration once at startup, parse it into typed fields, validate all invariants, and pass the resulting value to the components that need it.

The examples below use only the Go standard library and work with modern supported Go releases.

Keep configuration in a typed struct

Suppose a service needs a listen address, request timeout, and optional log level:

Request Coalescing in Go Without Extra Dependencies

Tue, 01 Sep 2026 00:00:00 +0700

When many requests ask for the same expensive resource at the same time, running identical work for every caller can overload a database, API, or filesystem. A cache can help after a result exists, but it does not necessarily prevent several concurrent cache misses from triggering the same backend operation.

Request coalescing solves a different problem: while one operation for a key is already running, later callers wait for that operation and share its result. After the operation finishes, the result is forgotten. The next request starts fresh work.

Streaming Pipelines with io.Reader and io.Writer in Go

Tue, 01 Sep 2026 00:00:00 +0700

Go’s io.Reader and io.Writer interfaces are intentionally tiny, but they enable a large class of streaming programs. Files, HTTP bodies, compression streams, hashes, encoders, sockets, and in-memory buffers can all participate in the same pipeline without loading the entire payload into memory.

The key design principle is to pass streams through components instead of converting them to []byte or string at every boundary.

Start with the two core interfaces

The standard library defines the essential contracts as methods equivalent to:

Structured Logging in Go with slog

Tue, 01 Sep 2026 00:00:00 +0700

Plain text logs are easy to print but difficult to query reliably. Once an application runs across multiple processes or containers, operators usually need to filter events by fields such as HTTP status, request path, customer ID, or latency rather than search arbitrary strings.

Go’s standard library includes log/slog for structured logging. It was added in Go 1.21, so the examples in this article require Go 1.21 or newer.

What structured logging changes

A traditional log message often embeds data inside prose:

Testing Go HTTP Handlers with httptest

Tue, 01 Sep 2026 00:00:00 +0700

HTTP handlers are one of the easiest parts of a Go service to test well. You usually do not need to bind a real network port, start the entire application, or depend on an external test framework.

Go’s standard library provides net/http/httptest, which can construct HTTP requests, capture handler responses, and even start temporary HTTP servers when a real client-server round trip matters.

This guide builds a small JSON endpoint and tests it at several useful levels.

Token Bucket Rate Limiting in Go

Tue, 01 Sep 2026 00:00:00 +0700

Rate limiting protects a service from traffic spikes, accidental client loops, and workloads that consume more resources than the system can safely handle. A useful limiter should do more than enforce a fixed request count: it should allow small bursts while keeping the long-term request rate bounded.

The token bucket algorithm provides exactly that behavior. This guide implements a small, concurrency-safe token bucket using only Go’s standard library and then shows how to use it in an HTTP service.

Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter

Sat, 24 Aug 2024 00:00:00 +0700

Go arrays and slices are straightforward once you understand their different roles. Arrays have a fixed length that is part of their type, while slices are flexible views over an underlying array and are the collection type used most often in application code.

The following examples use a slice of structs:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

type Person struct {
    Name string
    Age  int
}

people := []Person{
    {Name: "Alice", Age: 30},
    {Name: "Bob", Age: 25},
    {Name: "John", Age: 20},
    {Name: "Zara", Age: 35},
}

1. Add an Element

Use append:

Build a CRUD API with Go, Gin, MySQL, and GORM

Sat, 24 Aug 2024 00:00:00 +0700

This tutorial builds a small CRUD API with Go, the Gin web framework, MySQL, and GORM. It also uses godotenv for local development configuration.

1. Create the Project

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

mkdir myapp
cd myapp
go mod init myapp

2. Install Dependencies

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

go get github.com/gin-gonic/gin
go get gorm.io/gorm
go get gorm.io/driver/mysql
go get github.com/joho/godotenv

Run go mod tidy after adding your imports so the module file reflects the dependencies actually used by the application.

Deploy a Go Web Server with systemd on Linux

Sat, 24 Aug 2024 00:00:00 +0700

When developing a small Go web server, it is common to run it manually with go run main.go. The problem is that the process stops when the terminal closes, and it will not automatically return after a server reboot.

A better production setup is to run the application as a systemd service. That gives you automatic startup, monitoring, service management, and optional restart behavior after failures.

1. Create a Simple Go Web Server

Start with a minimal HTTP server:

Easy Ways to Convert an Integer to a String in Go

Sat, 24 Aug 2024 00:00:00 +0700

Converting an integer to a string is common when building output, logs, identifiers, URLs, or serialized data. Go provides several standard-library options depending on whether you need a simple decimal conversion or more control over formatting.

1. `strconv.Itoa()`

For an int in base 10, strconv.Itoa is usually the clearest choice:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import (
	"fmt"
	"strconv"
)

func main() {
	num := 42
	str := strconv.Itoa(num)
	fmt.Println("String value:", str)
}

Itoa is equivalent to formatting the int as a base-10 integer.

Efficient String Concatenation in Go

Sat, 24 Aug 2024 00:00:00 +0700

String concatenation appears everywhere in Go programs: generating text, building paths, formatting reports, or assembling protocol messages. The best technique depends on how many pieces you are joining and how the data is already structured.

1. The `+` Operator

For a small, fixed number of strings, + is clear and perfectly reasonable:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

str1 := "Hello, "
str2 := "world!"
result := str1 + str2

Avoid repeatedly growing a string with + inside a large loop, because each result is a new immutable string and repeated copying can become expensive.

Generate Random Strings in Go

Sat, 24 Aug 2024 00:00:00 +0700

Random strings are useful for temporary identifiers, test data, filenames, invitation codes, and security-sensitive tokens. Go offers different random-number sources, and choosing the correct one matters.

1. `math/rand` for Non-Security Uses

For simulations, test fixtures, randomized UI behavior, or other cases where predictability is not a security problem, math/rand is appropriate.

With modern Go, create an explicit generator when you need independent pseudo-random state:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import (
	"fmt"
	"math/rand"
)

const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

func GenerateRandomString(r *rand.Rand, length int) string {
	result := make([]byte, length)
	for i := range result {
		result[i] = alphabet[r.Intn(len(alphabet))]
	}
	return string(result)
}

func main() {
	r := rand.New(rand.NewSource(42))
	fmt.Println(GenerateRandomString(r, 10))
}

A fixed seed is useful for reproducible tests. Do not use math/rand for secrets, session tokens, password-reset tokens, or other authentication material.

How to Check Whether a File Exists in Go

Sat, 24 Aug 2024 00:00:00 +0700

Checking whether a file exists is a common task when working with configuration, local state, generated output, or other filesystem resources. Go’s os package provides the necessary APIs, but it is important to distinguish “does not exist” from other errors such as permission failures.

1. Check with `os.Stat`

os.Stat returns file metadata when the path can be resolved:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

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

func fileExists(filename string) (bool, error) {
	_, err := os.Stat(filename)
	if err == nil {
		return true, nil
	}
	if errors.Is(err, os.ErrNotExist) {
		return false, nil
	}
	return false, err
}

func main() {
	filename := "example.txt"

	exists, err := fileExists(filename)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	if exists {
		fmt.Printf("File '%s' exists.\n", filename)
	} else {
		fmt.Printf("File '%s' does not exist.\n", filename)
	}
}

Returning an error prevents permission or I/O problems from being mistaken for a missing file.

How to Check Whether a Map Contains a Key in Go

Sat, 24 Aug 2024 00:00:00 +0700

Go has a built-in idiom for checking whether a map contains a key. A map lookup can return both the stored value and a boolean indicating whether the key is present.

Check a Key

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

myMap := map[string]int{
	"apple":  1,
	"banana": 2,
	"cherry": 3,
}

key := "banana"
value, exists := myMap[key]

if exists {
	fmt.Printf("Key '%s' exists with value %d\n", key, value)
} else {
	fmt.Printf("Key '%s' does not exist\n", key)
}

The boolean is important because a missing key returns the value type’s zero value. Without the boolean, you cannot distinguish a missing key from a present key whose stored value happens to be zero.

How to Create Enum-Like Types in Go

Sat, 24 Aug 2024 00:00:00 +0700

Go does not have a dedicated enum keyword like Java, C#, or TypeScript. Instead, enum-like values are usually modeled with a named type plus constants, often using iota to generate sequential values.

1. A Simple Enum-Like Constant Set with `iota`

iota is a counter that starts at zero within a const block and increments for each constant specification:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import "fmt"

const (
	Red = iota
	Green
	Blue
)

func main() {
	fmt.Println("Red:", Red)
	fmt.Println("Green:", Green)
	fmt.Println("Blue:", Blue)
}

Output:

How to Get a Slice of Map Keys in Go

Sat, 24 Aug 2024 00:00:00 +0700

Go maps store key-value pairs, but many tasks only need the keys—for example, to sort them, display them, compare sets, or feed them into another operation.

Map iteration is intentionally unordered, so extracting keys into a slice is also the first step when you need a deterministic order.

1. Collect All Keys with `range`

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

func getMapKeys(m map[string]int) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	return keys
}

func main() {
	myMap := map[string]int{
		"apple":  1,
		"banana": 2,
		"cherry": 3,
	}

	keys := getMapKeys(myMap)
	fmt.Println("Keys:", keys)
}

Preallocating the slice with capacity len(m) avoids unnecessary growth while keys are appended.

How to Safely Convert a String to an Integer in Go

Sat, 24 Aug 2024 00:00:00 +0700

Numbers often arrive as strings from command-line arguments, form input, files, environment variables, or APIs. Before performing arithmetic, convert the text with Go’s strconv package and handle invalid input explicitly.

1. Use `strconv.Atoi()` for `int`

Atoi is the simplest choice when you want a base-10 int:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import (
	"fmt"
	"strconv"
)

func main() {
	str := "123"
	num, err := strconv.Atoi(str)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("Number:", num)
}

Invalid input such as "12a" returns an error. Never assume external text is valid without checking it.

Learning Interfaces in Go: Concepts, Examples, and Best Practices

Sat, 24 Aug 2024 00:00:00 +0700

Interfaces are one of Go’s most important abstraction tools. An interface describes behavior as a set of method signatures. A concrete type satisfies an interface implicitly simply by implementing the required methods—there is no separate implements declaration.

What Is an Interface?

An interface is a set of methods. For example:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

type Speaker interface {
    Speak() string
}

type Person struct {
    Name string
}

func (p Person) Speak() string {
    return "Hello, my name is " + p.Name
}

Because Person has the required Speak() string method, it satisfies Speaker:

Loops in Go: A Practical Guide with Examples

Sat, 24 Aug 2024 00:00:00 +0700

Go has only one looping keyword: for. That can look unusual if you come from a language with separate for, while, and do-while constructs, but Go’s for is flexible enough to cover the common looping patterns.

1. Basic `for` Loop

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

This is similar to a traditional loop in C, Java, or JavaScript: initialize a counter, continue while the condition is true, and run the post statement after each iteration.

Manage Goroutine Work Queues Efficiently in Go

Sat, 24 Aug 2024 00:00:00 +0700

Goroutines are one of Go’s defining features. They make concurrent work inexpensive to start, but creating an uncontrolled number of goroutines can still overwhelm memory, downstream services, file descriptors, or database connections.

A common solution is a bounded worker pool: tasks are placed on a channel and a fixed number of goroutines consume them.

Why Use a Queue?

A controlled work queue helps you:

limit the number of active workers;
apply backpressure when work arrives faster than it can be processed;
centralize task scheduling;
shut down cleanly after queued work finishes.

1. A Basic Channel-Based Queue

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

type Task struct {
    ID int
}

func worker(id int, tasks <-chan Task) {
    for task := range tasks {
        fmt.Printf("Worker %d processing task %d\n", id, task.ID)
        time.Sleep(time.Second)
    }
}

A channel can hold pending tasks while several workers read from it.

Maps in Go: A Practical Guide with Examples

Sat, 24 Aug 2024 00:00:00 +0700

A Go map stores key-value pairs and gives you fast lookup by key. It is similar to a dictionary or hash map in other languages and is one of Go’s most useful built-in data structures.

Creating a Map

Using make:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

personAge := make(map[string]int)
personAge["Alice"] = 30
personAge["Bob"] = 25
fmt.Println(personAge)

Using a map literal:

Practical Ways to Combine Slices in Go

Sat, 24 Aug 2024 00:00:00 +0700

Combining slices is common when data comes from several sources or processing stages. In Go, the standard approach is append, optionally with preallocated capacity when the final size is known.

1. Combine Slices with `append`

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import "fmt"

func main() {
	slice1 := []int{1, 2, 3}
	slice2 := []int{4, 5, 6}
	slice3 := []int{7, 8, 9}

	combined := append(slice1, slice2...)
	combined = append(combined, slice3...)

	fmt.Println(combined)
}

Output:

Pretty-Printing JSON in Go with MarshalIndent

Sat, 24 Aug 2024 00:00:00 +0700

Compact JSON is efficient for transport, but long documents can be difficult to inspect when everything appears on one line. Go’s standard encoding/json package includes json.MarshalIndent for producing human-readable JSON with line breaks and indentation.

Pretty-printed JSON is useful for debugging, generated configuration, logs intended for people, and command-line output.

1. Use `json.MarshalIndent`

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	data := map[string]any{
		"name": "Alice",
		"age":  30,
		"address": map[string]string{
			"street": "123 Main St",
			"city":   "Wonderland",
		},
		"hobbies": []string{"reading", "hiking", "coding"},
	}

	prettyJSON, err := json.MarshalIndent(data, "", "    ")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println(string(prettyJSON))
}

MarshalIndent accepts three arguments:

Several Ways to Handle Optional Parameters in Go

Sat, 24 Aug 2024 00:00:00 +0700

Go deliberately does not support optional or default function parameters like some other languages. Function signatures are explicit, which keeps call sites and APIs predictable.

When an API genuinely needs optional configuration, Go developers usually choose one of a few established patterns.

1. Variadic Parameters

A variadic parameter (...) is useful when the optional part is simply zero or more values of the same type:

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

func greet(message string, names ...string) {
	for _, name := range names {
		fmt.Printf("%s, %s!\n", message, name)
	}
}

func main() {
	greet("Hello")
	greet("Hello", "Alice", "Bob", "Charlie")
}

message is required, while names may contain zero, one, or many values.

Structs in Go: A Practical Guide with Examples

Sat, 24 Aug 2024 00:00:00 +0700

A struct groups related fields into a single Go type. Structs are the standard way to model domain entities, configuration, request data, records, and many other compound values.

Define a Struct

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

type Person struct {
    Name    string
    Age     int
    Address string
}

p := Person{Name: "Alice", Age: 30, Address: "123 Main St"}
fmt.Println(p.Name, p.Age, p.Address)

Using field names in composite literals is usually clearer and more resilient than relying on field order.

Working with Time in Go Without the Headaches

Sat, 24 Aug 2024 00:00:00 +0700

Time handling looks simple until time zones, parsing, durations, and scheduling enter the picture. Go’s standard time package covers the common cases without requiring third-party libraries.

Current Time

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

currentTime := time.Now()
fmt.Println("Now:", currentTime)

time.Now() returns the current local time according to the process environment.

Common Function Patterns in Go with Practical Examples

Tue, 20 Aug 2024 00:00:00 +0700

Functions are first-class values in Go: they can be assigned to variables, passed as arguments, returned from other functions, and wrapped in closures. Combined with multiple return values and defer, this gives Go a small but flexible set of function patterns.

1. Basic Functions

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

func add(a, b int) int {
    return a + b
}

result := add(3, 4)
fmt.Println(result) // 7

Functions declare parameter types and, when needed, a return type after the parameter list.

Encrypt and Decrypt Data in Go with AES-GCM

Tue, 20 Aug 2024 00:00:00 +0700

Applications that store tokens, private configuration, or other sensitive values often need encryption at rest. Go includes everything required to implement modern symmetric encryption in its standard library.

This example uses AES-GCM, an authenticated encryption mode that protects both confidentiality and integrity. That makes it a better default for new applications than older unauthenticated modes such as CFB.

AES-GCM in Brief

Symmetric encryption uses the same secret key for encryption and decryption.
AES accepts 16-, 24-, or 32-byte keys for AES-128, AES-192, or AES-256.
GCM adds authentication, so modified ciphertext is rejected during decryption.
A fresh nonce must be used for every encryption operation with the same key.

Complete Go Example

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"fmt"
)

func generateRandomKey() ([]byte, error) {
	key := make([]byte, 32) // AES-256
	if _, err := rand.Read(key); err != nil {
		return nil, err
	}
	return key, nil
}

func encrypt(plaintext, key []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}

	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}

	nonce := make([]byte, gcm.NonceSize())
	if _, err := rand.Read(nonce); err != nil {
		return nil, err
	}

	// Prefix the ciphertext with the nonce so decrypt can recover it.
	return gcm.Seal(nonce, nonce, plaintext, nil), nil
}

func decrypt(ciphertext, key []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}

	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}

	nonceSize := gcm.NonceSize()
	if len(ciphertext) < nonceSize {
		return nil, fmt.Errorf("ciphertext too short")
	}

	nonce := ciphertext[:nonceSize]
	ciphertext = ciphertext[nonceSize:]

	return gcm.Open(nil, nonce, ciphertext, nil)
}

func main() {
	plaintext := []byte("Secret application data")

	key, err := generateRandomKey()
	if err != nil {
		panic(err)
	}

	ciphertext, err := encrypt(plaintext, key)
	if err != nil {
		panic(err)
	}

	fmt.Println("Ciphertext (base64):", base64.StdEncoding.EncodeToString(ciphertext))

	decrypted, err := decrypt(ciphertext, key)
	if err != nil {
		panic(err)
	}

	fmt.Println("Decrypted text:", string(decrypted))
}

How It Works

generateRandomKey creates a cryptographically secure 32-byte key for AES-256.
encrypt creates an AES cipher, wraps it with GCM, generates a random nonce, and encrypts the plaintext.
The nonce is stored at the beginning of the returned byte slice. A nonce does not need to be secret, but it must not be reused with the same key.
decrypt separates the nonce from the ciphertext and calls gcm.Open. If the ciphertext was modified, authentication fails and an error is returned.

Key Management Matters

The encryption code is only one part of a secure design. Do not hard-code real encryption keys in source control. In production, load keys from an appropriate secret-management system, protected environment, or key-management service.

Implement HMAC Message Authentication in Go

Tue, 20 Aug 2024 00:00:00 +0700

When an application exchanges sensitive data, it is often important to verify both the integrity and authenticity of each message. If an attacker can modify a request in transit or replay an old valid request, the receiving service needs a reliable way to reject it.

One common building block is HMAC (Hash-based Message Authentication Code). This article shows how to generate and verify an HMAC in Go with SHA-512, plus a nonce and timestamp to reduce replay risk.

Pointers in Go: A Practical Guide with Examples

Tue, 20 Aug 2024 00:00:00 +0700

A pointer stores the memory address of another value. In Go, pointers are useful when a function needs to modify a caller-owned value, when a type needs a meaningful nil state, or when pointer receiver semantics are appropriate.

Declaring a Pointer

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

var ptr *int

The zero value of a pointer is nil. Use & to take an address and * to dereference it:

Search Multiple Texts Concurrently with Goroutines in Go

Tue, 20 Aug 2024 00:00:00 +0700

Go makes concurrent work straightforward with goroutines. One practical example is searching for a word across many text values at the same time.

Instead of checking each text sequentially, you can launch a goroutine for each item and wait for all searches to finish.

Overview

The program below will:

Search for a word in a single text value with searchInText.
Search multiple text values concurrently with searchWordInTexts.
Print whether the word was found.

Complete Example

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

package main

import (
	"fmt"
	"strings"
	"sync"
)

// searchInText reports whether word occurs in text.
func searchInText(text, word string) bool {
	if text == "" || word == "" {
		return false
	}

	// Make the search case-insensitive.
	text = strings.ToLower(text)
	word = strings.ToLower(word)
	return strings.Contains(text, word)
}

// searchWordInTexts searches multiple texts concurrently.
func searchWordInTexts(texts []string, word string) bool {
	var wg sync.WaitGroup
	var mu sync.Mutex
	found := false

	for _, text := range texts {
		wg.Add(1)
		go func(t string) {
			defer wg.Done()
			if searchInText(t, word) {
				mu.Lock()
				found = true
				mu.Unlock()
			}
		}(text)
	}

	wg.Wait()
	return found
}

func main() {
	texts := []string{
		"This is a long example text",
		"Another text for word searching",
		"This program uses goroutines for searching",
	}
	word := "program"

	if searchWordInTexts(texts, word) {
		fmt.Printf("Word '%s' was found in at least one text\n", word)
	} else {
		fmt.Printf("Word '%s' was not found\n", word)
	}
}

How It Works

searchInText converts both the text and search term to lowercase, then uses strings.Contains for a case-insensitive match.
searchWordInTexts uses sync.WaitGroup to wait for every goroutine and sync.Mutex to protect the shared found variable.
main provides sample data, runs the concurrent search, and prints the result.

A Practical Note

For short in-memory strings, launching one goroutine per string may be slower than a simple loop because goroutines and synchronization have overhead. This pattern becomes more useful when each task is expensive or blocking, such as reading files, calling services, or processing large independent inputs.

Variables in Go: A Practical Guide

Tue, 20 Aug 2024 00:00:00 +0700

Variables are one of the basic building blocks of Go programs. Understanding declaration syntax, scope, zero values, constants, and type inference helps keep code predictable and easy to maintain.

Declare Variables with `var`

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

var name string
var age int

If you do not provide an initializer, Go assigns the type’s zero value. Here, name starts as "" and age starts as 0.

Implement Validation in a Go Web App with Gin

Tue, 28 Nov 2023 00:00:00 +0700

Input validation is an important part of any web application. It lets the server reject malformed or incomplete data before business logic runs.

This tutorial builds a small API with Gin and uses go-playground/validator for declarative validation rules.

Project Structure

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

project/
├── main.go
└── utils/
    └── validation.go

1. Create the Gin Application

Create main.go with a /register endpoint:

Validate User Input in a Go Web App with Gin

Tue, 28 Nov 2023 00:00:00 +0700

Input validation is one of the first defenses a web application has against malformed, incomplete, or unexpected data. Validation should run before business logic writes data to a database or triggers other side effects.

This example uses Gin with go-playground/validator to validate a simple registration request.

Project Structure

$el.innerText = 'Copy', 2000)" class="absolute top-2 right-2 bg-neutral-700 text-white text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity" > Copy

project/
├── main.go
└── utils/
    └── validation.go

1. Set Up Gin

Create main.go:

Go on Nalar

Atomic File Writes in Go: Prevent Partial and Corrupted Files

Bounded Concurrency in Go with a Worker Pool

Coalesce Duplicate Work with Single-Flight Patterns in Go

The cache-miss stampede problem

Exponential Backoff with Jitter in Go

Go Context Timeouts and Request Cancellation

Go Error Wrapping with errors.Is and errors.As

Why error strings are fragile

Graceful HTTP Server Shutdown in Go

Reliable Application Configuration from Environment Variables in Go

Keep configuration in a typed struct

Request Coalescing in Go Without Extra Dependencies

Streaming Pipelines with io.Reader and io.Writer in Go

Start with the two core interfaces

Structured Logging in Go with slog

What structured logging changes

Testing Go HTTP Handlers with httptest

Token Bucket Rate Limiting in Go

Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter

1. Add an Element

Build a CRUD API with Go, Gin, MySQL, and GORM

1. Create the Project

2. Install Dependencies

Deploy a Go Web Server with systemd on Linux

1. Create a Simple Go Web Server

Easy Ways to Convert an Integer to a String in Go

1. strconv.Itoa()

Efficient String Concatenation in Go

1. The + Operator

Generate Random Strings in Go

1. math/rand for Non-Security Uses

How to Check Whether a File Exists in Go

1. Check with os.Stat

How to Check Whether a Map Contains a Key in Go

Check a Key

How to Create Enum-Like Types in Go

1. A Simple Enum-Like Constant Set with iota

How to Get a Slice of Map Keys in Go

1. Collect All Keys with range

How to Safely Convert a String to an Integer in Go

1. Use strconv.Atoi() for int

Learning Interfaces in Go: Concepts, Examples, and Best Practices

What Is an Interface?

Loops in Go: A Practical Guide with Examples

1. Basic for Loop

Manage Goroutine Work Queues Efficiently in Go

Why Use a Queue?

1. A Basic Channel-Based Queue

Maps in Go: A Practical Guide with Examples

Creating a Map

Practical Ways to Combine Slices in Go

1. Combine Slices with append

Pretty-Printing JSON in Go with MarshalIndent

1. Use json.MarshalIndent

Several Ways to Handle Optional Parameters in Go

1. Variadic Parameters

Structs in Go: A Practical Guide with Examples

Define a Struct

Working with Time in Go Without the Headaches

Current Time

Common Function Patterns in Go with Practical Examples

1. Basic Functions

Encrypt and Decrypt Data in Go with AES-GCM

AES-GCM in Brief

Complete Go Example

How It Works

Key Management Matters

Implement HMAC Message Authentication in Go

Pointers in Go: A Practical Guide with Examples

Declaring a Pointer

Search Multiple Texts Concurrently with Goroutines in Go

Overview

Complete Example

How It Works

A Practical Note

Variables in Go: A Practical Guide

Declare Variables with var

Implement Validation in a Go Web App with Gin

Project Structure

1. `strconv.Itoa()`

1. The `+` Operator

1. `math/rand` for Non-Security Uses

1. Check with `os.Stat`

1. A Simple Enum-Like Constant Set with `iota`

1. Collect All Keys with `range`

1. Use `strconv.Atoi()` for `int`

1. Basic `for` Loop

1. Combine Slices with `append`

1. Use `json.MarshalIndent`

Declare Variables with `var`