The Secrets to Having a Long and Fulfilling Career as a Programmer
Published: 2024-01-08 14:00:00

This post is not about getting financially successful as a programmer or climbing career ladders to reach a higher social status. I understand that most programmers need a good job to pay the bills and live a good life. But that shouldn’t be the entirety of a career if you think in a life-long context. The only way to have a "successful" career is to make it fulfilling at the spiritual level.

I’ve been in the software industry for close to 20 years. Many programmers in my generation started our careers as idealists — coding gave us such an empowering feeling that we could change the world with our hands. However, to many, programming soon became a daily grind that pays well but feels increasingly tedious, repetitive, and superficial.

Modern software development is so complex that we find ourselves deeply tangled in learning, collaborating, deadlines, operations, firefighting, KIPs, and so on. But the secrets to having a long and fulfilling career as a programmer lie in how you see the programming activity.

## The Aesthetics of Coding Itself

> A classical understanding sees the world primarily as underlying form itself. A romantic understanding sees it primarily in terms of immediate appearance.
>
> ― Robert M. Pirsig, Zen and the Art of Motorcycle Maintenance

We are all born romantic and see things as how they appear. The development of science and engineering and the professions that came from them turned some of us into classical ones. The influence became so strong that they see through the immediate appearance directly to the underlying form. To programmers, we think of coding as the means to an end — the application, the features, the user values, the revenue, and so on. A layman sees nothing in a source code and won’t be interested. But when a programmer reads some code, he starts to "run" it in his head to understand its functionality. However, the beauty of the code itself is often considered irrelevant — or at most to facilitate the understanding of how it works.

If you open the engine hood of a BMW — old or new, you see parts beautifully laid out. If you look at the engine, you’ll find it visually appealing. Taking the engine apart, every piece of it is also aesthetic. If you’re not a mechanic, you probably can’t get the "underlying form" about how these pieces coordinate to move the car, but the immediate appearance is satisfying and attractive. Aesthetics and pragmatism are fully reconciled.

![BMW engine compartment](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4cbhsvrgxvv42goqf0pt.png)

There are many reasons why achieving the same thing in software is difficult. It could be that users can’t open your "engine hood". Or, software, unlike a car, is constantly evolving. However, one big reason is that many of us, worn by the daily grind, have lost interest in the immediate appearance of code. Looking back at the history of programming, you’ll find early pioneers held the bar high for themselves.

```
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
…
```

They may appear to be wise principles, but what’s behind them is care. Care for the coding itself as much as for the resulting product. Care to create aesthetic things around ourselves. Care to rise from a coding mule whipped by deadlines to become an artisan, an artist. Care to put emotion into this purely rational activity.

## The Intriguing Fun of Creating Systems

> You must create because it’s important to you. There is an energy within you which deserves a creative outlet. There is an imbalance in you which can be brought to balance through your creations. So it doesn’t matter what becomes of your creations. What matters is that it’s out there. What matters is that you create.
>
> — [Shreya Dalela](https://medium.com/@shreyadalela), [Why should you create at all?](https://medium.com/the-coffeelicious/why-should-you-create-at-all-2757e542dd32)

As you mature as a programmer, regardless of job title variations, one of the most significant changes is that you shift from building standalone functionalities to sophisticated systems. That is the most rewarding part of working as a programmer. The joy comes in two levels.

First, designing and building such a system involves an extended period intensive with generating ideas, experimenting, exploring options, struggling with decisions, and navigating through the mist. What’s best is that you can write lots of new code without the drag of legacy. The feeling of starting fresh is very refreshing and is the best way to heal fatigue or boredom.

Second, if the system you’re building happens to be one that other people can use to create their things, the fun gets doubled. It’s like creating a mini-world where you set rules and boundaries but aren’t really sure what people will do inside. Programming languages, frameworks, and highly extensible systems are examples of this category. What’s intriguing is that there are infinite possibilities. You focus on getting the fundamentals as right as possible and then observe what happens next.

People are creative beings, and engineers are in the best place to experience the joy of it. If your company is stagnant and you’re patching existing software day after day, month after month, the environment is poisonous, and it’s time for a change. If you find yourself buried in meetings, processes, and politics, it’s time to reflect on whether you still desire a programming career, and if so, get back to creating stuff and writing great code.

## Restless Exploration

> Anything that’s invented between when you’re fifteen and thirty-five is new and exciting and revolutionary and you can probably get a career in it. Anything invented after you’re thirty-five is against the natural order of things.
>
> — Douglas Adams, The Salmon of Doubt

A key to a sustainable passion for programming is never settling on things you already know. Keep exploring. Always learn new languages and tools. Always try using new technologies in new projects. It doesn’t matter how it happens — inside or outside a job.

[Choose Boring Technology](https://boringtechnology.club/) suggests that companies should prefer boring but predictable technology to avoid taking unnecessary risks. Also, many people believe rewriting complex software (especially a profitable one) is stupid and doomed to fail. I mostly agree with the ideas from a business perspective. However, these are great examples of situations where corporate and personal preferences don’t align. Safety, reliability, and predictability are great for a business, but they annihilate creativity and passion for individuals.

Software developers tend to build up a strange arrogance over time: "the new language is hype", "oh, yet another new framework", "Y is just X revived". As we age, we become more close-minded and less excited about learning new things. However, the danger is not about having an outdated skill set. It’s about losing the connections to the most active minds in the industry. Those minds are discontent with the status quo and challenge it not by talking but by creating tools to shape the future of programming toward their ideal. It’s OK if you don’t like the ideas, but it’s NOT OK if you lose track of what’s going on. A passion can’t last without constant new stimuli.

---

Programmers are rational people. The profession requires intelligence, analytical minds, and great precision. It’s also very demanding (mentally and physically) and can quickly burn you out. The solution is to lean more towards the emotional side of it. Unleash the desire for aesthetics, creativity, and curiosity, and let them generate the spiritual fulfillment that fuels your passion along the way.