What really makes a senior developer? The theory of the 5 hats.

During the last few years doing technical assessments I have realized that the concept of seniority in the software development varies widely from some people to others. Many times I have wondered about what a senior software developer really is:

• Is it someone who has worked too many years in a specific field? 
• Is it someone who has had different job positions?
• Is it someone who has had different job positions in different companies?
• Is it someone mature, with good ability to judge?

Yes and no. Of course, being at different companies or jobs would help you to improve and gain experience, learning from different people, etc. but you still could not be considered as a senior software developer, in my opinion. We normally say that the seniority is related to experience, I totally agree. And we usually say that the experience is related to age, I don't agree. The experience normally comes at an age, but is not strictly related to age, not with the present millennial culture. So, what does the experience really mean? When we should consider a software engineer as a senior role?.

Let me use my theory of the 5 hats to explain it. In my opinion, a senior software developer is a someone that should have worn and used at least the following five hats:

1. Construction hat: Build a new product or feature.

The skills gained when building new software are really important. Building software brings you creativity, customer-oriented approach and requirements gathering techniques. However, although it's a very important hat, every software developer knows how to build a new product with better or less quality, so it is not the only hat to take into account to become a ninja sofware engineer.

 2. Soldier hat: refactor like a beast.

In order to be considered as a senior software developer you should have got crazy several times (and of course, survive after that) refactoring a legacy application with no software layers, no code conventions, no documentation and even nobody in the team knowing why the things were developed in that way. Yes, you should wear this hat and fight against all the problems. Don't be panic, this is, in my opinion, the stage where you learn the most: why dependency injection is so important, why other software patterns are useful, why separation of responsibilities is crucial, etc. At this stage you will understand why it's very important to continuous refactor your code and manage properly the technical debt of your product.

3. Cheff hat: Test what you have built.

Testing is really important, but not because everyone says so: it is very important when you realize why it is needed. I am not saying anything new, although I have seen several managers and companies not prioritizing automatic testing as they don't consider it to add value to the customers. If you don't test, your customers will, and testing makes you write better code.

4. Fireman hat: Bugfixing.

Most developers just want to write new features, they don’t want to work with maintenance and bugfixing. I think they are missing out one funny part of the software that will be very beneficial for them. Why? The reason is simple: each bug will teach you something. Either it is a simple coding mistake (like a wrong nested if statement), a performance issue, some missing requirements, etc. For sure, after dealing with several bugs you will really understand the good software practices and write better and non error-prone code.

5. Elderly hat: Experience is the teacher of all things.

Common sense is the less common of the senses, especially in software engineering. Sometimes, we should assume technical debt, sometimes we should write bad quality code. The common sense gives you the idea on how we should handle the technical debt and when we should do spaguetti code and quality code. Don't be wrong, spaguetti code is not bad, sometimes we need to write one-off spaguetti code. The bad thing is to do spaguetti code where you shouldn't. The common sense and intuition is the key.

So, consider wearing these five hats in your next software development career, as they will make you a great senior software engineer.