I have spent many years studying (and implementing) everything related to clean code practices and “refactorings”, which is why I have written many articles, as well as “The Practical Book of the Agile Programmer”, and delivered several training sessions.
I have discovered that when a programmer has spent several years doing something “their way,” with their vices and virtues, it is very difficult to change their way of working. This is completely human: we cling to what is familiar (even if we sense there are much better ways out there). You will realize this if you do all your projects in more or less the same way.
I do not know if it is precisely because I crossed the threshold of forty, but over time you realize that life is enjoyed more (your home, your family, your friends) by avoiding complexity and perhaps creating a productive and creative routine in everyday life.
In other words, for some mysterious reason, we often fall into the mistake of believing that the more complicated something is, the better it is; the more, the better. We do not stop to think about it or imagine the possibility that whatever it is, it can be done in a simpler way with the same result.
I remember with affection an old coworker from a previous working stage; he was very technically good, what he did worked, and he developed it quickly, but the problem was that only he understood it. Anyone who had to take on some of his projects or libraries had a serious problem.
I have also, to my regret, found certain attitudes in professionals who deliberately make things excessively complex (as if that somehow made their value greater), and even clients who, upon perceiving the complexity of a product, strangely associate it with greater value.
My opinion is that rather than adding complexity, we should remove it and look for what is simple. And even better if it is extremely simple: in your work, in the way you approach projects, and also in making the rest of life simpler—family relationships, our home, hobbies, etc.
Simple does not mean easy; quite the opposite. Looking for simplicity is usually something complex, however strange that may seem, at least at first.
In recent years I have read a lot about minimalism, downshifting, and similar concepts. For that, I recommend a title I liked especially: “The Art of Living with Simplicity”, by a Japanese Zen monk named Shunmyo Masuno.
And what does that philosophy of living simply have to do with software development?
Everything, because in the end, we pour our way of thinking and acting into our work. The scattered mind of a poorly disciplined person, who wanders around, distracted, whose work desk is a warehouse of disordered memories and whose home shows the same lack of order (and cleanliness), will inevitably permeate their creative work with the same way of life.
Yes, Charles Bukowski, to give an example, was a great writer, but also a bitter alcoholic and probably a pig of a person; but let us leave geniuses as the exception that proves the rule.
From a few years ago until now, I have been passionate about simplicity and the simple, and over time I have discovered that in software development this brings many more advantages than it might seem at first.
Making a software project simple is not trivial; in fact, I think that, contrary to what it seems, it is quite complicated and requires a lot of experience.
But it also requires seeking simplicity by dedicating time and part of the development iterations to it.
“This already works,” I often tell myself, but “is there a way to simplify it even more?”
In the products I lead for the company that is my main client, I always organize “sprints” to improve this and that before moving on to more functionality, and as a consequence, the subsequent speed is greater (how hard it is to convey this idea to team managers…).
It is not a whim; it is more of a necessity, especially in products and projects that you know will accompany you for a long time or that at some point you have to delegate to others. The simpler it is, the cheaper and easier its evolution will be and the more easily other colleagues will take over the work. Do them a favor and leave things clean and tidy; they will thank you.
If you need to begin delegating in order to grow professionally and take on other responsibilities, things will go better if what you delegate can be easily digested by others. In other words, that search for simplicity as much as possible gives you more freedom.
I always look for simple solutions, as simple as possible to put into practice, without sacrificing, of course, good practices and good design, to the point that if I see a piece of code with a certain complexity, I do not rest until I “clean it up” and find a way to simplify it—something that almost never takes more than a minute.
Curiously, in doing that work, you discover that this way of approaching programming generates more robust designs, capable of handling future changes much better.
Think about it: why complicate our lives when we can live in a simpler and equally rewarding way, or even more so? Why implement something in a convoluted way when we can do it with enviable simplicity?
From time to time, I like to do the following exercise: I browse a bit through GitHub hunting for projects that catch my attention. I enter them and, without knowing exactly what they do or how, I look for obvious points of improvement (to make them simpler), quickly identifying the “bad smells” and trying to imagine a way to do it a little better, refactoring this or that, changing something else so it is cleaner and more readable.
Sometimes I come across real gems in this respect: admirable projects by developers with enviable and highly refined code. Strange as it may seem, you may ask yourself… what would this person’s desk and house be like? Would there be coherence between this magnificent work and their way of life? I bet there would.
Add simplicity to your work, your organization and methodologies, your code, the way you express yourself and communicate your ideas and presentations, the content of your emails, and you will multiply results of every kind.
Only the simple survives; artificially complex things usually end up being abandoned.
“As you do something, so you do everything.”
PS: This is a complete chapter of “El Arte del Emprendedor Digital”.
PS2: Also published on Medium.