Why Learning Networking Still Requires Pen and

FreeCodeCamp just dropped a 12-hour computer networking course, and the most interesting thing about it isn't the content—it's the delivery method. Instructor Kshitij Sharma teaches the entire thing with pen and paper, working through concepts live like it's 1995. No slick animations. No code-along interfaces. Just diagrams and explanations, the way networking professors taught before bootcamps convinced everyone that education needed gamification.

This feels deliberately anachronistic, and Sharma knows it. "I don't like slides and all," he tells his students early on, "so I'll be teaching you raw pen and paper style." It's a small rebellion against the polish of modern tech education, where every concept comes pre-packaged with interactive visualizations and progress bars.

But here's what makes this approach interesting: networking might be one of the few domains where this actually makes sense.

The Topology Problem

Sharma spends significant time on network topologies—mesh, star, ring, bus—and asks students to calculate how many links exist in a fully connected mesh network with n nodes. The answer is n(n-1)/2, which he derives by explaining that each node connects to every other node exactly once. "In some very basic exams or easy exams these questions could be asked for fun marks," he notes.

This is the kind of problem that looks trivial until you're debugging why your distributed system is exhibiting weird latency patterns at scale, and suddenly you need to reason about connection counts and topology tradeoffs. The pen-and-paper method forces you to internalize the math, not just recognize the pattern.

The course promises to cover everything from "physical media access control up to complex application layer protocols like HTTP and DNS," with modules on IPv4 addressing, error detection (CRC, Hamming codes), flow control mechanisms (Stop-and-Wait, Go-Back-N, Selective Repeat), and transport protocols (TCP/UDP). It's comprehensive in a way that suggests Sharma isn't trying to get anyone job-ready in three months—he's trying to teach them how networks actually work.

What Makes Data Communication Effective

One of the more revealing moments comes when Sharma asks students about network effectiveness metrics. Someone suggests reliability, and he pushes back: "Reliability is not considered to be a metric for effectiveness. Why? For example, in transport layer, we are going to read about two protocols TCP and UDP. There you will learn that UDP is not reliable but still it is significantly used."

Instead, he identifies four actual effectiveness metrics: delivery (data reaches the correct destination), accuracy (data isn't corrupted), timeliness (data arrives when needed), and jitter (consistent timing between packets). This framework cuts through the usual hand-waving about "reliable systems" that dominates software engineering discourse.

The UDP point is particularly instructive. We've spent the last decade building systems that assume reliability as a default, adding complexity to achieve it even when the use case doesn't require it. Video streaming, gaming, real-time communications—these all tolerate packet loss better than they tolerate latency. Understanding why UDP exists and when to use it requires thinking about the actual constraints of data transmission, not just reaching for the "reliable" option because it feels safer.

The Walkie-Talkie Explanation

When explaining transmission modes, Sharma uses walkie-talkies to illustrate half-duplex communication: "While you talk over a walkie-talkie, you cannot both talk simultaneously. That's why you use the word like over and out so that the other person may know that the first person is not going to speak in between."

This is pedagogically clever—it maps a technical constraint (single-lane bidirectional communication) to a lived experience most people have had. But it also reveals something about networking education: the concepts aren't actually that complex once you find the right analogies. The difficulty comes from the accumulated jargon and the assumption that everything needs to be explained in terms of abstract protocols rather than concrete mechanisms.

Sharma's target audience includes GATE exam aspirants, university CS students, and people preparing for technical interviews. The course assumes familiarity with data structures and algorithms—"you should know what is a queue, what is stack and all these things"—because he'll be covering routing algorithms like Bellman-Ford and Dijkstra.

This prerequisite structure makes sense. You can't understand routing without understanding graphs, and you can't understand flow control without understanding queues. But it also means this isn't an "intro to tech" course trying to make networking accessible to absolute beginners. It's assuming you already have a foundation and want to understand how the internet actually moves packets around.

The Textbook Wars

Sharma's reference stack is revealing: Forouzan as the primary text ("This is the bible. You should have a copy"), Tanenbaum for "in-depth theoretical foundation," and Kurose-Ross's top-down approach for people who are "absolutely crazy and want to read all these three books."

These aren't random recommendations—they represent different philosophical approaches to networking. Forouzan is comprehensive and traditional. Tanenbaum goes deep on the theory. Kurose-Ross starts at the application layer and works down, which reverses the typical bottom-up teaching approach. The fact that Sharma references all three suggests he's not dogmatic about pedagogy; he just wants students to understand the material however works for them.

The course also includes a "bonus module" on cybersecurity, covering "how security is maintained among the networks." This addition feels like a concession to reality—you can't teach networking in 2024 without addressing security, even if it wasn't traditionally part of the curriculum. The CIA triad (Confidentiality, Integrity, Authentication/Authorization) gets mentioned, with Sharma immediately assigning homework: "What is the difference between authorization and authentication? Because some people are mentioning authentication, some are mentioning authorization."

This is the kind of confusion that seems trivial until you're implementing an access control system and realize you've been using the terms interchangeably.

The Market for Fundamentals

What's striking about this course existing at all is what it suggests about the gap in networking education. We have thousands of tutorials on building web apps, deploying to cloud platforms, and using frameworks. But understanding subnetting, CIDR blocks, and VLSM? That requires sitting down with pen and paper and working through the math.

The course runs over 12 hours, which means it's competing with every other demand on a learner's time. Nobody accidentally watches 12 hours of networking fundamentals. You do this because you've hit a ceiling in your understanding and realized you need to go back and learn what's actually happening under the abstractions.

Sharma's teaching method—theory, practice, daily practice problems (DPP), and revision—assumes students will do the work between lectures. "You will not attend the class without solving the DPP," he tells them. This isn't content you passively consume; it's material you have to metabolize through practice.

The pen-and-paper approach, then, isn't nostalgia. It's recognizing that some concepts need to be worked through manually before they click. You can't really understand subnetting by watching an animation of it. You need to borrow bits, calculate subnet masks, and make mistakes until the pattern becomes automatic.

Whether this works for a YouTube audience accustomed to quick wins and dopamine-optimized content delivery is an open question. But it's clarifying to see someone bet that there's still a market for doing the hard work of actually understanding how things work.

Marcus Chen-Ramirez is a senior technology correspondent at Buzzrag.