Focus On the Language, Not the Framework

One of the more disconcerting things I hear developers say is "I'm a React developer" or "I'm a Meteor developer." This is something I used to say and, as my own skillset has evolved, I've realized the danger in pigeonholing yourself that way.

Now, you may think "Hey, wait a minute! I'm an ___ developer!"

Don't be angry.

The reason I say this isn't to shame or degrade but to share a bit of grey beard wisdom. When you identify as an X tool or X framework developer, you're putting unnecessary limitations on your thinking.

If we take the example of React or Meteor, though it's true that you develop things using React and Meteor, they're just tools built on top of something else: JavaScript.

Both React and Meteor rely on functions. Both rely on variables. Both can take advantage of the Array.map() method. Though completely independent, both are built with JavaScript.

As a developer working with these tools, you're working with JavaScript, too. You may use these specific JavaScript tools, but the raw element, the thing you're "digging out of the ground" is JavaScript.

Why is this important? Isn't this what 39 year old developers fight over when they're waiting for their coffee?

Probably.

But it matters because how you choose to identify the work you do influences how you think about it. I say this from experience. When I first started with JavaScript, I did so by using jQuery. And that was the only way I knew how to use it.

Because I started with jQuery not knowing any better (it was the "it" framework at the time), I identified as a jQuery developer. This meant that if someone said "can you add some JavaScript to this," I would have to say "yes, with jQuery."

That's problematic for obvious reasons. Because I started by learning the framework, I missed out on opportunities to learn the underlying language. As far as I was concerned then, jQuery was JavaScript.

As my skillset evolved, I started to understand the divide between a framework and a programming language. Gradually, I started to learn that by understanding the underlying language, as a developer, it was easier to adapt to any tool or framework.

And this is the point.

When you focus solely on a framework, you limit the potential to evolve your skillset, or, in the event that your tool of choice is tossed into the recycling bin, the opportunity to transfer your skills to something else.

If you focus on the language, though, and its features (e.g., how Promises work or the difference between a forEach and a map), your adaptability increases. Your speed increases, too, because your brain starts to understand the syntactic boundaries between the language and the framework—you start to understand that a .map() is not a React feature, but a JavaScript feature.

As with anything, of course, this takes practice. But, by paying attention to how you think about your own skillset, you greatly increase your long-term potential and value as a developer.

So, the next time you've got "I'm a React developer" on the tip of your tongue, stop and instead say "I'm a JavaScript developer that has experience with React."