There is a quote, which I particularly like:

“I think most programmers spend the first 5 years of their career mastering complexity and the rest of their lives learning simplicity.”
Buzz Andersen

According to this insight of a developer, most time of your career would you be spending on learning simplicity. Whether you feel that to be true or not, or applicable to your situation at all, there is a lesson to be learned.

Master the details

Consider creating a software solution to do certain things. You master the details, the complexity. Everything runs well. That is, for the moment. Now try to explain the working to another developer or pick up the software after a year. Most likely, the original and working solution does not seem to be that simple anymore. This is following the rule that writing code is easier than reading code.

Clearing the path ahead

That latest observation can serve as an anchor for future development. Once you realize that a working solution usually isn’t as simple as it probably could be, awareness starts to change. This consideration might change how you create future updates or new solutions. In this process you most likely will try to improve the work you did before. Simplifying a previous approach is one of these things.

Simplifying things is most likely a main challenge of your career. The challenge is not “complexity” if you are good at handling that. It is the simplification. Instead of simplification, think of related concepts, like simplicity for upgrades, enhancements, and reductions. You also might think of how you structure scripts, handle errors, and improve on design and accessibility for the user. All of these issues can be realized in various ways. Here is the specific question to ask yourself: How can this particular process be simplified?

Whatever it is, clearing the path ahead, to my understanding, is a process of simplification, not conquering the technical complexity only. Some benefits of simplifications are the following:

• More stable structure
• Easier to update and maintain (sustainability)
• Easier to enhance or configure
• Less support needed
• After the initial investment: cheaper to handle (result of previous points).

Develop the developer first

Simplifying is hard and requires both experience and conceptual thinking. It therefore isn’t a straightforward process. It grows over time. The developer always develops himself before he can improve on any project or approach. It is a two-step simplification, by first learning what you need, get an idea and resolution, then proving the idea in an update or new product. Over time, your solutions will become both more sophisticated and less complex at the same time. That is, where experience and real thought pay off.

What holds developers back from improving existing solutions? Frequently it is the paycheck. If a customer does not want to pay for improvements, they usually do not happen. The tricky question is here: If no customer pays you for improving, will you improve yourself nevertheless? And if so, how do you do that? Simple is beautiful. Simpler is usually more beautiful, more sustainable, and more future-proof. How to achieve that quality?