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

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.

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.

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.