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

andrewsmith1996 profile image Andrew Smith ・1 min read

Having recently started a new internship as a Junior Software Developer, I can't help but feel like I (significantly) annoy everyone with my (very) frequent questions.

Don't get me wrong, I know in myself that it's a necessity to ask questions as a Junior Dev, because after all that's how you learn and gain experience, right? So I understand that I am not in the wrong by asking questions, but I often do wonder, does this get annoying for the people (most often Senior Devs) answering my questions? After all I'm taking them from their time pressured work, I'm asking them to explain something that I'm finding difficult but they probably can do in their sleep and I'm generally taking time from their day.

So my question is, do you ever get frustrated with your Junior Developer?

Posted on by:

andrewsmith1996 profile

Andrew Smith


Developer specialising in web development and mobile app development, with a keen interest in JavaScript technologies, cross-platform & native mobile application development and Dev-Ops.


Editor guide

I think it only gets annoying when you ask the same questions again and again. This tells me that you were using me as a crutch rather than as a teacher.

Otherwise, I love it when developers ask me questions. I can help them find the best ways to solve problems, helping them learn from my mistakes.

So, the problem isn't asking questions at all. The problem is asking me the same question more than once (usually in a slightly different form or situation).


While I'm new to web development, I spent 10 years in hospitality. This encapsulates what I told many new employees. "There's no dumb questions the first time."


Spot on. Also, if you have source code to work from, read it first,then you can ask relevant questions related to the work.

If you haven't bothered to try and read the code, you will have no context, you will have put in any effort and you would not have had the opportunity to learn from others code.


This has to be the single best explanation of how to behave as a junior dev I've ever read.


As a new Jr. Dev who asks the odd question (and tries to ask as few as possbile), this makes me feel much better. Thank you!

I take a lot of notes, anything that I ask or lookup myself I write down to review later.


:) The main thing is that you've demonstrated you're putting in your side of the work to learn. If you're putting in the work and your senior developer is still annoyed, they are the problem, not you.


This is good advice in general. With how much there is to know in development I find I'm a senior and a junior all rolled up in one depending on the topic.

So I guess my point is don't forget this when you start to feel like a senior in one area. It still applies for the areas you are not as strong in.


Most times I got angry was when they didn't asked a question, they thought they knew how to do something, and did it wrong, and I had to clean it up.

Too many questions no, except when they don't use google before :)
Bad: "How I should do that (simple thing)?"
Good: "How I should do that? this way or that way?" -- means you did the research, you understood something and ask for more details.

Ofc every problem has more good solutions, but it matters how we do things HERE, now, in this team and in this project.

Recently I learned more about how team compositions work better, and what kinds of devs should be paired with juniors


My advice? Get used to the feeling. I just joined a new company as a senior dev about a month ago. I still ask a lot of questions. They're using systems I've never used before, and they have a process I've never seen before. Asking questions is how you integrate. Not being afraid to ask is a good trait. Keep it up.

As far as being annoying, I can't speak for your team, but in my experience, they're likely busy. Context switching can be hard, but it's necessary when you're bringing in new talent. Give it some time. You'll find that you ask fewer questions, and you may start answering some as well.


Sometimes, there is a little frustration if I am in the middle of something and I am interrupted. I don't think anybody like that feeling. But, we all go through the same process, so I quickly remind myself where I come from, and it is only a natural thing to do when you are a junior dev. It's important for the junior devs to feel like they can ask questions all the time, especially if they think it's a stupid question.


I find this had a lot to do with how you're asked. Interrupting someone in person while they're working interrupts flow. Catching them while they are talking a break (coffee, bathroom or just taking a walk) is much better.

Even better (IMHO), asking in a group chat room is non-obtrusive, and someone else can answer sooner if they know. On top of that, it's going to help other people who can read the conversation.


Totally agree with that!


I like this approach... Just remember to let the group know it got sorted so others don't waste their time ;)


Don't be worried about asking questions, even if you are asking a ton of them. The biggest red flag to me is when developers don't ask questions.

I've been in your shoes before, and the biggest mistake I made was not being restrained in the way that I asked questions. Anytime a question popped into my head I would immediately seek out someone to ask. It was impulsive behavior caused by 2 things.

One, the desire to learn. Just being young and super excited to soak it all in. Two, using questions as a way to show my mentors how excited I was.

Here's what I would recommend you do. Collect all the questions you have over the course of the day. Then, approach your manager/mentor at the right time and say "hey, I've got a list of questions I'd love to discuss when you have some time we could block out."

Using this approach you'll give yourself time to organize your thoughts. Also, some of your questions might become irrelevant or answer themselves. The biggest payoff is you'll look more professional to the team by demonstrating respect for others time/focus, while still getting to ask all the questions you want.

You can follow this up by saying something to the effect of "hey, this was really helpful and I appreciate you taking the time. Would it be possible to setup something on a reoccurring basis?"

Good luck!


Yes, I do get frustrated with junior developers... when they don't ask those questions. I love filling in people's knowledge gaps with "simple" questions because it's an opportunity to share knowledge and maybe reaffirm to myself that I actually do know what I'm talking about.

That being said, I'm not always great at showing that I'm available for questions and sometimes I'm busier than other times. But if I'm ignoring you, it probably means I didn't see the notification and I'm stuck in some deep work, but when I tell you I don't mind if you poke me again when I forgot to get back to you yesterday, I mean it.

I also don't have a ton of patience for pair programming, and that's just me, and it has nothing to do with being annoyed with anyone. Some people love to jump on things and are, frankly, more helpful to juniors. I'm more introverted and my capacity to help for extended periods of time is not the best. But even despite this, I love the questions, and will look to get you the help.

So for me, the bottom line is that I don't get annoyed with this, and absolutely prefer it to the other extreme, but I'm still not always totally available to be helpful. That's just life. And ultimately, any time someone has asked me how to ask me questions, we've always gained clarity together. So I'd suggest getting some clarity on what a good approach is. I think people typically tell the truth when asked that question.

I'll also add I don't get that annoyed if you aren't asking the questions. Really you do you as long as you're trying your best and being a team player.


I have recently started forcing myself to not wear headphones. Which can be a problem, but O find that people will avoid asking any questions if you appear in the zone or focused.

I view it as part of my role as a sr to answer questions. I pad all of my estimates knowing that I expect 2-3 hours per day to go to helping others.


Junior devs frustrate me when they:

1: Refer to their lack of knowledge constantly ("I'm just a junior") - don't do this! Lack of experience doesn't mean your opinion is worth less. Also, the more you remind people that you're "just a junior", the longer people will treat you as one, even after you don't feel it's true any more.

2: Don't ask enough questions, or don't ask questions early enough - if you give me the impression you understand something, then I'm going to imagine that you do. But if you make it clear that you don't understand something, I'm going to make sure that you do! This is a tough one of course, because I know that as a junior developer, it's often hard to know whether you understand something or not, and as a mentor I have a lot of responsibility for not letting you feel like you have to pretend to understand things.

3: Want something done for them, rather than wanting to learn how to do something - pretty obvious one but when mentoring junior developers, you're not there to do their work, you're there to help them grow. Thankfully I've only ever experienced this with one junior developer ever, and I'm pretty sure that this is an uncommon issue on the whole in software engineering.

Senior devs frustrate me when they:

1: Forget that they were junior developers once too.

I think every senior dev can probably recall a time when they were junior devs, and their own mentors (or just senior devs around them) would get frustrated by their questions. I certainly do. If you feel people are getting frustrated by your questions, perhaps gently remind them that you weren't born with a knowledge of the things you're asking about; hopefully they'll remember that they weren't either. :-)


Senior devs frustrate me when they:
1: Forget that they were junior developers once too.

Yes! And it's easy to do in the moment, but it's something you should be consistently checking yourself on.


Oh yeah, I'm not saying I'm immune to this. If you're in the middle of something and you're being asked questions frequently, feeling a tinge of irritation is natural and often unavoidable. But yeah, as you say, you need to keep that in check and make sure that you don't make people feel like it's "unsafe" to ask for help.


It's a funny balance isn't it. I encourage absolute honesty about your own level of knowledge, in the sense that I 100% believe that it's totally fine to say "you know what, I have no idea", about anything, because everyone has gaps in their knowledge.

But the reason I discourage people from constantly reminding others that they're "new" or "junior" etc. is that when people do that, other people have less faith in them; often team leaders / project managers / whatever will end up avoiding giving people "tricky" bits of work if those people are actively suggesting to people that they're less capable, and that really just perpetuates the problem!

So yeah, I guess what I'm saying on that one is just be open, but not apologetic, about what you do and don't know. And that's advice for everyone, not just junior software engineers. :-)

Awesome that you tell people the same thing; genuinely pleased to hear that sort of message coming from other places too!


