July 19, 2021

How To Get Out Of Being A Junior Developer

How To Get Out Of Being A Junior Developer

We’ve all encountered dev memes at some point. The point of memes is to reflect on reality in some form in a humorous manner. Maybe I’m just overthinking it. Maybe I’ve reached a particular point in my coding career to not find them funny anymore. But there’s one meme that annoys me more than any other.

It’s this one:

As a junior noob, I used to find this funny.

As an enlightened software dev that’s worked with enough sketchy code in the past, this meme just feels juvenile.

It’s like a grade-school teacher being told the same lame jokes, over and over again — but by different kids every year.

And every year, those kids laugh their heads off at their supposed cleverness.

I was one of those kids with this meme. But now I’ve grown up as a dev. I’ve joined the devs who have made it to the other side of what acts of coding are supposed to feel like.

  • Confident
  • Clear
  • So simple that any random dev can look at it and understand it.

From what I’ve learned about clean code and keeping things structured is that if it’s complicated to you, then it’s going to be doubly complicated to others. Complicated does not equate to clever. Complicated just equates to complicated.

Complicated simplified is the real manifestation of clever.

How to understand how your code works

When we get stuck on something, we usually start by typing a question that looks something like this into Google:

  • how to do [x] in [language]

Under normal circumstances, the first or second result is often a StackOverflow question/answer. We click on it, scroll down to the solution with the highest vote or one that looks sort of alright.

This is where the junction between a forever noob and a proper developer starts.

The forever noob will copy and paste the proposed solution into their code — never actually reading it properly, let alone comprehend what’s going on. If it works, it works. If it doesn’t, well, it’s onto the next Google search result.

The process flow is different from how a proper dev will operate. The proper developer will pause for a moment, maybe narrow their eyes and try to figure and filter out the irrelevant parts, and whatever else — all for the sake of understanding the proposed solution.

The major difference here is that a proper dev seeks knowledge to understand in order to create a solution. A forever noob dev relies on sheer luck to make things work.

To upgrade from being a forever noob, one needs to start acting like a proper dev. What does this look like?

  • adopt a mentality that you need to understand everything you code
  • if you don’t understand something, don’t copy-paste it. Google it until you do.
  • accept that you have the capacity to learn and understand, not just laugh at memes because they’re too close to your experiences as a developer

Dev ranks and what they actually mean

You’re not going to know everything. The point of difference between a noob, a junior, an intermediate, and senior developer is the amount of knowledge and understanding they have on a particular language, their nuances, how to fix them, and how to connect up seemingly unrelated knowledge points in order to turn it into something useful.

Here are the traits and how I classify each level of ‘seniority’:

The noob

  • has a lot of surface knowledge
  • can tinker and make things sort of work
  • there is no actual understanding of anything in general

The junior dev

  • has an alright understanding of how things work.
  • May have gaps and holes in their knowledge.
  • can make things work with some proficiency and understanding
  • lacks general code ‘creativity’, which may be due to a lack of exposure to projects. aka. work experience

The intermediate dev

  • has a solid understanding of how things work.
  • may have gaps and holes in their knowledge.
  • can make things work with understanding.
  • has a passable level of code ‘creativity’ and can link up concepts to form solutions.

The senior dev

  • has a lot of knowledge about how things work.
  • acknowledge that they don’t know everything and goes on the hunt for more knowledge.
  • can make things work with understanding.
  • has a high level of code ‘creativity’ and can come up with effective solutions to complex solutions.

When it comes to developers, it doesn’t matter how many years of work and industry experience you have. You can have people with 10 years of ‘experience’ but suck at creating solutions. Or you can have a noob that’s been tinkering for the past three years but never quite making it to junior status simply because they don’t actually understand what they’re doing.

These are true stories.

I’ve had ‘senior’ devs post secret keys to their public repos. I’ve also had ‘intermediate’ devs copy-paste solutions for code reviews without even changing the original variable names to match the context of the project.

But how do you climb the ranks? How do you go from noob to junior, to intermediate, to a senior developer?

The quickest path is to dive down the rabbit hole.

In a nutshell, if you don’t understand something, you stop everything and start by attempting to understand the concept.

Still don’t understand a concept? Take one step backward by catching onto the part that you don’t understand.

For example, you don’t really understand how classes work in JavaScript. The more you look into it, the more you notice how people keep mentioning prototypes. So you look up prototypes and realize that there’s an entire structural and architectural side to the code construction.

It might feel like you’re uncovering a rabbit hole — and perhaps you are. This is a good thing because the further you go into the rabbit hole, the more you’ll find that there’s a network of tunnels that eventually connect up.

This is the difference between an intermediate and senior dev, in contrast to a junior dev — the intermediate and senior dev know their way around the tunnels. A junior is someone in the process of discovering, while a noob is just blinding walking around without taking notes, and hope that they’ll eventually find their way out of the maze.

So what’s the point of this article?

The point is, if you don’t understand something, it doesn’t have a place in your code. A straight copy-paste from StackOverflow is not the answer.

Don’t do it.

Manually type it out at the very least. You might force yourself to learn something rather than just blindly follow what the Internet is telling you.

Code from StackOverflow is just a general gist — not the final solution. It’s supposed to guide you. It doesn’t know the full context of your requirements, project structure, or architecture.

A StackOverflow thread can be a helpful entryway to get you down the rabbit hole. But don’t look at it as if it’s your golden ticket of a solution. Don’t paste code without understanding how it works.

Just don’t do it.

Rant inspired by memes over.

Thank you for reading.