Programmers live in a bizarre world where laziness is rewarded and intelligence is a handicap. Let me explain.

Most of us have accepted that the best programmers are lazy. They will complain whenever they encounter non-automated repetition or searching (you know, the stuff computers were built for). Instead, we can work smarter by automating tasks that pass a magical threshold where the time to automate it is less than the doing it manually X times. Old news.

There’s a complexity threshold that each of us can work within efficiently. Sometimes, we push ourselves and work a little over it, but we are only fooling ourselves thinking that it’s sustainable. When teams are working at different levels, collaboration can be very frustrating (too obvious or too confusing).

If the workplace is busy, or we are personally strained, we are not able to work at that same level. If we push ourselves by always working at our maximum, we are hindered when we’re not at our best.

I’ve been able to appreciate this recently. While working on some old legacy projects, rebuilding the mental model is much more complex with fresh eyes. Add any deadline stress or personal fatigue to the mix, and I can only touch it after hours with absolute focus. That is not sustainable, nor desirable. The result is hopelessly trying to make sense of things: shooting in the dark until things “click” – if they ever do. This may last a few minutes, hours, or even months on a large project. It’s absolutely demoralizing.

This is why TDD works. The amount we need to load into memory is always so small, our personal constraints will never be the bottleneck. It leaves clear next steps, and code the entire team can understand, and even better: write.

Break things down so they are stupidly obvious, and progress becomes fluid and predictable. If you don’t, you are relying on a hero to save the day. That’s a lot of weight to carry.

There’s a certain draw to finding the perfect tools that magically match your list of requirements and save you lots of time and money. If you’re lucky, you may find some that fit, and it’ll be wonderful. Until they don’t.

One of the best parts of being a programmer is the ability to build your own tools. You don’t necessarily have to build your own raw tools, but you should be able to wire them together. Spending a little extra time understanding the tools you use everyday can have major pay-offs.

The more I develop on a unix-based system, the more I appreciate this philosophy. Leveraging a wide array of simple tools, and orchestrating your own solutions will allow you to naturally evolve your workflow as your requirements change.

The alternative is being enslaved to SaaS systems which lease tools to toolmakers purely because they solve your problems for you and hide the complexity. As a developer, it’s our job to embrace and ultimately overcome those complexities.

I see it almost every day…

• How can I automate deployment with myfavoritehost.com?
• How can I integrate my VCS with MegaEditorIDE?
• How can I get CI for my language?
• How can I run tests when the filesystem changes?

All of these features add a ton of complexity to the solutions they integrate with, and the kicker is, none of them are necessary.

• Your host has SSH access. That’s all you need.
• Learn Git from the command line. Any GUI will get you 80% there and then suffocate you.
• CI just needs to run a script. Whether it’s node, java or PHP is irrelevant.
• Your operating system has mechanisms that can tell you when files change. Use that (and leverage it in your toolset).

Master your raw building materials. They’ll help you far more than the pre-packaged solutions that you are being sold.

There’s a hidden benefit to refactoring that nobody seems to mention when weighing the options… the opportunity for learning.

The more often you allow yourself to break down code and rewrite it to be more concise and understandable, the better at it you’ll be. More importantly, you’ll recognize more patterns as you write code and it won’t require the additional refactoring next time.

Similar to the arts and the crafts, you won’t be able to create amazing work unless you practice each and every day. Practicing creates value. Refactoring creates value.