Actually, I am a little obsessed with how to train junior developers the right way so they can avoid the pitfalls I experienced and grasp the more advanced concepts as easily as possible. So, if I ever happen to answer your questions, you might find me taking some time to really think through and consider several different ways to try to find the best way to answer!


Yes. The teachers are just as self-aware and sometimes self-critical.


TBH, if a senior dev gets annoyed with jrs asking questions or for help they're not really a senior dev in my opinion. Part of a senior dev's skill set should be the ability and desire to help jr devs grow. If you can't do that you have a skill to work on.


I want junior devs to ask questions. I feel more confident on a topic if I can explain that to a junior dev and he/she understands it. :)

Something I expect from not just junior dev but rather any dev, before asking question always do your "Due Diligence". After a few years of experience its really easy to tell when a person has done some work before asking me a question.

This is most important factor me personally. I also follow this rule when I try to ask question to other people.


Haven't been frustrated with them yet. Will probably be if they give up and stop making progress.
Naturally, to make progress, they ask a lot of questions. And that is great. Knowledge should be shared, not held by those who got to it first.
Of course, I expect them to first try on their own - either to figure it out, or find an answer online. I am not Google, nor StackOverflow. Once they put some effort in, I am more than happy to help.
Juniors are a great way for me to grow as a mentor/teacher. They are also a great tool for detecting issues with the pre-existing, well, everything. Juniors don't know why things are as they are. So they ask. And should be encouraged to ask. Often, I find that the reason for something is no longer in effect, and the thing can or should be changed.

Just, you know, be kind. Be thoughtful. As happy as I may be answering your questions, I have my tasks as well. Respect others' time and effort, and you'll do just fine.


Teammates asking questions should never be annoying. If I can spare the time, I'll try to give them a hand and get them going, if I can't, I'll give a general answer or point them at where they can look - managing my time is my own problem, so being busy isn't a reason to get frustrated. (Of course, it's polite to ask if someone has time first.)
Also, I will ask questions back. There's bound to be a technology I'm not familiar with, or a part of the system I haven't worked on, and it's important that asking questions is part of the day to day life of the team, and that no-one feels like they're losing face or being talked down to for needing help. And to be honest, it's nice to be asked simple questions that I know the answer to!


I've been a senior developer at my company for quite a few years now, and coincidentally I read over the requirements for my position today. They're pretty standard for most places, and one of the requirements is that I mentor more-junior developers. So, for you, I wouldn't worry about if you're bothering the senior developers you work with because it is literally their job to help you.

If they are getting bothered by your questions in a way that you notice, then I've got bad news for you: You're working with a bad senior dev. I don't know if there's anything you can do in that case, so lets ignore it and focus on senior devs that either a) don't get bothered by questions, or b) deal with their frustration without taking it out on others ("are grown-ups" in other words)...

First-off, as others have already said, asking questions as a junior dev is a very good thing. It's part of how you learn. If you think you're asking too many questions or worry that your questions are too basic though, try something that a junior dev that worked under me started doing. He told me once that he worried he was asking me too many questions, so he started asking himself "What would Jeff say?" before asking me a question. Most of the time he got an answer from imaginary-me. Even if you don't get an answer from your imaginary senior dev, you might figure some more details out and be able to ask a more informed question.

As for worrying about wasting their time, don't worry about that either. Most of the senior devs I know (myself included) subscribe to the "Montgomery Scott School of Project Estimation". You take your estimate of how long a project will take, multiply it by 4, then tell your manager that number (my manager knows I do this, and in fact then further multiplies it by 2). This is done to account for unforeseen problems with the project, poor project planning, and answering questions from junior devs.

Good job thinking of others though!


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.


Hello Andrew.

Well this depends ;) Of the senior dev in question, junior dev in question and the environment. Just earlier this day a colleague of mine was actually complaining of a Junior dev there that ask questions on everything over and over again, doesn't take notes, get easily distracted, doesn't know much and don't make the effort to find by himself even for basic stuff that anybody can google like how to create a page in confluence. he wouldn't read neither the doc he is provided.

But you as a junior dev can do a lot to make the experience for both better. You can try to group questions, to ask them when the senior has time to respond. You can check by yourself, you can try to not always ask the same guy, you can ensure you take notes so that you don't have 10 time the same...

Still understand that it is essential to ask questions. It save time for all. There no issue, if both side behave nicely ;)


I love taking the time to help the junior members of my team. Teaching someone something new makes the team more capable and sometimes gives me an unexpected insight into an old problem from a junior developer's fresh eyes. After knowing junior developers who do nothing but ask questions and others who refused to ask questions when they needed help, I instituted the Thirty Minute Rule. If they ask for help before thirty minutes are up, they're cheating themselves out of valuable opportunities to work it out for themselves. If they don't ask for help after thirty minutes, they're probably just fruitlessly banging their head against a wall and only getting frustration and imposter syndrome out of it.


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.



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.


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.


Sometimes I get frustrated. Then I take a deep breath, and accept it's my problem, and not theirs.

Most of the time, though, I love to answer questions. Imagine how good it feels to be the guy people go to for answers. Honestly, there is no bigger ego boost. Besides, half the time they're asking questions that I've not thought about much, and answering them clarifies things in my mind. And sometimes by asking "Why is this code a bit weird here?", what they're doing for me is reminding me that we have a chunk of tech debt that we've become inured to by constant use. A fresh pair of eyes, untainted by years of just dealing with some odd bit of code, is often very valuable to a project. And a less experienced developer can highlight areas of needless complexity, too. Flattening a learning curve is a very positive thing.

Even, sometimes, the same question over and over can suggest that something really is simply hard to grasp - or maybe I'm bad at explaining it. Rarely does it mean (on its own, anyway) the junior developer is no good.

In fact, the only thing that I find frustrating, annoying, and frankly unforgivable is when junior developers have what looks as if it could be a birth year in their username if only it wasn't so damn recent...


Not always, but it you're a senior dev and get frustrated by the same question over and over again, it could be that you're not enforcing the idea of the junior dev having a notebook or whatever to write down the answer.
I get hella frustrated with anyone in a meeting or whatever that doesn't bring to the table a way of recording info. If I get asked a second time about a thing that could have been written down the first time, I get frustrated.


I do.

And it's not because they ask questions so frequently, but because they don't ask the right questions. It's easy to rely on someone who knows more than you and maintain a low responsibility position as long as you can, so you can just ask for the solution of your problem rather than asking for techniques to solve it.

This leads not only to repeated questions (annoying), but also to frustration for me if I can't manage to answer quickly. Because, it should be noted, I make mistakes too. And, I'm sure, more often than I can imagine.

That being said...

I also get frustrated with them if they don't ask questions! And rather try to solve their problems with convoluted, over-engineered, poorly thought, gullible and simplistic solutions. I appreciated initiative a lot, but always take your time to ask yourself: "Am I doing the right thing or I'll end messing everything up?"

That's something that I do on a regular basis and kept my sanity for so long. So, just remember that being shy won't lead you anywhere, and spit your doubts out.


I’m aleays happy to answer junior questions, BUT I don’t tolerate when they only want quick answers or don’t want to learn from the sources I point them to. My approach is a gentle version of the good old RTFM 😉


Everybody ask the same questions all the time. That's not a problem. When you have that responsibility, solve others problems (I do have) is your fault if people don't have: docs, wiki, examples and many times a shoulder to cry.

Don't suffer for that, just try to fight a little with your problems before ask


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 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 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've learned that taking your time before approaching another dev to phrase the question clearly, concisely, and with the relevant context (including the things you've tried), you'll often find the answer (or the way to the answer) along the way, and if you don't find the answer, then your question shows that you've put thought and effort into solving the issue first.


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...


I would flip this around a bit. I get frustrated with my junior developers if they dont ask me questions. That tells me that either they are not interested or are too worried about how they sound which will in turn hinder them ever moving out of the junior developer zone...


It's natural if you're out of your element at first (ie new language, framework, stack, etc) and you need to get caught up, or if you get caught on random syntax gotcha's. What gets annoying is when one interrupts someone who's in the middle of programming or solving a problem. Breaking the concentration of someone who's 'in the zone' can be highly irritating.

Truthfully, try talking out your issues out loud to yourself (this is called rubber duck debugging) - you'll often realize the core of the problem and find a solution before you finish speaking. If that, researching documentation, and google fail you, then ask a co-worker or an online tech community. Then bookmark or otherwise document the information your coworker gives you, for future reference.


No. I actually feel ashamed. Not because they are asking foolish questions or repeating the same question. But because I never had mentoring experience before, and I was a rough student on my teachers. I feel ashamed of giving them the pain I am getting. Though I learnt a lot in giving them pain, but I am happily accepting this pain as I consider this as my responsibility to teach what I have learnt.


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.


