Programmers are often creators. Being a creator takes vision. Vision to see the destination, and vision to see the course. The destination could be learning a new language or technology stack. The destination could be a product to be released to customers. It could be something done for personal edification. The course is determined by taking that larger goal and breaking it down to manageable steps.
The trick for successfully creating something, is to maintain that vision. But often the vision becomes lost and projects end up stalled or abandoned entirely.
Patience in our work as programmers may be one of the most underrated skills a programmer could possess. There have been many articles (1, 2) written about the benefits of being a so-called “lazy programmer” which can lead to the benefits of automating common tasks. Though, the role that patience plays in persevering in a project is something that seems to get lost in the conversation.
Patience is important on many levels, but two come to mind in particular. There’s the project level, and then there’s the module level.
Patience is useful on the project level when you can see your ultimate goal, but there are barriers to getting it done. A type of project that I frequently undertake is learning a new programming language. It often presents itself as “I want to write X application using X language.” I can see the application in my mind. The barrier to finishing the application is the syntax and ecosystem of the language I intend to learn. Of course, right? The point of the whole project is learn those new things. This is when impatience can be a project killer because shortcuts get taken. The original goal was twofold: 1) language and 2) application. Impatience can shift that goal into becoming a singular goal based on an exciting app, rather than the dual target of learning and also building. Project level impatience is what usually causes my personal projects to languish.
What I’ll call module level impatience is the kind of thing that rears its head when you’re eyeballs deep in code. The ultimate function of the feature being written becomes the focus, and the voice of impatience starts nagging about taking shortcuts to get to the finish line faster. This impatience clouds the reasoning about the individual pieces of the feature being implemented. It is the enemy of clean and maintainable code.
The truth is that when we code with an impatient mindset, then the results will suffer. Patience is required to maintain the project’s vision.