February 20, 2019 • 11 min read
Experience, they say, is the best teacher, and the more experience you’ve had, the better you would be at handling a certain task. This, however, begs the question: Just how do you measure it? Well, as a software engineer at least, experience is not determined by the number of years you’ve been one. In fact, let’s ditch that misconception forever: just because you've been a developer for 15 years does not necessarily mean you're a Senior developer.
Let me illustrate why I say this without doubt: If within a 10-year period, developers just sit at their desk, working on the same old technologies in a static company, what they will be after 10 years would be older junior developers, and not exactly developers with the right experience.
What we need to understand is that the market is not static. Technologies evolve, and so do the ways we develop software. In that environment, it’s not possible to simply learn a single thing and then use it for the rest of one’s career. The next 5, 10 or 15 years a software engineer spends working with that limited knowledge would take him or her nowhere near a senior position.
Whether developers like it or not, or whether they are even aware of it or not, there is always a kind of competition among them. The moment a developer stops improving existing skills and learning new ones, his or her value will depreciate quickly, left behind by those who expand their range. Such is the industry we work in, and the sooner developers acknowledge the need to constantly hone their abilities, the sooner they can work their way up to higher levels.
Ideally, you cannot ask for more money if you do not bring more value to a company or a customer. In reality, however, some companies may pay more, either because they don't know the value of their software engineers, or because they have an overabundance of resources; not necessarily because these developers are better. The market also evolves and this could lead to a particular language becoming rare or sought-after. When this happens, developers who have mastered this skill or language stand to earn more, but that doesn’t mean they have learned something new that will be valuable to their next employer.
The danger is in software developers falling into a sense of complacency where they think that their pay scale is a measure of their technical level, and hence, they no longer seek to acquire additional knowledge. To summarize: Just because one is well-paid does not mean that he or she is actually good and worth that income.
“Do not confuse motion and progress”
~ Alfred A. Montapert
Following the law of compensation written by Ralph Waldo Emerson a long time ago, your value as a developer depends on three aspects:
Of the three, the first aspect is the one that is completely beyond the control of the professional. It is the market that decides if a certain job or industry has a higher demand or thrives more than another. The third factor is dependent on the other two. If there is a need for one’s abilities, and a person is good at what he or she does, then there is an assurance of a decent job at all times.
Thus, it remains that the only thing you can directly act on is your own skills and capabilities. No one should be content with just doing the same things over and over again. Just because a developer has been slinging code for years doesn’t automatically warrant ‘seniority’. There should be a plan and effort for continuous improvement. To improve, it is fundamental to understand what your "value" is in the industry you belong to, and then strive to increase it. Even if you aim poorly, it’s still better than doing nothing and going nowhere.
As I recently explained in the clean coding presentation, a software company does not and should not calculate the value of a developer by just counting the number of lines of code written and looking at the resulting complexity. Complexity, in fact, is expensive for a company. Instead, developers who write simple, readable code that is easily maintainable, provide more value to the team.
One might argue that the very basic requirement should be a working software, and that is true to some extent. But these days, there is the need to offer more value to the organization. We developers should not be content with just producing code because that is only the start.
Rising up the software engineering career path also requires developing other capabilities. Some people have the tendency to focus on only one aspect of their skillset. For instance, the most logical for a developer would be upgrading programming skills and technical knowledge. But the truth is, you can rarely excel at a software engineering job without building a full range of competencies—this includes soft skills such as communication and social skills, as well as some periphery skills including business and marketing abilities.
Knowing where you stand in your knowledge as a developer is the first step in planning for your skills improvement. Below, I give a description of the three levels of progress for a software developer.
Starting their journey in the development world, junior developers first have to deal with the logic behind programmation like loops, variables, conditional statements, and memory management.
Then they learn the syntax of their preferred language, learn some code formatting, and work on how to implement basic algorithms like string and array manipulation, sorting, and searching. If they branch into web development, they also need to understand how the network works, study about protocols like HTTP, and learn what an API and a hosting platform are, among others.
Further along, they have to fully understand the differences between compiled and interpreted code; between procedural, functional, and object-oriented programming; between synchronous and asynchronous execution; and learn about basic security principles. Knowledge of all these will help them choose the language they prefer to work with the most.
The points below define the tasks of and expectations from junior developers:
As developers progress in their careers, they will begin learning from their mistakes. They will start getting an appreciation of the bigger picture, and understand that programming is not about writing small pieces of isolated code. Rather, it's about interactions, patterns, and layers of abstraction. Mid-level developers will start to learn these, and hence, are defined by the following characteristics:
A senior developer should already have the ability to fully deliver a solution. They have a better appreciation of the work in its entirety. They can ensure the quality of the entire code base rather than just their own code. They have the ability to move their team in the same direction towards a defined goal. While not all senior developers have the skills or insight to clearly define that goal, most of them have a good idea of the general objectives that they are working towards.
Senior developers are designated as such because of the following traits and responsibilities:
Obviously, as stated in the article of Matt Briggs, the given outline of essential features for each level is an over-simplification of the respective roles of developers, whatever category they belong to. The reality is that, a software engineer’s career can take many different roads. Some will prefer becoming an architect, others like the business side, and a few will move towards the position of CTO. Some developers may also eventually choose to teach and/or write.
Still, I think it’s important to provide a seniority roadmap and define the expectations that companies would have in hiring and job promotion decisions. This post will also help software engineers determine the potential responsibilities that may be given to them if they were to join a business organization, bringing with them their current skills. They should now have an idea of how much they still need to learn (or experience, in the real sense of the word), to be able to make it up the seniority ladder.
I hope that if you, dear reader, are sitting at your desk and have been using the same old technologies during the last 5 or 10 years, this will give you a wake-up call. It’s a hard necessity to grow, but once you do, you will appreciate the fruits of your efforts.
Looking for new careers opportunities as a software developer? Let's talk. Check open jobs and apply online.
Eric has been working as a software engineer for more than 20 years. As a senior architect for Arcanys, he works closely with the developers to instill the habit of learning, clean coding, re-usability and testing with the goal of increasing the overall quality of the products delivered by the teams.