Do you ever get frustrated with your Junior Developer(s)?

I never got. It was absolutely wonderful that someone asked question. I also noticed Juniors have a lot of good ideas, which I did not know of. So, recommended to engage in Q&A!

No. I find Juniors a clean slate and wonderful to work with. Most good directors and CTOs will tell you the same. If you accept that you are paying a lot less for the junior, and that they come with certain obvious additional needs, I have never met a CTO or director that otherwise doesn't like juniors.

Statistically, the hardest developers to work with are usually mid-level. They may think they are senior, but that is part of the problem isn't it? ;)

Also, if a Junior developer is fortunate enough to be taught by an actual senior developer instead of another mid-level developer, or, even better, if the Junior can be taught by an actual architect or director, then the Junior never really gets into the "mountain of stupidity" that plagues normal mid-level developers.

How can you train or work with someone who thinks they know better?

Psychologically, humans are easier to get along with both when they first start something, and after they have finished climbing the 1-4 year "mountain of stupidity"; the mountain that makes them think they know things they do not. This is always the most difficult time to deal with someone.

This issue is in fact so common that it's known as the Dunning-Kruger Effect. A lot of science has been done on this, and it plagues all fields equally, not just development.

So, all personality quirks and other issues with normal human behavior that has nothing to do with knowledge aside, this human tendency to act within the Dunning-Kruger effect regarding knowledge is certainly the real issue we're all actually discussing.

In 2020, if you aren't getting paid over $150,000 a year as a developer, and you think you know a lot, you are either very, very wrong and are still climbing "Mt. Stupid", or you're severely underpaid. If you read this paragraph and think you're the latter, failing miserably will take you into the "valley of despair", i.e. place you where you belong: on the way to true wisdom.

Or, you know, it will get you paid over $150,000, which is great.

Either way, you will be sure to get over that mountain!

Yes, Juniors are annoying, but it's the way of life. Don't worry, you will someday have someone to annoy you.

I get annoyed at almost everything a Junior Developer does:

• when they say they've done the work and they haven't.

• when they don't ask questions and say they've understood everything.

• when they have 0 attention to detail.

• when they consider themselves a backend or frontend developer when they've only been working for 6 months and use it as an excuse for poor quality.

• when they expect me to fix their problems.

To be honest, the answering questions is the least annoying part of working with a Junior. I wish I would get asked more questions so that we wouldn't have to spend so much time fixing or reviewing code.

I always ask junior devs to come with possible answers and I can then help them finding the right answer. That way I know whether they have done enough homework before asking questions.

I try to ask StackOverflow and Google before I go to anyone else. I can image it would be annoying to be asked questions that are easily discovered with a quick search. Googling things also helps with learning, in my experience.

I'd be lying if I said I didn't get frustrated with more junior developers on occasion, but only really if they are particularly difficult or disruptive when I'm involved in something. Most of the time, I enjoy mentoring my junior colleagues and like collaborating to solve problems - pair programming is something I find very interesting. Also, I always come to understand something a lot better by mentoring others about it because I have to think about it in a different way.

The job of a senior developer, at least in part, is to be not just a mentor for junior devs, but a force multiplier. It's been my experience that in a team of mixed ability, then if there's sufficient scope for code review and cross-training, the junior devs will quickly pick up knowledge and best practices from their more senior colleagues. Once that's happened, the role of the senior dev becomes more of an occasional troubleshooter for complex problems, which tend to be more interesting and satisfying to resolve. If I'm in a team with more junior devs, part of my job is to help them avoid the mistakes I made earlier in my career because I was a solo dev with no-one to pull me up on bad practices that came back to bite me down the line.

My advice is to make an effort to avoid disturbing your colleague's workflow. If you have a messaging system like Slack, use that to ask questions, and throw it open to the whole team so anyone who can spare the time can pick it up with you.

If you're going to ask questions, make sure you've spent some time Googling so you can ask good questions and demonstrate you've at least identified some specific options.

"I want to do X. I've thought about doing it this way and that way. I'm not sure which would be best because this part is unclear. /or/ I think this would be best because XYZ, what do you think?"

If you're just lost on where to start, ask the other dev for a point in the right direction so you could come back later with some specifics.

And then once you get your advice / answer run with it and really understand it. Dive deep to show your appreciation, and follow up with another thank you, showing off what you've learned. Any senior dev worth their salt would love that, and you'll encourage them to invest more time in you.

I get more annoyed when the junior devs don't ask questions or feel like asking questions is somehow a waste of time. I'd rather they take a few minutes of my time instead of wasting days or their time.

I only get frustrated if you don't ask me questions. I want you to ask me questions. I enjoy helping people and seeing them learn.

I remember being an intern and the same situation. I was always afraid that I would bother my leads. I learned being there longer to never be afraid to ask questions.

My advice: don't be afraid to ask questions. But also do not be afraid to ask WHY we are doing something a certain way and why not this way. What I like to see more than anything is for someone to learn why or why not we are doing things and not just taking whatever we say as the gospel.

I ask lots of questions and started to get worried they were too many at some point so I've addressed my colleagues directly by asking them. Turned out in the end most of them enjoyed it as they could go through their ideas with me at a slower pace and were happy to teach me stuff!

Additionally, I found out the ones who might not enjoy too many questions as much as the others and would bother them less.

Andrew-

As a junior developer, especially an intern, you are SUPPOSED to ask questions. You are "junior" because you don't have practical experience as a developer. There is only so much you can learn in a classroom. That's why internships are so valuable. You can learn so much from the practical experience of coworkers, and they should do the right thing and help you (they were junior developers once). So never hesitate to lean on and learn from your coworkers.

That being said, you need to do your part. Here are some tips:

• Take notes when other developers are answering your questions or sharing important information with you. Use Microsoft OneNote, Google Keep, or even a physical notepad.

• Try to answer your own question first. Look at your notes, do Google searches, check StackOverflow. Make an effort to figure out the problem, because this is a valuable skill to build. However, don't spin your wheels. If you have no ideas on how to proceed, then don't waste your time. That's when you should ask for help.

• When you questions, don't just ask them. Mention what you tried, why you tried it, why it's not working, and what you're thinking about trying next. Let the person know your thought process. Make it a two-way discussion right off the bat.

• When you get answers, thank your coworkers. A simple, verbal "thank you!" is good enough. They take extra time out of their routines to help you. If you're grateful, they will be more likely to help you again. We generally like to help.

• Apply what you've learned to future problems. Programming problems tend to have common challenges. You'll start to see how components of one solution will help you in other problems.

• Don't forget that you can probably enlighten your coworkers too. You may be learning current technologies and techniques in school that they haven't seen or used yet. So be ready to share your knowledge with them too.

I know it's hard starting out, but we've all been there. If you meet someone who claims to know it all, they don't. There's always someone who knows more, and it's very difficult to memorize every construct in a programming language. Just keep at it. Soon, you'll have less questions and more answers. So remember to pay it forward and help future junior developers. Hope this helps.

Best way to know if you understand something is to teach someone else about that subject. On the topic of annoyance, if junior dev invests time and tries to solve a problem multiple times and then asks a bunch of questions because he didn't succeed, that's great.

But if senior dev is used as a solution solver or your personal Stack Overflow Googler, this becomes frustrating...

As a consultant for a long time I've had to field a lot of [dumb] questions from supposedly mid-level to senior devs. Questions that made me question if they know basic programming.

So, I don't find any questions annoying, assuming it's not "I don't know how to write a loop" from someone with supposedly +5 years of experience.

BTW, I've been programming for a long time, and at my new job I am asking a lot of questions. Just so I can make sure my work aligns with team practices and all that. Sorry if your senior devs are grumpy guys.

Andrew, first let me reassure you that every single one of us who embark upon a career in software development have experienced this same anxiety at some point, so know you’re not alone 🤓

I’ll add a point I didn’t articulate in that post that I think Is relevant for this discussion - you willnface this anxiety again and again...sure you may not be a true novice or junior dev when you take your next job role at a new firm...but “junior” is a relative thing....when you join a team as the “new dev” it won’t matter THAT much that you have amassed real professional experience....you won’t have the same domain knowledge and understanding of the workplace that even younger Devs than you might have if they’ve been working there for a while...

But fret not! The steps I outline below should serve you well in every new team you might join, as long as you are sincere in your desire to work hard and continuously improve yourself.

I wrote an answer to a question posed in a similar vein over on Quora a while back that I think captures the essence of both WHY we feel the pressure we do in this situation as a new junior dev:

quora.com/How-do-you-work-with-dev...

Hopefully you’ll find some of the techniques I’ve shared from own experiences helpful. They’ve served me well.

When I have managed interns in the past, I get more frustrated when they come to me after trying and failing for hours. I also have adopted that in my own career. I used spend hours trying to solve a problem I knew that a more senior team member could help with, all because I wanted to prove I could do it. I found that my solution always was much messier and took way longer than if I had just asked. Likewise, I cause more work for them because they would later have to go back in and fix something I did wrong.