We love learning how things work.
Many programmers are afraid of learning how computers work behind the scenes, but not us. We are driven to understand how systems work at every layer of the stack.
If someone gives us JavaScript, we will dig deeper into the engine. If someone gives us C++, we will dig deeper into the machine code. If someone gives us machine code, we will dig deeper into the microarchitecture. There is a real computer behind our magic abstractions, and we love to learn what makes it tick.
We like to reinvent the wheel.
Many programmers think writing software from scratch is a waste of time. They will criticize you for “reinventing the wheel”. They think the hard problems have already been solved.
But programming is a very young field! Much of the world’s software is a first draft. There is so much room to innovate, and the only way to innovate is by trying new approaches to familiar problems.
As Casey Muratori said on day 1 of Handmade Hero, nothing we have developed in the past 30 years is a “wheel”. Software today is like a bicycle with square wheels, awkwardly clunking along. To make better software, we must reinvent the wheel, and we love that challenge.
We don’t make excuses for bad software.
There is no excuse for bad software. If it doesn’t work, it doesn’t work. If it’s slow, it’s slow. No amount of excuses can make up for software that doesn’t work the way it should.
Good software should respect the user’s resources and use the hardware effectively. It should be fast, efficient, and pleasant to use. It shouldn’t use excessive CPU or memory, and it shouldn’t be janky or buggy. We hold ourselves to this standard no matter what language we choose.
We value competence.
There is a popular narrative that all programmers are fundamentally just idiots or “impostors“. We reject this narrative. You can build real expertise. You can truly understand your systems. There are programmers who know what they’re doing, and who do great work. We aspire to be that kind of programmer.
We like to be self-sufficient.
We like to build things ourselves. We don’t care if someone else has already made a library or a framework for us. We’d rather write the code that we need, when we need it, and learn from what others have built instead of using it blindly.
We like to write the code ourselves.
High-level programming wisdom is born from years of lower-level work. You don't know how to build a system until you've built it by hand a few times. It may be easy to use a library or prompt an AI, but by doing so you rob yourself of the understanding that makes it worthwhile.
We question “best practices”.
We don’t turn our code inside out, write useless tests, or type a bunch of boilerplate unless we understand why. We strive to be experts, not to blindly trust those who claim to be.
After all, if the “best practices” still produce terrible software, maybe it’s the “best practices” that are wrong.
We are not “language people”.
We are not “C programmers”, “C++ programmers”, “Rust programmers”, or “web programmers”. We are programmers, and languages are tools. What actually matters is how the software works, not how the software is created.
We value the user above the programmer.
The user doesn’t care about the code. The user is not impressed by how elegant our programs are, or how quickly we wrote them. They only care if their software works, and works well.
Users can feel when software was made with care and craft. They can also feel when it was made without. Nothing we do as programmers matters unless it actually produces good software.
Explore the best Handmade projects created by the community.