Preface: Why Build Yet Another Go Framework

In today’s highly mature Go ecosystem, “building yet another Go web framework” may seem redundant—or even boring.

We already have:

• Feature-rich, full-stack frameworks with massive communities
• Performance-oriented, low-level HTTP / RPC frameworks
• Cloud-native application runtimes deeply integrated with Kubernetes
• Complete engineering systems tailored for microservices

Plumego is not meant to compete with them.

The motivation behind Plumego comes from a different, often overlooked, set of real-world engineering needs:

Introduction: Comparing Frameworks Is Ultimately About Values

In technical communities, discussions of “Framework A vs Framework B” never seem to end.

But experienced engineers usually understand one thing clearly:

Framework debates are rarely about right or wrong technology—they are about value trade-offs.

Plumego was not created in a “blank market.”
On the contrary, it deliberately chose a seemingly “unattractive” path in an already thriving Go ecosystem.

Therefore, this article does not attempt to prove that:

Introduction: A Responsible Framework Must Define Its “Non-Use Cases”

Any framework that takes engineering quality seriously must be willing to answer one question:

“In what situations should you not use me?”

If a framework claims that it:

• fits every team,
• fits every stage,
• fits every business,

then it is almost certainly not credible.

Plumego was never designed to be a universal answer.
It is a choice explicitly created for a specific class of engineering problems.

Plumego Advanced Guide: Designing Explicit, Scalable Go Services

Introduction: Beyond the Basics

The introductory Plumego documentation explains what Plumego is and why it exists. This guide focuses on a different question:

How do you design serious, long-lived systems with Plumego?

This article assumes that you already understand:

• Go fundamentals
• HTTP server basics
• The core Plumego APIs
• The philosophy of explicitness

What follows is an advanced, production-oriented tutorial. We will explore architectural patterns, not just APIs. The emphasis is on design decisions, trade-offs, and operational correctness—the areas where Plumego provides leverage without hiding complexity.

Introduction: Why Another Go Framework?

The Go ecosystem does not suffer from a lack of web frameworks. From minimalist routers to batteries-included solutions, developers can choose from a wide spectrum of abstractions. Yet, despite this abundance, many experienced teams eventually encounter a recurring problem:

Their framework either does too little to guide large systems, or too much to stay out of the way.

Plumego exists in the narrow but important space between these extremes.

A Calm, Developer-Focused Comparison

Python, Go, and Rust are three of the most influential languages in modern software engineering.
They represent three different philosophies:

• Python: simplicity & productivity
• Go: concurrency, cloud, and production reliability
• Rust: memory safety & high performance

This article provides a clear, concise, and practical Birdor-style comparison to help you decide which language fits your next project.

1. Design Philosophy: What Each Language Values

Python — Readable, expressive, productive

Python prioritizes human time over machine time.
The design is optimized for:

Go’s net/http package is fantastic—but sometimes you want to see what’s really happening under the hood.

In this article, we’ll build a tiny HTTP/1.1 server from scratch, using only:

• net — for TCP sockets
• bufio — for buffered I/O

No net/http, no handler interface, no magic.

You’ll learn:

• How HTTP/1.1 requests look on the wire
• How to parse the request line and headers
• How to build a minimal response (status line, headers, body)
• How to handle multiple connections with goroutines
• A tiny router for different paths

This is not production code—it’s a learning tool. But it’s a great way to deeply understand HTTP.

Go’s net/http package is deceptively simple on the surface—just call http.ListenAndServe() and pass a handler. But beneath its minimal API lies a highly optimized, battle-tested, and beautifully engineered HTTP runtime.

This article explores the internal architecture, concurrency model, lifecycle, request handling flow, connection reuse, transport behaviors, and performance strategies that make net/http one of Go’s most iconic packages.

This is a true deep dive—use it to understand how Go’s HTTP stack really works under the hood.

High-performance networking is one of Go’s strengths. With lightweight goroutines, a rich net package, and strong concurrency primitives, Go is a great fit for building custom TCP servers, game backends, proxies, and internal protocols.

In this article, we’ll design and implement a high-performance, multi-goroutine socket server in Go, with an architecture you can evolve into a real-world production system.

We’ll cover:

• Architecture and design goals
• A baseline TCP server
• A multi-goroutine concurrency model
• Connection limits and backpressure
• Request handling with worker pools
• Graceful shutdown and observability

1. Goals and Design Principles

We’ll design a server that:

The net package is the foundation of all network programming in Go.
Everything — from HTTP servers to gRPC, Redis clients, DNS resolvers, and low-level TCP/UDP tools — ultimately relies on Go’s networking stack built around the net package.

This article provides a deep, practical, and complete exploration of net with clear explanations and runnable examples.

1. Why the net Package Matters

Go’s networking model is:

• Simple – Uses familiar Unix-style sockets and file descriptors.
• Cross-platform – Same code works on Linux, macOS, Windows.
• Concurrent by design – Each connection can be handled by a goroutine.
• Powerful – TCP, UDP, Unix domain sockets, DNS, interfaces, IPs, CIDR tools, etc.

Higher-level packages rely on it:

Go’s context package is one of the most important tools for building robust, cancellable, timeout-aware, concurrent programs. Whether you are writing HTTP servers, gRPC services, background workers, or database operations, you will almost always use context.Context.

This article provides a deep, practical, and complete analysis of the context package using clear code examples.

1. Why context Exists

Modern Go programs are highly concurrent. You might start goroutines for:

• database queries
• API calls
• background tasks
• streaming events

But how do you cancel a goroutine?
How do you propagate deadlines across function calls?
How do you attach request-scoped values safely?

Go (often called Golang) is a modern programming language designed at Google. It focuses on simplicity, performance, and built-in concurrency. If you want to build fast web services, CLIs, tools, or backend systems, Go is a great choice.

This article will walk you through Go from zero to a small, working example, with plenty of code you can copy, paste, and run.

1. What is Go and Why Use It?

Go is: