We've all seen it, you're in an interview for a job and they'll certainly ask you about your experience in software development. In fact, you probably saw the following line in almost every job description for a software development position before you started looking
You need at least X+ years of professional experience working as a X-developer for this position.
They may even have been asked how many years of experience they have with specific technologies. I've even heard of huge Excel spreadsheets where you have to fill in the years you've worked with each technology.
So I have always wondered:
- What exactly is this mysterious experience?
- Can you count it?
- Do you have a reference for it?
- Is it just the simple years you've worked so far?
- Is it really that simple?
Let's dig into it a bit.
Most companies or recruiters I've seen so far define or rate experience by the number of years. And your position is defined by this. A hard example would be that 5 years of experience as a software developer prepares you to become a senior developer, with more than 10 years you can become a manager.
Well, So why don't we just sit there, count the years and gain more and more experience? With this analogy, you'll be the best developer in the last year before retirement, and all you'll have to do is sit and wait to get better and better.
Let me explain why I don't think that is true and why defining experience isn't that simple.
For a better understanding of what experience really is, it is important to divide it into "Technical Experience" and "Everything else than technical Experience"
As a software developer, you will always have to learn new things. The tools we work with change so quickly that it is important to keep a sharp eye on current trends and new methods or technologies. However, experience in working with a technology from 5 or even 3 years ago is often not as valuable as the experience you gain when working with the current technologies.
Imagine you have worked as a software developer for 10 years and then traveled the world for 5 years without reading or touching any code. Does your 10 years of technical experience have the same value as someone who has worked in the last 5 years? Probably not.
Understanding the context
Suppose you as a developer have been working for over 5 years with a huge code base that already exists before you started working on it. You did your best to add new things, refactor some things, or understand the legacy code. Another works in an agency or as a freelancer and has contributed or created several different projects of varying scope. Although your were in the same field or using the same technology, you have both gained quite different experiences.
One type of experience is how to handle and maintain a large project and how to work with legacy code, the other is more experience in setting up projects and the ability to recognize the balance between quality and speed..
It depends on the motivation
This is probably the most overlooked point of experience. You can either be the developer who is always curious and always open to try new things and ready to step out of the comfort zone, or you can be a one-trick pony developer who knows one thing quite well, and you always do it because that's what you know.
But at the end of the day you will have the same years of experience, but the actual knowledge and experience you have acquired is completely different.
Everything but technical experience
We all know it, the work as a software developer usually includes working with other people or mostly working with within a team. So you will soon realize that a large part of the experience is in how to deal with teamwork, planning, communication and mentoring. You cannot learn these things by reading a book or an article. These things are part of the job. This is probably the case when experience is the most valuable resource. But again, is time the best measure here?
Let's imagine that someone works in a team with rather fewer people and the fluctuation is quite low, which means that everyone works together for years. Is this experience they all have easily transferable to other teams? Or is this experience really linked to the specific company or team? Wouldn't someone who has worked with several different teams or companies of different sizes at the same time be more experienced in this respect?
Don't get me wrong, I'm not saying that everyone should change the company or the team every 3 months, I would just argue that it's easy to get into a kind of comfort zone where you always work with the same people and get used to the workflow without getting new input. If new input and leaving the comfort zone is indeed the best way to gain experience.
Especially when it comes to non-technical things, since you usually can't read or learn them with the resources available, the only thing that brings new insights is to talk or work with new people. So perhaps another measurement other than time would be more appropriate for defining experience in this sense.
Years can matter
Let me get this straight: I'm not saying the years don't matter, they definitely do. I'm pretty sure I'm a better developer today than I was 5 years ago. But I'm also pretty sure there's someone out there somewhere who has fewer years in the "field" and is a far better developer than I am, because that's just a reference point for yourself, but not as easy as comparing with others.
Let's take an example, if you work as a simple door-to-door salesman selling vacuum cleaners, there is a simple measure of how well you work, the number of items you sell, for them it is so simple. Therefore, from any point from which you work in this area, you can be the best directly by simply selling more items.
But I think when it comes to judging the experience or value of developers, it's not that easy, and since software development is such a common task, it's almost impossible to find this way. That's why the most used one at the moment is just the simple time of work experience. But since it is obviously not so easy to define it, why do we use such a simple measurement? Can't we make the definition a bit more detailed than just a simple number?
So I think we somehow need a better way to understand the real value of experience as a software developer, and especially when it comes to hiring, there must be a way to identify that experience, rather than just counting down the number of years.
Sometimes I have the feeling that we lose a lot of potential in young talented developers just because we don't give them a chance or don't appreciate them enough because of "too little experience".