I do not understand.”
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’ll dig deeper into the runtime. If someone gives us C++, we’ll dig deeper into the machine code. If someone gives us machine code, we’ll dig deeper into the microarchitecture. There is a real computer behind our magic abstractions, and we want to understand what makes it tick.
We like to reinvent the wheel.
Many programmers think that writing software 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 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 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 “best practices” still produce terrible software, maybe the “best practices” 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 more than 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.
We are happy when the user is happy.