Go

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.

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.

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.

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.

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:

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.

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:

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.

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:

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:

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.

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.

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: 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:

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 Copy mkdir myapp cd myapp go mod init myapp 2. Install Dependencies 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.

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:

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: 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.

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: 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.

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: 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.

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: 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.

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 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.

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: 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:

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 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.

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: 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.

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: 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: