I consider this topic very important for everyone working in IT and even those that are currently interns, because eventually you will become Senior Developers and will need to nurture your own interns.
There are few things in the world of software development that have such a huge ROI as nurturing your interns to be the best possible engineers possible. While this goal is not achieved with every intern, I think it is the job of the manager (or the Team Lead) to bring out the best qualities in them and improve those qualities.
Over the years, I've had some interns that exceeded my expectation as well as those that didn’t due to being unmotivated. Usually the main difference between those two types was, that the former type had some sort of passion towards programming. And that's currently my rule of thumb - if I see that a person lights-up when he's talking about programming (e.g. some cool stuff he has built over the summer/weekend) - he's probably going to be a good developer in 2-3 years.
Nonetheless, every intern needs to be taught and nurtured. Here are some rules that I developed during my years that I'd like to share.
This goes without saying, I never believed in unpaid internships. An intern is an asset with unlimited potential, so investing time and money into their future is a no-brainer.
Don't hire just anyone
Interns might not have much knowledge, but that doesn't mean they need to be hired differently than other employees. They still need to be tested for a cultural fit and for the adequacy. Furthermore, try to hire interns when you have projects for them to work on, there's nothing worse than an intern coming in and having nothing to work on.
Progressively complex tasks
This is the easiest thing to do, and also the most important one as I see it; the tasks that are given to an intern always need to be just a tiny bit harder than what he can currently manage. As a very basic example consider this: Your intern successfully wrote some script last week to do some aggregation, as a next task you might consider asking him to improve the solution with raw SQL, or add concurrency/parallelism, or implement it as CLI Tool. This keeps them on their feet as they browse StackOverflow trying to find a solution.
We all know how hard programming is at the start, so it's better to battle against many small challenges, increasing the difficulty over time, rather than only few big ones.
Stupid questions are acceptable. Once.
The policy that I try to enforce is that you can come up to me with any question, regardless of how dumb you think it might be, I will try to answer as thorough as I can or at least give some pointers. But this can happen only once per question, so if a week later a person comes up to me with the same question, I will tell him to try and find the answer himself.
Get the entire team involved in identifying and evaluating project risks. Everyone looks at the project differently, and sometimes the input from the student intern can be vital.
This has worked quite nicely over the years, because people started to really try and remember the answers and write them down if necessary. (Although usually the answers are in Slack, so it's even easier to go back and reread them)
Giving problems from different domains
It's important to let them have a taste of problems from different domains. This serves two purposes, the first one being - broadening their problem-solving spectrum. This is useful because it's possible that in the future they will end up in a situation where they will need to have some basic knowledge of some random domain. The more domains the person has "tasted" as an intern the easier it will be for them to adapt later.
The second reason being - they may end up liking that domain even more than they do their current one. This is self-explanatory, as the intern doesn't have many experiences, he may suddenly find a passion for something different.
A well-rounded experience is the most important asset for the interns future career.
As an example, consider this scenario: An intern working in the Frontend that has zero knowledge about the Backend - it's probably wise to let them fix some bugs in the Backend, even though it would take them more time. Or maybe give them some tasks from the DevOps for them to understand how the whole CI/Deployment looks like etc.
Teaching them standards
It's important to teach good standards from the start. Good standards result in good habits and good habits eventually lead to good quality code. The earlier a person develops some of those habits the better.
Good habits formed at youth make all the difference
It's far harder to try and get rid of bad habits than it is to develop good ones, so enforce standards as much as possible, even when the intern complains and doesn't really understand why they are so important. It will definitely benefit them. As an example of some of these good habits: Terminal usage as much as possible, reading documentation/comments before trying to use a library, rebase instead of merge, DRY and KISS principles, limiting function size, tests etc.
Working on their Soft Skills
In my opinion having good communication skills is as important as having technical skills. Some interns may think that their academic achievements are the most crucial part of their work success, but that's not the case. You will probably need to teach them the opposite. The idea of being a loner and coding in your cubicle for hours on end without interacting with anyone doesn't work nowadays.
This means you need to start teaching them good communication - translating ideas into words and conveying complex information in an understandable way. This is important not only inside your team but with other departments also.
Giving them freedom and holding them accountable
Although some interns truly need to be managed constantly (e.g. micro-managing), most people are able to complete simple tasks on their own and take responsibility for them.
He that is good for making excuses is seldom good for anything else.
Not even interns enjoy when someone is constantly looking over their shoulder. Let them work autonomously, but have an agreement that if the intern is stuck for more than several hours on a single problem he should come to you or ask for help from someone else.
Allow them to fail
You need to take into account that most likely, they will fail and make mistakes a lot.
Several years back I read a story about an intern who dropped a production database (sadly I don't have a link, if you do please send an email and I will add it, UPDATE: https://reddit.com/r/cscareerquestions/comments/6ez8ag/accidentally_destroyed_production_database_on/), and the supervisor got really mad about the whole situation and the intern was fired. I do understand the position of the manager, it's a pretty tough situation to be in, but the responsibility is 100% on the supervisor and not on the intern.
There should never be a possibility for the intern to fail so spectacularly, they need to work in a controlled environment.
Experience is the name every programmer gives to their mistakes.
This topic is always up for debate and people will have their preferences, but I think this can be a really productive thing. Allow the intern to be the driver, while you observe their thought process and guide it. Over time this will help them see the patterns on their own. Another bonus of this exercise is that the intern can't get distracted by Whatsapp or reddit while you're sitting there with them, so they are more concentrated.
Tech Talks, Books, etc
There's so many good tech talks on youtube, it's important to share them with your interns. Otherwise you're losing on an extra source of knowledge for them. I would suggest having a list of must-views and must-reads for the programming-language of your team’s choice. You can then have some Fun-Fridays where you watch those Tech Talks together or maybe some of your Senior engineers can hold their own internal tech talks (depending on the size of your company and the resources available)
Teach other people to manage interns
As crazy as it sounds, not everyone is aware how to mentor interns. A Guide with links to resources where one can learn how be a good mentor is a nice to have.
Regular 1 on 1 Meetings
You need to catch the blockers early, so a bi-weekly meeting with an intern about their progress is necessary. The usual questions include:
- What did you do since our last meeting?
- Did you have any problems during that time?
- What do you need to improve your stay at the company?
- What were the highlights/low points of your week?
Constantly improve your internship program
After the intern finishes his internship it's important to ask the critical questions:
- What would you like to have known before the internship started?
- Did you accomplish what you wanted to with this internship?
- What was the most beneficial experience for you?
- What would you have done differently?
In conclusion I want to say, that the first internship a person has, has a huge impact on their later life. It's important to make it a good one, let them have fun, let them explore, let them find their passion and don't make them stress too much as otherwise, they may reconsider their career choice and we really don't have enough developers in the world to allow that to happen.
Do you remember your first internship? If you think I missed any points, or you just want to talk about the topic, send me an email.