Education trains obedience to abstractions, not understanding of systems.
🔹 1. "TCP reliable / UDP unreliable" is a pedagogical simplification
Teachers present it as:
TCP = reliable stream
UDP = unreliable datagram
Students interpret it as:
UDP cannot be made reliable.
But the real story is:
TCP provides reliability because the kernel implements it.
UDP is merely a raw message delivery primitive.
Reliability is not inherent to TCP --- it is implemented logic:
- sequence numbers
- acknowledgments
- retransmission
- congestion control
- flow control
- reordering
- fragmentation handling
These are just features someone chose to put in the kernel.
Nothing stops you from implementing all of that in user space over UDP --- and people do:
✔ QUIC (Google, now HTTP/3) -- reliable, congestion-controlled, over UDP
✔ RTP + RTCP + FEC -- reliable(ish) streaming
✔ ENet -- reliable ordered UDP for game engines
✔ RakNet -- reliable messaging for games
✔ WebRTC DataChannels -- reliable UDP streams
So the "TCP reliable / UDP unreliable" story is just a classroom slogan, not a truth.
When people only learn slogans, they stop asking "why?".
🔹 2. Tutorials often teach consumption, not construction
Most textbooks tell you:
"use TCP if you want reliability"
But never:
"here's how reliability works underneath and why it matters."
This produces engineers who can use sockets but cannot build transports.
Same pattern repeats:
- "use SQL" → not "here's how indexing and query optimization work"
- "use Kubernetes" → not "here's how scheduling and orchestration works"
- "use Python" → not "here's how a VM executes bytecode"
- "use AES" → not "here's why block ciphers are designed the way they are"
- "use AI API" → not "here's how attention or tokenization works"
It's training for dependency, not independence.
🔹 3. Why schools teach half-stories
Partly because it's easier:
- simplifies grading
- reduces cognitive load
- avoids system-level complexity
- fits standardized curriculum
But the more subtle reason:
teaching you how to build systems creates people who don't need systems anymore.
Institutions (education, corporations, government) prefer producing operators , not inventors.
An operator is someone who:
- calls APIs
- configures tools
- consumes platforms
- depends on external infrastructure
An inventor is someone who:
- builds alternatives
- creates new platforms
- threatens monopolies
- understands internals
The world systemically rewards operators, because they plug into the machine.
Inventors complicate the power structure.
🔹 4. This ties into points about lock-in
When people believe UDP "cannot" be reliable, they stop experimenting.
When people believe frameworks "must" be used, they stop building replacements.
Same root dynamic:
- Abstractions become dogma
- Dogma becomes curriculum
- Curriculum produces dependency
- Dependency reinforces the platform
Knowledge becomes siloed and rare.
🔹 5. TCP is actually a historical limitation
Here's a twist:
The fact that TCP is in the kernel actually makes it hard to evolve:
- changing congestion control requires kernel upgrades
- new features require RFC standardization
- ossification happens (middleboxes block new behavior)
Google's QUIC exists precisely because TCP became ossified.
So they moved reliability to user space over UDP
And HTTP/3 is now QUIC by default.
The system came full circle --- user-space reliability won.
🔹 6. Cognitive takeaway
Here are points to a deeper intellectual skill:
Don't treat abstractions as truths.
Treat them as design choices.
Once you see that engineering is just layered decisions, you can imagine alternatives.
Most people never reach that level because they were taught:
- what to use
- not how to think