Developer

How to mentor a greenhorn developer

Mentoring new developers can be tough--especially when they have no formal training. Here's some step-by-step advice on how to ease them into a development position.


It’s not uncommon for a manager to ask senior developers to mentor their inexperienced peers. But this task becomes more challenging when the inexperienced developer doesn’t have a development background.

As the mentor, you play a key role in getting the newbie started on the right track. Dealing with greenhorn developers requires patience and skill. It’s all in figuring out what they already know, getting them into training for what they don’t know, and selecting the right project to get their feet wet.

Starting out
Here’s a typical scenario: You’ve just learned from your manager that Alex will be joining your development team from the desktop support group. Alex has worked on desktop support for two years, but he wants to move his career toward application development. He doesn’t have any programming experience beyond writing batch files. Your manager wants you to help Alex learn the ropes as a developer and as a member of the team. Before joining the team, Alex will attend a one-week immersion class about your team’s preferred development language.

Given this scenario, review what you know about your newest team member by asking the following questions:
  • How familiar is he with OS functionality and with troubleshooting? This information will be helpful as he gets into debugging and trying to solve those pesky development issues.
  • What is the level of Alex’s product knowledge? If he has been working with customers for two years, he may have insights into problems your customers frequently encounter.
  • What basic development concepts do you need to cover? For example, his immersion class will probably cover if statements.

In our example, Alex is sent to training before joining the team. This approach is highly recommended; it’s the most painless way to introduce a newbie to the fundamentals of development. You can enhance the experience by taking a few proactive steps: Meet with the new developer before training begins to go over the course outline. Point out any parts of the class you feel will be vital to drill down on. Doing so will reassure the new developer that the training will relate to the new job’s expectations. It will also give you a feel for the level of understanding you can expect after the training.

Selecting the first project
Selecting the right first project for new developers is key. The type of project and the way you guide them through it will have a big impact on how neophyte developers feel about the job.

Have a project ready for your new developer by the time he or she formally joins the team. This will allow the developer to quickly get into the work of the team and to apply the training while it’s still fresh. I like to start new developers out by having them add functionality to an existing program. This approach offers several benefits:
  • New developers won’t feel as overwhelmed as if they had to start an entire program on their own.
  • They get to see how other developers solve problems.
  • They get to see examples of good coding practices.

If you do decide to have a new developer modify an existing program the first time out, keep the following points in mind:
  • The modifications should stretch the new developer’s learning without being overwhelming or discouraging.
  • The modifications should be meaningful. As an experienced developer, you know how it feels to work on something that won’t see the light of day or that will have little impact.
  • As the mentor, you should be familiar with the program and its code. The new developer will have many questions, and you’ll be able to answer those questions more easily if you’re familiar with the code.

Introducing the project
Introduce the project by explaining the application’s behavior and describing what needs to be modified. By providing this high-level overview, you’re providing insight into how the trainee’s contributions will work into the program. Meet one-on-one with the developer to look at the code that needs to be modified. Doing so will give you an opportunity to see how much he or she learned and retained from the training. Look for the following things during this meeting:
  • How familiar is the trainee with the development environment? Just starting the development environment may be difficult for a new developer.
  • How well does the trainee grasp the language’s fundamentals? Development is impossible if the new developer doesn’t understand variable declaration, conditional statements, loops, and so on.
  • How quickly is the trainee picking up the assignment? Pay attention to body language to see how the new developer feels about what you’re describing. Yes, the first project can be daunting, but you don’t want the trainee to feel that the situation is impossible. If he or she doesn’t appear to understand the assignment, ask follow-up questions to refine the assignment.

Once you’ve assessed these points, you’re ready to help the new developer get under way.

Getting the newbie under way
When I introduce new projects to new developers, I like to use their computers to open the code directly to where the changes are required. This assures that they have access to the code and can begin to feel how to navigate the code in their own environment. Next, I help them see where the changes are needed and how the surrounding code relates. Finally, I ask, “How do you think we should start the changes?”

This question allows a new developer to think through ways to address the problem programmatically. People who don’t have development backgrounds need to be introduced to the ideas of program design, and a good way to do that is to talk through the way a new function should work. As you hash out the problem, write some pseudo-code or flowchart the solution. I like to talk through the programmatic steps, adding comments in the code that can later be replaced with the actual code. This is also a good time to introduce the trainee to your team’s development standards. Don’t dump too much at once; remember, this developer is just learning about variables and may not be ready for an entire coding style guide.

After discussing what needs to be done, ask how your trainee feels about the project. Allow ample opportunity for discussion and questions. When you’ve addressed all of the questions, ask the developer for an estimate of how long the programming will take. This question will stump virtually any newbie. But by asking it, you allow your trainee to begin to put time parameters around the project. Come to a mutually acceptable due date with built-in checkpoints. The due date can be flexible to give the new developer time to develop skills.

The project review
After your trainee has completed the project, sit down to talk about it. Look at the code. Test it together. Ask what hurdles the trainee had to overcome. As you review the code, point out areas that could be done differently with more advanced programming techniques. Don’t change the code; allow your new developer the opportunity to learn the technique and incorporate it into the code.

Conclusion
Mentoring neophyte developers is a unique challenge. Not only do you need to help them learn to program but also you need to help them learn design, good coding practices, and problem solving. If you don’t overload them with too much information, and provide the help they need, these developers will quickly become solid programmers and valuable members of your team.

Mentoring development newbies
Have you had to mentor developers who don’t have years of formal training? Post a comment below or tell us how it went.

 

Editor's Picks