The Marketplace Of Ideals
On Handmade, polarizing Internet debate, rational discussion, controversial personas, tribal conflict, and how they relate to the future of computing.
When I first learned programming, I was told—by peers, Internet tutorials—and later, when I was in university, by professors—a number of rules. They included ideas like “abstraction is good, to avoid lower level details”, “manual memory management is difficult and you should not do it”, “never write systems from scratch”. The justification for every rule was that it allowed one to avoid programming problems, rather than allowing one to conquer programming problems. In fact, it seemed as though every “rule” presented to me was driven by a hatred of programming, rather than a love for it.
I shrugged much of this advice off, but initially internalized much of it too.
And then, I found Handmade Hero, in which the host, Casey, demonstrates what writing a game for a Windows PC looks like—from scratch. Every minute of programming—from confusion, to debugging, to sketching out solutions, to typing code—spent on the project is captured live, on a Twitch stream.
Now, everyone knows the Carl Sagan quote—“If you wish to make an apple pie from scratch, you must first invent the universe”—and the series didn’t kick off with a deep dive into quantum mechanics (if that is indeed what would help one invent a universe). But “from scratch”, for Handmade Hero, meant what it used to mean for game developers and systems programmers in the ‘80s or ‘90s: no libraries, no complex programming language features, just writing straightforward, procedural, C-style code to directly command the machine about what must be done to produce the effect of a game (interfacing with operating system or GPU APIs when necessary).
Handmade Hero didn’t justify itself with rational arguments immediately. It didn’t justify its existence by debating the utility of libraries, the tradeoffs of modern programming language features, nor a balanced breakdown of its more traditional programming techniques as compared with modern programming approaches. It justified itself with something deeper: care for the product. Handmade Hero’s announcement trailer presented game development as a labor of love—a craft—best done by those passionate about it.
For me, Handmade Hero was immediately captivating because I’m, by temperament, contrarian. If I’m in a room with 100 people, with 99 of them repeating identical dogma, and the remaining 1 passionately and unapologetically presenting a unique perspective, I’m always curious about that one person, and I’m always interested in what they have to say, even if I don’t always end up agreeing with them unilaterally. But, in many cases, I am convinced by that one person—and this certainly was the case with Handmade Hero.
After watching the series for a while, I became sure that all of those “rules”—the ones I mentioned above—were wrong. Programmers who cared about what they were doing—the ones who cared enough to handcraft something from scratch—didn’t need to be infantilized. They could understand computers to a much better degree. They could understand problems from first principles, and write solutions from scratch. They could eliminate dependence on libraries, and have a much greater degree of control over their projects. Unchained from a number of technologies written by others, they could achieve entirely new possibilities, which would’ve been incomprehensible for programmers not in on the secret. Love for the craft provided vastly superior results.
Handmade Hero ignited a fire that spawned a rapidly growing community. It was filled with many older programmers who found a renewed interest in the ideals that initially motivated them to program. But it was also filled with many young programmers, empowered by their new understanding of the process of programming, as it was originally done. There were a number of amazing projects—all breaking what everyone used to believe were the “laws of programming”. 17, 18, 19 year old programmers had projects that made an embarrassment of university computer science senior capstone projects.
Handmade Hero also provided a glimpse into the state of computing—what did an experienced programmer, who grew up in an earlier age of computing, think about modern computers? How had the field progressed—or not—since they were a kid?
And with that glimpse came an immense frustration—that same community, at some point deemed the “Handmade community”, felt like computers had been wasted. The community had learned many of the principles required to build software to a much higher standard—and yet every program on modern computers was immensely frustrating. Almost every program was slow, unethical, annoying, and exploitative—and what’s worse? It wasn’t always that way! Computer hardware had become faster, not slower! Consumer machines had several orders of magnitude more compute power, more memory, more long-term storage! It had become more trivial, not less, to solve security and ownership problems! And yet software then ran slower, less reliably, required more Internet access, and seemed to exploit the user more than 20 years earlier. It became undeniable to everyone that the computing industry was no longer run by those who loved the craft—but by those who exploited the craft for other purposes.
Why? What caused this exceedingly obvious state of decay?
The community found purpose in its newfound lessons—part of the reason was perhaps that modern programming advice, education, and techniques were entirely misguided. Maybe selling books about absurdly complex language features became prioritized over doing a good job. Maybe many modern programming languages were more about the programmer, rather than the user. Maybe older approaches—older languages, older tooling, older styles—were a much more valuable place to start. Maybe the institutionalization and corporatization of programming education eroded standards, and drove toward the production of programmers as replaceable widgets in a gigantic corporate apparatus, rather than skilled, irreplaceable craftsmen. Maybe cushy corporate programming jobs were prioritized by capable engineers over the riskier path of competition.
Maybe this whole “Handmade” approach was the answer. Maybe the community had something to offer in solving problems in software. With frustration came drive—and motivation. Programmers in the community felt that—while they certainly couldn’t solve everything—they could at least build a corner of the computing world that didn’t suck so terribly. They could at least use what they had learned from Handmade Hero, and build more great games, or engines, or tools—and some dreamed even further, to operating systems, toolchains, and computing environments.
But with that initial frustration—often public frustration, expressed both in the original series and later by followers of the series—came a critical response of the Handmade community. The criticism was that the passionate, harshly critical, and blunt comments made by those in the community, or adjacent with the community, were “polarizing”, or “inflammatory”, or “toxic”, or “overly hostile”. The programmers in the Handmade community had no right to criticize software, at least in the way they were doing so. The problem was not that the software world had failed, it was that the criticism of the software world was too unkind. Or, even if the software world had failed, laying harsh blame on any product, committee, or person was inappropriate. Really, those people are just trying their best. Blame—the argument goes—must be diffuse. It is a “collective failing”, not a failing of any individual.
In many public conversations on the topic, the conversational dynamic shifted. The conversation was about the behavior of those being critical of software—not software itself failing the user. Maybe it was possible to criticize, or improve, software without being so fiery—without being so harsh. Maybe the Handmade community went too far. After all, sometimes “abstractions are good”, and sometimes “libraries are okay”, and sometimes “manual memory management should be avoided”, and sometimes one “shouldn’t write systems from scratch”, and sometimes people on a committee really do just try their best, and the result doesn’t turn out so well, and that’s okay. And besides, why be so fiery on social media? Why jeopardize employability, or friendships, or follower counts? Why not persistently affirm the work of others—irrespective of how you feel about it? After all, they spent so much time and effort on their work—that necessitates that it’s valuable. And really, what the Handmade community’s behavior reinforced was an ugly stereotype of game developers being assholes on the Internet. And you don’t want to be an asshole on the Internet, do you? How about you just sit down, shut up, and keep quiet?
The degradation continued with attempts to rationally deconstruct the community’s core purpose itself. What did “Handmade” really mean? Surely it isn’t practical to write all systems from scratch. Surely manual memory management can’t be done well for everything, at least not if you’re any short of a programming demigod. Surely it’s wrong to look down upon the failures of software—they are a perfectly predictable consequence of nature, and the best one can hope for is incremental progress, and incremental progress is hard.
As this shift in tone continued, the community nevertheless grew—but the new members didn’t have the same fire which characterized the original community. They had adopted the conceptual framing of the programming world at large. The rules of which I spoke were, yet again, rules. Following along with Handmade Hero was no longer a rite of passage for newcomers—after all, it’s over 600 episodes long, and who has time for that?! (and who has time for even the first 20 or 30?!) But even if it were shorter, it no longer was a useful embodiment of the community’s popular values. To the new community, it was too opinionated. It wasn’t nuanced enough. It wasn’t respectful of programmers writing most software. It was too harsh. At this point, the newcomers to the community were not “Handmade programmers”, and they still aren’t.
With this shift came the extinguishing of the fire which drove the community in the first place—indeed, the fire—the frustration, the unapologetic standards—was that which produced the passion, the motivation, the drive to do better. When the community buckled under the critical pressure, it was defeated—every core value upon which the community was built became necessarily supported by a “sometimes”, or “maybe”, or “probably”. Engineers producing bad software couldn’t be blamed—it was structures and systems at fault. The community failed to gatekeep against those who disagreed with its premises, and as such was subject to a deluge of average Internet programmers. It ceded linguistic frame, ideological ground, and its base axioms to outsiders, and failed to defend itself on such ground. The community, preferring nominal growth over loyalty to its roots and conviction in its values, became akin to virtually all online programming communities—many community members parroting some of the same propaganda that the community once notoriously rejected.
In ceding ideological territory to its opponents, in an effort to gatekeep less, and to create a wider umbrella under which more individuals could feel unoffended, the Handmade community made a critical error in misunderstanding the forces responsible for its creation.
In 2018, I became responsible for a major portion of the formal Handmade community—known as Handmade Network, which began in the wake of the initial Handmade Hero series—and I adopt responsibility for this critical error. It is with years of reflection and thought that I write this, in hopes of capturing what I found my mistakes to be. I left as community lead of Handmade Network in 2022, and it was largely due to what I write about today, although such feelings didn’t easily manifest into words at the time.
In adopting responsibility, I hope that what I’ve written thus far about the Handmade community is not seen as an attack on its future—but rather a diagnosis of its decay in the past, which I oversaw. The Handmade community’s story is not over, and I write this partly to defend its original history and roots, which—as I’ve written—has been denounced by many.
The Handmade perspective arose—and was felt so strongly, by so many—because of a vision about what software could be like. It began as a look into the past—at how good software once was, and how programming once was—which fueled imagination about what computers might instead become in the future, if carefully guided. It even had a compelling story about how software might be carefully guided to produce that better future—and that story was rooted in love for the craft, not love of oneself.
In other words, it was a vision about a goal; an ideal: an aesthetic ideal about what it meant to program, and what it meant to be a programmer. Handmade programmers were not egg-headed academics, but were competent engineers—familiar with their hardware, and their true, physical problems. They did not seek social acceptance, nor approval, if their product sucked and they knew it. In this ideal, programmers—if not designers themselves—understood the critical role of design. They did not busy themselves with abstract, academic problems, at least not as part of their day-to-day projects—they were concerned first and foremost with the machine code which would eventually execute on a user’s machine, and what effects that machine code would produce.
They weren’t necessarily allergic to using someone else’s code, nor were they allergic to abstractions, but they understood both as a double-edged sword, with serious tradeoffs and implications, and thus used both extremely conservatively. They were responsible for code they shipped that ran on a user’s machine, period—whether they wrote it or not; as such, they rejected forests of dependencies, and built at least most of their software from scratch, in true Handmade fashion. They loved and cared about the result, and what it meant to the person using it—as such, they wanted the most productive and useful tools for the job, without compromising that end result.
In short, the ideal was that the act of programming is for the product, not the programmer. Becoming a programmer meant becoming as effective as possible at the craft of producing the highest quality software, and nothing else. Many other ideals follow: high performance, reliability, flexibility, user-driven computational abilities, practical and grounded programming tooling, ethical software respecting the user’s time and choices, and beautiful visual design.
In this ideal, if the software is bad, then it’s the software maker’s burden. Somebody is at fault—the engineering failure is somebody’s responsibility. The call to action is to empower oneself such that they might outcompete such failures, and build a simpler and more functional computing world, piece by piece.
Understanding that this perspective is in fact ethical is crucial, because it distinguishes it from a set of logically derived propositions. Handmade ideas about software apply only within a particular ethical frame. Furthermore, that ethical frame is not universally agreed upon, nor can it be, because it’s not derived from scientific observation, nor logical analysis; it’s derived from aesthetics and values. It’s derived from what someone loves, not what someone rationally derives.
The visceral response which saw the original Handmade community as toxic, or hostile, or dismissive was not a response to any logical proposition originally made—it was a response to the prioritization of the product over the programmer. Such a response came from a disagreement about what is defined as a burden, and on whom a burden is placed. The Handmade programmer believed in accepting personal responsibility, and providing something better—the culturally dominant trend in the programming world, however, was to collect a paycheck and abdicate responsibility for low-quality software. To such people, it is, in fact, the system and the process that is the problem (if there is a problem at all)—not any individual in particular. Such people are made inadequate by craftsmen who love their work—and so to them, Handmade was an ideological threat.
This, importantly, is not a disagreement which can be resolved by hashing it out with rational debate; it arises at a deeper level, which can only manifest as some form or another of tribal conflict.
The hostile arguments often seen on social media between Handmade-style programmers, or game developers more broadly, and—for instance—modern C++ programmers, or web programmers, is not occurring within the often-referenced marketplace of ideas—the hypothetical space in which competing perspectives are solved through calm and rational debate provided a common goal—but instead in the marketplace of ideals, in which broad common ground ceases to exist.
The Handmade view of software has ugly implications for programmers—if its premises are accepted, then it follows that: several large software projects to which individuals have dedicated careers are valueless wastes of time and energy; virtually every field of (at least) consumer-facing software has decayed dramatically in talent, in output, and in productivity; the $100,000 college degree that everyone was required to obtain, and to accumulate debt for, was merely a signaling mechanism, rather than a certification of any technical ability; a huge swath of programming tutorials, programming books, and organizations are basically fooling themselves into believing they’re doing productive work, when in fact they’re shuffling around bits of memory for personal pleasure and gratification; some people who call themselves “programmers” are not doing programming; some people who do program should not be producing software for others; and plenty more.
But none of that needs to matter. For some, it’s more important that they personally find themselves comfortable, and so they choose to prioritize the programmer over the product.
Because Handmade programmers—among others who’d like to change the course of software for what they see as the better—are operating not in the marketplace of ideas, but rather the marketplace of ideals, it’s crucial that they understand that they’re not involved in rational debate, but the Internet equivalent of ideal-based tribal conflict. And indeed, this is why “technical discussions” about—say—programming languages are virtually never conducted nor won with technical arguments. Data is never collected, assertions are never scientifically justified, and promises to investigate further scientifically are conveniently delayed—permanently.
But notice that arguments about technologies—presumably battling for adoption, social acceptance, and popularity—are not only empirically not about rationality, but definitionally cannot be about rationality. A beginner who knows nothing about programming cannot select an ecosystem or technology based on rational arguments, because they’re removed from the technical context which makes such arguments meaningful. They can only select by second-degree metrics of qualities they care for—popularity, what someone seems to produce with said technology, how quickly they produce it, the unique qualities of that production as opposed to those of others, and so on.
In short, for those who want more prevalence of the “software craft”, in which responsible programmers are more akin to a homemade woodworker than a corporate slave, the battle over social dynamics and human motivation are paramount.
In such a battle, there is much wisdom to be gained from Handmade Hero—its initial justification of itself was a value proposition, not a logical argument. Its community’s idols, its leaders, and its followers came across as dismissive and polarizing because they loved their craft, and because that was what was most important. That behavioral characteristic was responsible for motivating the community, and for promoting human action by those within the community. They wanted good software, and they knew how to make it, and if others wanted to produce crappy software, fine, but it was simply unacceptable for inadequacy to be the industry’s default.
Therefore, there is in inextricable link between the fire, passion, inflammation—the “toxicity and dismissiveness”—and the prevalence of the values. The former is what drives the latter. To expect the latter to arise detached from the former is to ignore the true causal relationship between the two.
Furthermore, the public fire, passion, and polarization is the most useful tool in promoting the value system. In acknowledging that the “software craftsman” perspective—the Handmade perspective—is not logically defined but ethically defined, it can assert itself aesthetically. It can loudly proclaim that there is a better way to make software, and it can loudly denounce the work of its opponents. In doing so, the Overton window about software is shifted. The average programmer becomes exposed to a wide variety of value systems, and of value frameworks about programming. As such, his null hypothesis about, for instance, libraries, one’s ability to write systems from scratch, one’s dependence on vast forests of middleware and abstraction layers, is changed.
With the ethical system’s public presence, the default probability of certain courses of action change. Maybe it is better to write systems from scratch. Maybe operating with care as a responsible engineer produces not only much better, but much more fulfilling results. Maybe the world improves with such software. Maybe we improve, if we hold ourselves to that higher standard.
Ethical systems win not by rational debate, but by hoisting their underlying aesthetic on a banner, and going to battle. Ethical systems which fail to step foot onto the battlefield are not winning by avoiding the “silly game” of tribal conflict—they are dying with their foolish believers, who mistook their cowardice for ascension above the human condition.
In short, the side which thinks itself above the human condition—and indeed, the need for public struggle between ethical systems, and the need to loudly proclaim one’s aesthetics and goals—will lose to the side which is dedicated to victory, even if through tribal warfare.
If you enjoyed this post, please consider subscribing. Thanks for reading.