Helping a Junior Developer Succeed

We all started out as junor developers. You start programming, think you know a bunch of stuff and then realize that there's lots more to learn. The realization that you don't know everything is a first imporant step, but much of your growth will come what you can pick up from your fellow team members. However, ideally, this should not be a passive knowledge transfer where you pick up things as you go along. With proper help and guidance from your more experienced team members, you can learn in a more directed manner and grow much faster than you would otherwise.

Lets establish a basline and assume that your junior dev has at least a basic aptitude for software development and is (at least to some degree) driven by interest in the subject at hand. Lets also get out of the way that some people lack either one or both of these; those people will, at least in my experience, never become great developers. At best, they'll be mediocre and maybe writing code may just not be the right vocation for them.

I've seen junior devs make crazy fast progress over the course of 1 year. But I've also seen junor devs languish on the same skill level they arrived with for more than a year and then quit because they felt overwhelemed. But it doesn't have to be this way! As experienced developers, it is our job to help junors succeed, if they don't, at least part of the blame rests on our shoulders.

Having gotten those baseline assumptions out of the way, let look at some of the skills and mindsets that junior dev may lack:

1. A wide range of skills across multiple platforms
2. A solid knowledge of algorithms and data structures
3. Hands on experience across multiple platforms
4. The ability to keep their code organized
5. The ability to see the big picture
6. The confidence to get it done and remain calm under pressure

I would argue that #1, #2 and #3 can be picked up independently by anyone who is interested in their field. However, #4, #5 and #6 will benefit greatly from guidance and feedback.

Having said all this, here are what you can do (and should be doing) to help your junior devs learn and become successful:

1. Environment setup: Nothing is more frustrating than having a dev environment you don't understand and/or that doesn't work properly. Provide clear instructions on how to set things up and if that fails, spend the time to help newcomers get situated. If you don't do this, productivity will fall and frustration will rise.
2. Ensure that the task give is realistic with respect to the difficulty, the deadlines given and the background and skillset of the developer.
3. Detailed Instructions: Don't just say "build feature X" but have some design documents ready which highlight the context in which this work matters and how you would want it to be implemented. Discuss the approach you think should be taken, how the code should be organized and what issues you expect to be tricky. By approaching things in this manner, you can remove many of the questions that may arise and provide a roadmap that makes the entire journey easier.
4. Regular code reviews: Do a weekly code review and spend 1-2 hours reviewing what your junior team member wrote. The prupose of this is not to say "your code sucks" but rather to provide specific tips for improvement. This can range from code organizing tips (break this class into these 3 subclasses ...), code formatting (seems obvious but I've seen truly horrific things), variable naming (again, seems obvious but you'd be surprised by what some people come up with) and anything else that makes the code better structured and easier to understand.
5. Be available to answer questions and take the time to properly explain your thoughts.
6. Give credit where credit is due. When milestones are reached, acknowledge the work done during a team meeting. There is nothing more motivating than success and the recognition of such successes by your peers.
7. Assume your share of the responsibility when things go wrong.

All of these may seem obvious, but I've seen organizations fail in this is many ways and it always leads to bad situations: dedlines are missed, code is an unmaintainable mess, people get frustrated, etc.

And now, that we've covered what you should do to support junior team members, here are some things you should definitely not do:

1. Have developers toil in isolation with no feedback.
2. Give them work which is too difficult for their skill-level
3. Be dismissive of their problems.
4. Just accept working code without checking it. The code may work but it may be a byzantine labyrith that noone understands and that turns out to unmaintainable.

While the points listed above are certainly not exhaustive, the should cover the basic issues and should allow junior devs to grow into productive team members.