Networking & Web, in Go

The reliable byte stream — net.Dial and net.Listen, the Conn interface every connection implements (an io.Reader+Writer), framing a byte stream, read/write deadlines and net.Error, and one goroutine per connection.

Connectionless datagrams in Go — net.ListenPacket and ReadFrom/WriteTo, DialUDP, message boundaries with no delivery guarantees, encoding a datagram payload, MTU and fragmentation, and when UDP beats TCP.

From names to numbers — net.ParseIP and net/netip, SplitHostPort/JoinHostPort, CIDR prefixes and subnet membership, and the net.Resolver that turns hostnames into IPs over the network.

Turning a TCP byte stream into messages — delimiter vs length-prefix framing, encoding/binary and network byte order, io.ReadFull, and designing a header-plus-payload protocol with a version field and checksum.

Serving HTTP in net/http — handlers and HandlerFunc, the ResponseWriter and Request, the Go 1.22 method+pattern ServeMux with PathValue, decoding request bodies, and a production-shaped http.Server with timeouts.

Calling services with net/http — http.Get vs a configured http.Client with timeouts, building requests and posting JSON, checking status, closing and draining the body, connection reuse via Transport, and context cancellation.

Dispatch and cross-cutting concerns — the Go 1.22 ServeMux (method+path patterns, wildcards, precedence), path values, middleware as Handler-wrapping-Handler, chaining order, and recovery/logging middleware.

How TLS secures HTTP — the handshake, certificates and the CA chain, serving with ListenAndServeTLS, verifying clients, mTLS, and autocert.

Defensive defaults for Go web services — security headers and HSTS, parameterized queries against SQL injection, html/template auto-escaping against XSS, body-size limits, constant-time secret comparison, and never leaking internal errors.

JSON over HTTP done right — resources and methods, idempotency, decoding/validating requests and encoding responses, the status codes that matter, consistent error envelopes, and versioning.

Typed, fast service-to-service calls — Protocol Buffers, the four RPC kinds, code generation with protoc, and HTTP/2 streaming over plain REST.

Full-duplex, persistent connections over one TCP socket — the HTTP Upgrade handshake, frames, ping/pong keepalives, and when to choose them over SSE or polling.

One-way push over plain HTTP — the text/event-stream format, flushing events, auto-reconnect with Last-Event-ID, and when SSE beats WebSockets.

When the client just asks again — short polling on a timer vs long polling that holds the request open, their costs, and when polling is the right boring choice.

The other side of polling — an external service POSTs to your endpoint when something happens. How to receive one safely: verify the signature, ack fast, dedupe for idempotency, and process out of band.

Calling Go functions across a wire — net/rpc and JSON-RPC, plus the serialization choices underneath: gob vs JSON vs protobuf and their trade-offs.

Go's driver-agnostic SQL layer — sql.Open returns a connection pool, parameterized queries stop injection, Scan reads rows, and you always close them.

Begin, Commit, Rollback — grouping statements into all-or-nothing units, the defer-rollback safety pattern, ACID, and isolation levels.

Choosing drivers and datastores — pgx for relational/transactional data, go-redis for caching and sessions, and the cache-aside pattern that ties them together.

cmd/internal/pkg layout, accept-interfaces dependency injection, wiring in main, config from env/flags, and why Go rarely needs a DI framework.

Catching SIGINT/SIGTERM with signal.NotifyContext, draining in-flight requests via Server.Shutdown, a shutdown timeout, and closing resources in order.