There is a cycle in software engineering. We oscillate between centralization and distribution. For the last decade, we have been living through the peak of distribution: Microservices, Serverless, and Kubernetes-everywhere.
But the pendulum is swinging back. And it is swinging back towards "Boring Tech."
Cognitive Load & Gall's Law
Gall's Law states: "A complex system that works is invariably found to have evolved from a simple system that worked."
We ignored this. We tried to build complex distributed systems from scratch using Kubernetes. The result? Exploding cognitive load.
Cognitive Load Theory (Sweller, 1988) teaches us that human working memory is limited. When a developer has to hold the state of 15 microservices, an event bus, a service mesh, and a distributed tracing system in their head just to fix a bug, they are effectively paralyzed.
At R3F, we optimize for Developer RAM. A monolithic Rust or Go binary fits in your head. You can jump to definition. You can run tests locally without spinning up a cloud.
The Lindy Effect of the Binary
The Lindy Effect suggests that the future life expectancy of a non-perishable thing like a technology is proportional to its current age.
Compiling source code to a machine-executable binary is a concept that has survived for 50+ years. It works. Docker containers are great, but a single, statically linked Go binary is the ultimate container. It contains everything it needs.
Complexity vs. Reliability
Complexity is the enemy of reliability. Every network hop is a point of failure. Every JSON serialization is a potential bug. Every dependency is a security risk.
# Typical K8s "Hello World" (Excerpt)
apiVersion: apps/v1
kind: Deployment
metadata:
name: complex-service
spec:
replicas: 3
selector:
matchLabels:
app: complex
template:
metadata:
labels:
app: complex
spec:
containers:
- name: complex
image: complex:1.0
resources:
limits:
memory: "128Mi"
cpu: "500m"
ports:
- containerPort: 8080
---
# Service, Ingress, HPA, ServiceAccount... (200 more lines)The configuration tax of distributed systems.
Compare that to the entry point of a modular monolith in Go:
// main.go
func main() {
// Everything is here. No network hops.
db := database.Connect()
auth := auth.NewService(db)
billing := billing.NewService(db)
// Type-safe, compiled interaction
server := api.NewServer(auth, billing)
server.Listen(":8080")
}Zero latency. Zero serialization cost. 100% Type Safety.
Conclusion: Choosing Stability
We are not anti-Kubernetes. We use it for massive scale. But we don't use it as a default.
Choosing "Boring Tech" means choosing stability. It means respecting your team's cognitive load. It means building systems that survive because they are simple enough to be maintained.