Seven Hours of Beginner C: What Dr. Jonas Birch's Project Marathon Actually Teaches

Dr. Jonas Birch published a seven-hour, twelve-minute video this week compiling four beginner-to-intermediate C projects: a Wordle clone, the classic GetNextLine challenge, a printf implementation from scratch, and a simple dice game. The video, posted on his channel under the title "4 different Beginner C projects" (youtube.com), is billed as approachable for beginners while remaining interesting for seasoned C developers. Both halves of that promise deserve scrutiny, because the video delivers on each of them unevenly.

The Honest Selling Point: Watching Someone Debug

Most programming tutorials are edited to hide the struggle. Birch does the opposite, and it's the most valuable thing about the video. He opens the Wordle segment by downloading a University of Michigan English word list, then cleans it with wget, sort, uniq, and grep using extended regular expressions to filter for five-letter words. Then reality intrudes: the regex matches words containing dashes and parentheses, the head of the file looks fine, and some entries still are not five letters.

His response is instructive. Rather than perfect the regex, he decides to add a runtime check in C instead: "I might have a solution, but in my head, but I don't want to dig into that right now because that can be pretty time consuming and advanced." A five-character check in the loading function catches whatever the shell pipeline missed. That is a real engineering decision, trading purity for momentum, and it happens on camera.

The debugging continues throughout. His first working test compares "cannon" against "nylon" and produces colors he cannot explain: "We do get different colors, but I'm not sure what it's based upon." The cause is swapped arguments in the check-word function. Any beginner who has stared at plausible-looking output wondering what went wrong will recognize the moment.

The Declared Constraint, and How It Holds

Birch states in the video description that he avoids pointers, structs, and advanced macros where possible. The transcript shows how well that goes. Strings in C are pointers whether you like it or not; he concedes this early, saying of a character parameter, "I will try to avoid pointers but, in this case, it's a string, so that's always denoted as a pointer." By the file-loading segment he is weighing dynamic memory with malloc against a static array, briefly attempts a struct-based return type, hits compiler errors, and retreats: "I don't really like global variables, but sometimes it's the easy way out. They are, after all, allowed in the C language."

Two lessons emerge here, and they point in different directions. For a beginner, watching a competent programmer hit the wall where "avoid pointers" stops being possible is more honest than any curriculum that pretends the wall does not exist. For a skeptic, it is a reminder that C's type system gives you no escape hatches: you will use pointers, the only question is whether you understand them when you do.

How This Wordle Compares

Birch's version loads all 5,172 words into a static two-dimensional array and validates guesses by linear search through that array, one strcmp-style comparison at a time. It works. Is it optimal? Not remotely, and that is fine for a teaching project.

For contrast, consider the open-source Wordle-C project on GitHub, which explicitly avoids loading entire word lists into memory and searches files on demand during gameplay, trading lookup speed for a smaller footprint. And this exercise is common enough that it appears in university coursework: a University of Texas CS303E project asks students to build the same game, with the same validation rule that a guess "must be a 5-letter word in the wordlist" before it consumes a turn. Birch independently arrives at the same design, penalizing an invalid dictionary word with a lost round while forgiving wrong-length input for free.

The compression point is worth naming: Birch's linear scan over 5,172 words per guess is fine at this scale and would be a problem at any larger one. His stated philosophy, prioritizing simple and reliable over optimized, is defensible for teaching. It would also be worth an explicit sentence in the video, since beginners tend to carry their first data-structure habits forward.

Scope, Structure, and What You Actually Get

The Wordle build alone consumes nearly four hours of the runtime, split across two parts. The finished product is 323 lines in a single C file, and Birch is candid about the result: "It grew bigger than I anticipated. And the structure is not so good as I anticipated either. But it works as intended and it's safe and secure."

The remaining segments shift in character. GetNextLine, a well-known challenge from the 42 school curriculum, reads standard input byte by byte using the heap, handling Unix and Windows line endings and error cases. The printf implementation rebuilds formatted output with no library dependencies, and the dice game closes things out at a lighter weight. The composite format means uneven pacing by design; you get four discrete sprints rather than one curated arc.

One caution from the source summary: the Wordle implementation as presented ends mid-build, during guess validation, before the full game loop is complete. Viewers hoping to copy a finished artifact should expect to finish some wiring themselves.

Who Should Watch This

The video works best as a companion, not a primary course. Someone who has read a C tutorial and understands variables, loops, and functions will get the most out of watching a working programmer assemble a real project: the shell-tool data prep, the compile-early-compile-often discipline with GCC warnings enabled, the small refactors when a first design overcomplicates things. A complete newcomer to programming will likely drown in the seven hours, particularly in the GetNextLine and printf segments, which lean on memory management concepts the stated beginner-friendly constraint tries to defer.

Birch asks his standard sign-off question after each segment: "Did you learn anything useful today?" Judged against his own framing, the answer is a qualified yes for a specific audience: the learner who wants to see C's friction up close, unedited, before deciding whether the language deserves a place in their toolkit. The friction is the feature.