Programming jobs and the age effect

Tech has an age problem. More than 93% of professional developers in 2018 were younger than 45. That leaves just 7% of development roles to developers aged 45 or up.

Indeed, if the statistics are anything to go by, programming is a field severely affected by age. It’s an industry that seems to view 28 as ‘middle aged’, and by the time you reach 35, you’re (supposedly) getting old.

But how does age really impact programming jobs? Here, we’ve explored the pros and cons of having younger and older developers. Does age matter as much as the tech world seems to think?

Younger developers: the pros

Young, starry-eyed developers seem to be the valued choice in programming jobs. But why?

  • Their knowledge is more likely to be recent and relevant

The tech industry is incredibly fast-paced. Technology and coding languages are always changing. A younger developer has been studying for their job more recently. So, they’re more likely to have up-to-date and useful technical abilities.

  • They can inspire new ideas with fresh insight

The tech industry is also obsessed with innovation. Younger developers provide fresh eyes to common problems. In theory, this breeds newer ideas and more innovative solutions.

  • They’re cheaper

This is perhaps the most obvious reason for the age effect in programming jobs. The less experience you have, the lower your starting salary. (Generally speaking.) So, young developers are cheaper to hire.

Young and inexperienced: the cons

Younger programmers can bring a lot to the development table. But what they provide in terms of energy and innovation, they may also pay for with a lack of experience.

  • They’re inexperienced

Younger developers may need time to find the most efficient workflow for them. They might also not yet know the best way to solve a common problem. Inexperience, then, makes them more likely to waste time, and more prone to mistakes.

  • They can lose sight of longevity

Younger developers are encouraged to focus on innovation and new ideas. They’re encouraged to ‘move fast and break things.’ Unfortunately, this can lead to rushed code that doesn’t take longevity into account, and needs to be fixed before you can build on it.

  • They can get overwhelmed or discouraged

Development jobs are hard. A programmer’s work is never done, and while an older developer has had a chance to embrace that, younger developers might struggle at first. When confronted with large amounts of code, a complex problem or impostor syndrome, younger developers can burnout or become discouraged.

Older developers: the pros

So, what’s it like on the flipside of the age coin for programming jobs? Older developers often face ageism in development roles. But what can they bring to the development table, when given the chance?

  • They have valuable insight from experience

Older developers have dealt with common coding problems before. They have pushed through complex problem solving, bug finding and code reworking. They know when a proposed solution won’t work. It might have been in a different language, but problem-solving experience is transferrable.

  • Better equipped to manage/handle legacy code

Many software companies have legacy code to deal with. This is old code that needs updating, rewriting and untangling. Older developers are more likely to have used the old coding language in the past. So, they’re often better suited to help you deal with your old systems.

  • They’re well suited to senior roles

They know what’s reasonable to expect, they’ve been there. They’re likely to have a more responsible attitude, because they’ve seen the consequences of careless errors. They also know how they work most efficiently. So, a task that might take a young developer a week might only take an older developer a day. 

Old and hardened: the cons

If they bring all that to the table, then why isn’t there more room for older developers? Well, here are some potential reasons for the age effect in programming jobs.

  • Experience isn’t as transferrable in a software development role

Due to the fast-paced nature of the tech industry, not all experience can transfer to new programming jobs. It depends on the type of experience. For example, having experience in a dead programming language isn’t helpful, but the experience in problem-solving is.

  • Risk of inflexibility

When it comes to the age effect in programming jobs, a major issue is the ‘old dogs, new tricks’ fallacy. This is the idea that you can’t teach an old developer new code or skills. There’s a concern that older developers will be stuck in their ways, meaning less innovation and less flexibility.

  • They often need higher salaries

Older developers have climbed the ladder. With their experience comes a slightly higher price tag for their expertise.

Drive diversity: it’s best with both in programming jobs

In the end, regardless of age, developers each have unique insight, knowledge and personality to bring to the development table. Hiring just one leaves gaps in knowledge, ability and insight.

Younger developers offer new insights and languages. Older developers offer expertise, and can mentor younger developers and help them forge their career path. And that’s why there is a distinct benefit to age diversity in the dev office. Age shouldn’t matter – it’s about passion, the drive to learn, and an openness to new ideas.  

So, let’s make the age effect in programming jobs about inclusiveness and diversity, not about bias and discrimination. Give age and youth alike a seat at the development table.

Useful links

5 tips to help new software developers find their footing

Developer impostor syndrome: why you feel like a fake

Dead programming languages (and those on their deathbed)