I came across a post on a programming forum where a junior dev, one month into their first job, was desperately asking the community for help.
The problem: the senior developer responsible for reviewing their JavaScript code didn't know about let, const, or string interpolation. Eight years of experience, and didn't know about fetch().
Shocking. Horrifying. Destabilizing! Surely the community would back them up in their horror, right? Such basics!
That's not what happened. The community raised some genuinely interesting arguments. Three of them stuck with me:
1) It's hard to keep up with everything, but try
ECMAScript 6 (ES6), the sixth standardized version of JavaScript, was released in 2015 and introduced a lot of new things, including let, const, and fetch(). Given that companies tend to be slow to adopt new releases, and that this senior developer was already deep in their career, it's entirely possible, and even normal, that they'd had little or no exposure to those additions.
Relevant comment:
"In 10 years, you'll be in that senior's position, with a new grad explaining a ton of new things to you: things you didn't have time to learn because your workplace piles on responsibilities and gives you little to no time for learning. By then you'll probably have a family, so you won't have time to study at home either. Keep that in mind: people aren't stupid or inferior to you. You just learned THIS. Next year there'll be more. And the year after, and the year after. It never ends!"
Lessons:
- Continuous learning and staying current are essential. Focusing on technologies you actually use at work, try to at least get familiar with the documentation so you can apply that knowledge in your code. If the technology you use is being updated (say, the company is moving from React 16 to React 17 or 18), even if you don't have time to practice, read the changelog and apply it.
- Ideally, your company will give you dedicated daily or weekly time for professional growth, plus access to learning platforms. This isn't a perk they're doing you a favor with: it's actually a very cheap way to keep a qualified, up-to-date workforce.
- If the company doesn't offer that time, use your free time to learn, improve... and find a company that does. If you're stuck working with outdated technology, reemployment gets harder in the event of a layoff, a company closure, or a search for better opportunities. Don't get trapped.
2) The difference between a junior and a senior developer isn't the code. It's everything around it.
More experience doesn't mean you have every syntactic detail of a programming language memorized. It means you can make long-term decisions grounded in your understanding of code quality, test coverage, business strategy, and how to apply technology to achieve company goals.
Relevant comment:
"I'm a senior, and I actually like using juniors to get me up to speed on new trends and concepts I can focus on during the very limited time I have for learning. I don't have time to learn everything and stay current on every technology we use, because the way I add value is by understanding how everything fits together and driving the decisions. We don't have developers with identical skill sets, we have complementary ones. We're always learning from each other."
Lessons:
- Senior developers, like any other professionals, have different areas of expertise and different perspectives. Some are stronger on structural concerns; others on innovation and creativity. Some factor in marketing; others focus purely on software patterns and best practices. Absorb what you can and take it with you on your professional journey.
- Even if every company runs differently, collaboration and communication tend to be essential skills regardless of area, role, or seniority level. A junior developer also has knowledge worth sharing, whether it's something new their colleagues haven't encountered yet, or prior experience from another industry that turns out to be relevant. Don't be afraid to ask questions or to teach, because one day you'll be the one teaching a new generation.
3) What matters to a company isn't the code (a continuation of point 2)
There's a persistent narrative that the best developer is the one who types the fastest, has the most trivia memorized, and is always the most up-to-date. For a company, those aren't the priorities. What matters most is how you deliver value to the company and to its customers.
Relevant comment:
"A solid understanding of the company's domain, how it operates, the customers it serves, and how to communicate with others: those are probably why that developer is a senior, and those are the skills that will set you apart down the line. And what if they don't even work with JavaScript? A company uses way more than one technology. They can read your code and judge its quality without knowing the syntax. On top of that, I've met plenty of developers who focus too much on theory and forget about results, or the other way around."
Lessons:
- When a product ships, the client doesn't care whether you used
letorvar,fetch()or Axios or jQuery. The user doesn't care about that. They care whether the solution meets their needs and their deadlines. The technical solution can be delivered in many ways and doesn't necessarily need to use the latest technology. Understanding the company's vision and your users' needs matters here. - Balancing quality standards, including clean, testable, maintainable code, against deadlines and management demands is a delicate task. But learning and practicing that balance is what tends to drive career growth.
Conclusions
Seniority levels in software development come with different expectations around knowledge and responsibility. Code is the foundation, yes, but the tendency is to move away from it as you climb the mountain.
The difference between a junior and a senior developer isn't the code. It's everything that surrounds it.
I recommend this excellent read from Felipe Marciano on career expectations (in Portuguese): https://www.fx.dev.br/frontend-junior-pleno-senior/