Older Is Wiser: Study Shows Software Developers’ Skills Improve Over Time
The prevalence of discrimination toward extreme youth in the software industry is probably a historical artifact of the fact that it's a new industry, so for the most part young people were the ones who "got it."That being said, I think it cuts both ways. Both younger and older developers have advantages.Older developers tend to see pitfalls and avoid them better. They tend to have a more diverse skill set, better organizational skills, and more knowledge of related domains outside programming (such as marketing, business, finance, etc.). Older developers are also less vulnerable to faddish thinking, choosing tools that they can ship with over the latest faddish language or technique. (And recognizing today's fads as yesterday's fads repackaged, which they often are.) Finally, older developers sometimes remember things that didn't work long ago but that might work today. Younger folks might not have a clue that certain things don't have to be the way they are, while an older person might be able to explain why a certain decision was made and then help them question whether it's still necessary today. A lot of innovation can be realized by searching through the discarded piles of yesteryear's ideas and asking, for each one, "are the reasons this was discarded still valid?"Young developers have the advantage of fresh eyes. They don't carry the accumulated baggage of prior environments and old ways of doing things. They can more easily dump legacy cruft, embrace genuinely novel and interesting ways of doing things, etc. They also sometimes have more energy, having simpler lives and lacking things like kids and mortgages and personal accountants. I think it's easier for a young developer to focus laser-like on one thing for a long time.I think the ideal team has both, and listens to both.It's also possible for anyone, regardless of age, to take on either of these sets of characteristics. It's possible for younger programmers to take the time to scratch the surface of fads, or listen to the older ones and learn from them. It's also possible for older programmers to intentionally "forget what they have learned" and open themselves to the possibility that such-and-such isn't needed anymore, etc.Edit: I also think it's important for teams to avoid the dark side of both. For older developers, it's the curmudgeon, or the developer so set in their ways they are not open to any new idea. For younger developers it's the cowboy who thinks they know more than they really know and will waste a lot of time reinventing wheels, chasing things already known not to work for provable reasons, etc.