Some time ago I wrote an article titled De qué Hablo cuando Hablo de Programar, which, by the way, is one of the most visited pages on my site in recent months. On the other hand, not long ago I read this entry on Medium with a title that I would call unsettling: Software development is a loser’s game, although I’m willing to bet the author only wants to attract readers with a title like that.
In any case, that article pushed me to reflect once again on what distinguishes a good professional from one who is not so good, in my opinion, of course.
So, if you consider yourself an amateur or a junior, I encourage you to keep reading.
Over the last few years we have seen an avalanche of new training opportunities that attracts many people to learn topics related to software development, probably because there is a lot of work and it is a clearly growing sector.
MOOCs, bootcamps, different training pathways (like vocational education in my country or higher-level modules), aside from more formal university education. I completed a five-year university degree a long time ago, with the grand title of Higher Engineer in Computer Science, only to conclude years later that I was at least two years overqualified and that the most important thing in my work and professional development I learned on my own and by working for companies. That is a somewhat sad truth to accept, although this is a different debate.
But we are in 2021; the pandemic has accelerated the digitalization (finally) of companies, processes, and everything that can be digitized, so thousands of people, from one year to the next, start doing programming work, front-end, back-end, etc., perhaps with the trendiest technologies of the moment (or those with the most employability) and which I’m sure will be forgotten in a few years.
And all of this, in my opinion, is very good, because it shows that our sector (everything related to IT) grows much more than others. But what can I object to? Precisely me, who has books and audiobooks published, some of which can be very useful to newcomers.
However, not everything is so good.
This avalanche of new professionals is being used by companies to reduce labor costs, believing that the work they can do (software products) will be the same as that of other professionals who have been active for ten or more years. This dynamic is surely helped by clients who do not understand the number of hours involved in any development work.
I do not like the terms “junior programmer” or “senior programmer,” because who can certify that someone is a real “senior”? Unfortunately, only years of work do not validate you as a better professional, because you may have been doing the same thing repeatedly and gaining very little experience. In fact, what I usually observe is that people, with honorable exceptions, get accustomed to doing things the same way and never get out of that habit.
In this way, it does not seem absurd to think that in our sector there are only around 20% real professionals. This is not a statistic I have calculated; it is just my intuition after everything I have seen in my experiences over the last few years. Or, to put it another way, the percentage of truly professional software developers is far lower than the number of juniors and amateurs.
But what does it mean to be professional in reality?
This post is aimed at everyone who has come to software development in one way or another, whether they like this activity or not, or whether they just see it as something to work on to pay the bills at the end of the month. I insist: I think all of this is fantastic, and what motivates me to write this article is precisely to shed some light and clarify that programming is not just programming, because what I want to highlight is what I consider differentiates a professional software developer from an amateur. And there is nothing wrong with being an amateur; on the contrary, if you really love everything related to software, then you should know how to create projects with the same quality as the professional you want to become.
The career and experience of a professional software developer are not acquired in one year; at most, in that time you gain theoretical knowledge, some practice, and little more. This is difficult to apply in the real environment of a company in real products and projects.
Just to put a finger on the wound: you are an amateur programmer if…
- You do not like standards (that is, in your department you go your own way and do things the way you want without following established guidelines or rules, if there are any).
- You believe writing software is creating a new feature and thinking that what you did “the first time” is untouchable and never has to be modified.
- You ignore the incremental (and artisanal) nature of software development.
- You find it difficult to go back and improve or simplify something you already did (something implicit in the previous point).
- You do not care whether your code is readable to others because you ignore all the practices related to clean code, refactoring, and patterns (anti-patterns and code smells, since we are at it).
- You ignore methodology (if it exists in your company), so you do not know how to break work down into tasks and iterations, because you do not even recognize terms like Scrum, Kanban, etc. In other words, you do not know how to work in an orderly way under a plan (or nobody has shown you how).
- You copy and paste too much from Stack Overflow without trying to understand how those code snippets work.
- You do not do testing, not even unit tests, which is the minimum, perhaps because you have been told that it slows development down, when it is exactly the opposite. The result? More monolithic applications. (Mono what?)
- You do not understand that sometimes poor system performance is due to bad design.
- You cannot distinguish between a monolithic design and an extensible, testable, and maintainable one, because you do not understand the advantages of the latter.
- Speaking of design, you have never heard of the concept of emergent design as new functionality is added.
- Writing documentation is not your thing, but filling the code with unnecessary comments is fine because it is hard to understand.
- You do not use object orientation well, using classes as mere sinks for functions.
- The idea of programming while taking principles like S.O.L.I.D. and others into account feels too abstract to you.
- You do not care about cleaning up the project’s assets organization, thinking it wastes time.
- You also ignore that creating a continuous integration pipeline necessarily affects code design.
- You do not have a team culture and you fail in soft skills.
- You find it hard to learn new things, thinking what you already know is enough.
And I stop because I am getting a bit bored :-) I am not saying you have to be an expert in all those areas, but you should know a large part of them to some extent.
To summarize: you are not a programmer because you know how to do some things with language X, even if everyone labels themselves as they want.
Only for some of the points above is there such an extensive bibliography that it has to be digested and put into practice for a very long time.
What I want to say is that programming, at least writing professional code in a professional environment, means, for me, knowing all the points above (and many others) and applying them, of course. Something that is difficult to learn in just a couple of years of training.
Finally, another very amateur belief: the idea that all of the above requires more effort, slows down work, and makes producing software more expensive…
I’ll leave it there.
Without wanting to discourage anyone, but quite the opposite, I encourage you to start documenting yourself and continue learning if you have been left blank by some of the points above. In fact, a professional developer’s career is continuous learning across all of the areas mentioned above.