The line between necessity to ask questions and annoy everyone with my frequent questions is how much you learn.

As a senior dev I can differentiate between

"they simply can't know the answer"

"they could know, but it's not mandatory"

"how often do they wan't to ask me the same thing"

"How does the companies API work" or "how do I set up a dev environment for this internal software I have to fix a bug for" are valid questions to ask, because there are often no docs for this internal stuff.

Also, the most important thing I learned as a junior dev was, how to get information before asking someone.

You have to decide when it's faster to ask someone and they explain it to you, so you can ask follow questions and when it's okay to read some things online about it.

"How do I use promises in JavaScript" may be a question you could ask or read online. Maybe there is a senior who has time to spare and can tell you how they work, you ask the follow up questions and get running in short time. Maybe everyone has work to do and since you're a cheap junior dev, nobody cares if you need to work an afternoon through a tutorial or something.

From junior devs I expect that they can at least start their computer alone and produce some kind of meaningful software in the language they were hired for ;) so questions about this may annoy people.

Also, if you ask the 10th time about things that you could have already written down the first time, I get annoyed, lol.


I think its fine to ask if an only if:

  • You've put a solid 15 minutes into the problem first. Tried a few things and now are genuinely stuck.
  • Respectful of how the other person likes to be interrupted. Don't expect an instant reply.
  • Are respectful of the other persons (seniors) time - it's more valuable than yours. No offence, but it is.

Initiative and respect goes a long way as a junior. Use it!


Grumpy old man here. :-) Questions are fine. Many questions are even better. I value the fact that you're willing to learn and eager to try things, even if that means I'll have to work overtime to compensate the hours spent with your questions.

It frustrates me if you don't. Lack of passion, "works for me" attitude or laziness drive me nuts. Indifference towards your results kills me. That's all much worse.

Keep up bugging seniors with questions, it'll make you a much better professional. Fast.


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.


Personally, I welcome questions from junior developers, and from anyone, really, so long as the asker is really willing to learn (you'd be amazed how often people ask questions and don't want the answers.)

In my experience, questions from junior developers benefit everyone involved. It is amazing how many "beginner questions" are actually quite non-trivial, and everyone ultimately learns from. Even truly trivial questions often make for good reminders for everyone involved.


Never had problems with juniors. Only had few problems with askholes (they ask question just to ask something). I enjoy working with juniors. You teach them plenty, they teach you some. As long as you teach them how to use google and communicate with rest of the people on the project you’re fine.


I was always ashamed to ask a Sr Dev for help to the point that my lack of asking for help was a negative mark on one of my early performance reviews. But as a Sr now, I wish my Jrs would ask me more questions.


Explaining/teaching things to them actually helps me refresh my own understanding of concepts.


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?

Statistically, the dumbest developers are mid-level

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!


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:


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


I try to emphasize (and often empathically re-emphasize) that I want devs to ask questions, and that goes for juniors and seniors alike. In that regard, it's important though that the answer always addressed why the question was asked.

Personally, I also tend to regulalry ask questions that have an obvious, implicit answer, as I prefer that assumptions are made explicit. That way, everyone is on the same level, and faulty assumptions are less likely to occur/persist.


The other anwers explain my perspective perfectly, but I want to add one important point:

In my experience, the best developers in the field never stop asking each other questions. If you can overcome feeling like a dummy and ask someone else for help, you have a chance to learn and fill the knowledge gaps you encounter.
New concepts in software are created every day. We're all humans, and no one can know everything.


It's more annoying if someone asks a question, for example how to debug a specific part of the code ... which may be almost impossible to debug in some cases (multithreads for example), therefore I suggest to write a JUnit in order to test only the part of interest ... and with this contribute to more stability ... but the Junior refuse to write the JUnit because he is too lazy to write additional code ... AAAARGGGHHHH ... unfortunately corporal punishment is not allowed in our country/company!

So if you ask and you get an answer or a suggestion, try at least to put it into practice and then after that ask your next question. In short, not the questions are annoying, but the reaction to the answers.


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.


For me it gets annoying when they only want the easy answer for the problem they are seeing instead of wanting to actually understand the whole issue that you are trying to explain.


It would annoy me if you haven't tried anything on your own. If I can go to Google and the 1st search result is your answer, I'd be bent.


Nope, not with junior developers just senior developers who do that. Yes, there are a lot of them.


It’s cool. We’ve all been the new guy at some point in our career.