I do not understand.”
We love learning how things work.
Many programmers are afraid of learning how systems work behind the scenes—but not us. We are driven to understand how computers work at every layer of the stack.
If someone gives us JavaScript, we’ll dig underneath and find the JIT. If someone gives us C++, we’ll dig underneath and find assembly. If someone gives us assembly, we’ll dig underneath and find the microarchitecture. Behind our magic abstractions is a real computer, and we know that the real computer is the only thing that matters at the end of the day.
We are not limited by the walls put in front of us, and we are energized by deeper understanding of systems.
We like to reinvent the wheel.
Many programmers think that writing things from scratch is a waste of time. They will criticize you for “reinventing the wheel”. They think that 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”. Our software 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 programmer 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. There are no excuses.
We value competence.
There is a popular narrative that we’re all just idiots at the end of the day—that everyone is an “impostor”. We reject this narrative. There are programmers who know what they’re doing, who understand their systems, 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 question “best practices”.
We don’t contort our code in weird ways, 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 worst software in the world follows the “best practices”, how good can those practices really be?
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 more than the programmer.
The user doesn’t care about the code. The user is not impressed by how elegant our solutions are. They only care if their software works, and works well.
We are happy when the user is happy.