Becoming a Senior Citizen

When you've spent a certain amount of time working in development whether formally or informally you will eventually be faced with the transition of becoming a senior member of the team.

But what exactly does that mean? What are the qualities that define a lead or senior developer?

Battle Scars 

The most obvious answer to this is experience, but this isn't just about time on the clock, its important that you've experienced failure.

The most beneficial aspect of experience is the painful memory of when you made a mistake in production or introduced a bad defect.

The desire to not repeat this experience will provide an in-built mechanism to detect when the same or similar mistakes are being made by yourself or others. 

The truly enlightened, and therefore lazy developer, will devise a mechanism to automate this oversight.  

Nobody want to screw up but a developer who regales you with a long story of success has either never stretched themselves or is oblivious to the errors or blunders they've introduced and therefore doomed to not improve.

Teaching All The Things

As a senior developer you aren't a one many army. Good developers will often have a natural desire to want to take on more and more work because they can see what should be done and how.

But an important part of a senior role is education, the goal should be for all members of the team to get the support and advice they need to also grow into becoming an experienced, productive and rounded developer.

This balance is not always easy, things still need to get done. But by recognising an opportunity for learning you'll help others progress, an important aspect to this is the elimination of a blame culture.

If mistakes are an important learning tool then when they inevitably happen they should be viewed in this light, this is made harder if a fear exists around taking ownership of a problem.

A senior developer should also be aware that this education is a two way street, good ideas can come from anyone in the team regardless of their time served. 

That'll Probably Do 

To be pragmatic is to be reasonable about the reality your facing and not dealing totally in the theoretical.

Software can very rarely be considered finished, instead it reaches certain stakes in the ground that represent the next release.

The perfectionism that good developers often hold can lead to a stagnation that causes a slow down in us reaching these points.

While quality should never be compromised to satisfy a deadline, an important skill for a senior developer is to recognise when something has reached its first iteration, it may not be perfect but it does what we need and has been constructed in such a way as to allow future iterations. 

Ultimately we do this to provide something to our users and we have to be pragmatic enough to realise when we've reached a stage where we can do this even if perfection is still a way in the distance.

I don't think senior developers are made just because of a change in their job title, they naturally evolve as they experience more and more of the development life cycle.

They are a product of their mistakes, the knowledge they gained in how things should and shouldn't be done and of the education handed down to them from the other team members they've worked with.