As developers and programmers of all stripes can attest, staying current in our industry is a moving target, and a fast moving one at that. Last year’s standards won’t cut it this year. The next project should always be better than the last. Didn’t you see that library has a new version? Haven’t you heard that tool is being deprecated?
Perhaps nothing embodies this momentum more than your average developer’s Twitter feed: a never-ending treadmill of 140 character reminders that you still haven’t read that latest article, or tried that new framework, or weighed in on that trending debate. Conferences offer another present reminder, where impressive speaker lineups and eye-opening talks seem geared toward encouraging early adoption of the latest and greatest.
Long ago I realized (as I’m sure many of my peers have) that the talent which allows us to make a living in our collective field is not our familiarity with any particular technology, but rather the ability to continually learn and adapt to new technologies and use them to achieve similar goals. Even recognizing that, the best of us can become fatigued at the constant merry-go-round of evolving tools and practices. Here are a few things I’ve learned along the way to help manage a long-term career with some sanity.
Careful with the Cutting Edge
It’s great to keep an eye on the latest news in our industry but it’s important to weigh the cost/benefit of cutting edge technologies. Tempting though they may be, it’s usually better to wait until new practices hit the mainstream before we fold them into our codebases and everyday work. I sometimes think of this like running in the middle of the herd instead of at the front of it. Maybe less exciting than the alternative, but there’s safety in numbers. You don’t want to be left high and dry trying to debug experimental software without a healthy list of Stack Overflow threads to help out.
Don’t Fall Prey to Imposter Syndrome
Trying to keep up in our fast-paced industry leads to a high prevalence of Impostor Syndrome among developers. Most of us who have been around the block a few times can relate. The best way I’ve found to combat this is to keep things simple:
- Avoid Unnecessary Abstraction: Most times there’s a framework or a library out there to make whatever task you’re trying to accomplish easier. But, be wary of always reaching for an off-the-shelf solution – especially when you’re hazy on what it’s doing under the hood. If it’s practical to roll your own solution, you’ll be in a better position to make changes and adapt to new problems along the way.
- Don’t Over-Engineer: It’s important to be forward-thinking with your solutions and plan for the future, but sometimes this can lead you down a path that’s more time consuming than beneficial. Bloating your codebase with features you might leverage in the future takes a cognitive toll on you, and anyone else who may need to work inside your codebase.
- New Doesn’t Mean Better: New technologies will always have that shiny luster we’ve all come to love (we’re technologists, after all), but it’s important to remain critical of new tools. There are a lot of programmers out there trying to leave their mark on the industry, but it doesn’t always mean they have something meaningful to contribute. I personally don’t bother reading up on anything until I’ve consistently seen it mentioned again and again by sources I trust.
My overall advice? Trust your gut. Over time you’ll start to get an intuitive sense for when a particular solution ‘fits’ a problem, and when it doesn’t. Second guessing yourself is healthy, but the third, fourth, and fifth time doubting your solution may be an indication you’re actually doubting your skills as a developer. Pro tip: don’t.
And last but not least…
Run Your Own Race
A career in our field is a marathon, not a sprint. Like any good marathon runner will tell you, you need to go at your own pace. It’s impossible to keep up with every development in our industry and if you try – you’ll burn yourself out. Take it a day at a time and enjoy the ride.