Dan Corman


Software Engineer at JWPlayer. Guitar Player. Book Reader. Mountain Climber. Enthusiastic Smiler. Consumer of Apples.


10 Things to Remember When Teaching Junior Developers

Over the past few months, I have had the pleasure of teaching dozens of junior developers programming concepts, coding techniques and design best practices, amongst other topics. These ten techniques have helped to ensure a positive and successful learning experience.

10. Give them the right tools.

Many people get discouraged about a future in software development because they think, "If I can’t even get things working on my own computer, how will I be able to get things working for other people?".

This major hurdle can be easily alleviated by presenting the students with a short list of tools and applications that will quickly get them on the right path. There are hundreds of "essential" applications out there, but in reality, we only need a few for learning and advancing.

By providing the right tools, as well as a crash course in how to use each one, we alleviate a disheartening experience and provide a more focused learning environment.

Some Pertinent tools: Whiteboard, Chrome Dev Tools, text editor, terminal, GitHub

9.Scope the material

Remember, concepts that are second nature to us now, may be confusing and complex to a junior dev.

Start at the very beginning when exposing them to something new. Even if they have seen it before,it never hurts to revisit and refine the fundamentals. Furthermore, be cognizant of what they have been exposed to in the past and don't let your own interests get in the way.

Stay focused on the subject matter being learned and incrementally add as the group or individual advances.

Like building an app, shoot for an MVP then iterate and add features. Teaching should be no different.

8. Teach the vernacular

Be mindful of the language used to articulate higher concepts. As a software engineer we are very accustomed to using words to help walk other people through our thoughts and code. Words and phrases like: instantiation, object oriented, iterate, functional, abstract, isolation, modulation, etc,.

While these words are fundamental to how we think and articulate our code’s logic they may have an adverse affect on those who don’t understand them. This may be especially true to a newer developer who is not yet comfortable revealing what they do not know.

It is important to take the time to not only explain a block of code but how to talk about code and the industries common vernacular.

7. Teach and reinforce question asking

We have all heard that there is no such thing as a bad question. I agree from a philosophical perspective but not from a communicative perspective.

The internal conceptualization and intellectual curiosity responsible for producing a question is never negative. However, a person's ability to convey and articulate thoughts in a concise way sometimes falls short, especially when they don't know the right language to use.

Asking a question is an act that coincides with an individual taking a risk and appearing vulnerable. People aren't always comfortable doing this - practice makes perfect.

A good way to get others asking questions is to have the mentor/teacher ask questions to the class or individual - genuine questions that hint that even the educator doesn't know everything. Ideally this question can provoke other questions and spark a conversation.

6. Provide great resources

It can be easy to get overwhelmed with the seemingly endless supply of resources both online and off. Luckily for our junior developers, we are here to guide them to the best resources.

Whether it be blog posts, tutorials, books, white-boarding techniques, etc,. you know what is good, and you know what is beneficial to a specific subject being taught. It is good to give them a list of resources specific to different topics - use your best judgement and take the learning styles of each student into account when deciding.

5. Instill Autonomy

A developers ability to be productive on their own is a trait that all employers look for. While some individuals are naturally autonomous, others need a little bit of a nudge. An autonomous developer can research, design and implement - taking a thought and turning it into a product. This is something that comes with experience tools, resources and techniques.

Luckily, autonomy can be taught. The best way to do it is enable each individual with the other 9 items on this list, but don't stop there. It is important to go beyond this and enable each junior dev by establishing an environment, both online and off, by which they can interact with the community. A major part of being autonomous is finding the answers to good questions. However, it is also knowing what to bypass from the community.

Only through the struggle of trial and error can a student grow and learn about these techniques. Once we have enabled a safe environment for them to struggle in, we can help them and answer questions, but it is important to be sure not to give them too much and let them come to the solutions on their own. This is a major contributor to autonomy. Like training wheels, we slowly raise them further and further up until they barely need us.

4. Get them coding

If it takes 10,000 hours of practice to master something, then we have to practice. While there are hundreds of incredible sources out there for excelling as a software engineer, none will ever be as valuable as the actual time spent writing code.

Don't get me wrong, videos, literature, lectures, Meetups, etc, are all incredibly valuable, but all in addition to keyboard time. The best way to maintain and further develop our skills are through toy problems and toy projects. Short sprints of intellectually stimulating challenges will pay dividends.

Junior developers sometimes spend too much time learning the what and seeing the why/how but often don't push themselves to code... code... code. Provide toy problem resources like Coderbyte and/or Codewars and remind them of this notion often.

3. Empathize

Every senior developer has gone through the process and struggle of learning. Whether it is learning frameworks, data-structures or higher level concepts, very few expertise come easily.

More important than the skills of the educator is the experience that enabled the development OF those skills. That struggle, that persistent journey is an invaluable resource to those who are just starting out. Not only technically, but also emotionally. It can be really powerful for them to hear that you didn't get something your first time either.

Being able to relate your own experience to a junior developer will not only give them an insight into what they can expect for themselves, but will give you a wealth of new ideas on how to teach and what questions to anticipate. This skill is really powerful when you practice it with patience.

2. Be Patient and Positive

Lets face it, learning to code isn’t easy. So don’t be surprised if they don’t understand something the first time, very few people do. But with patience and reiteration, anyone can learn.

There may be times when you look at a student's code and nothing makes any sense. This is a pivotal moment. You cannot show any frustration or negativity. The student is vulnerable and often looking to the reactions of the teacher to gauge their progress and to boost confidence.

Instead, it can be good to identify and remark on what the student is doing right - validate them and their efforts and then bring up what can be improved upon. Once we have established a positive interaction, the student will often be more motivated to keep improving and refining their skills.

All this is possible because within a potential moment of frustration, we were patient and were able to practice empathy. And hey, maybe their 'unique' approach may teach us something that we didn't expect.

1. Teach how to learn, not what to memorize

"I don't know, but I am confident that I can figure it out."

The most capable developers aren't the ones who have memorized every library's helper function. They are the ones that have developed the prowess to quickly research, identify and implement the right tools for each job.

To instill this methodology, the student has to be exposed to a plethora of new subjects, challenges and approaches. Always ask the students, why they approached it this way, can you think of another way, which do you think is better and why?

Our goal is to get students to ask these questions themselves. "Is this the best way I could be implementing this."

By continuously exposing students to new kinds of material, methodologies and challenges, we enable them to learn and think about the same thing numerous ways.It is through the instantiation of a 'big picture' approach that we enable our developers to think critically with many perspectives to help them problem solve. Besides, learning is fundamentally problem solving.

This universal philosophy will ensure confidence, autonomy and, ultimately, success.

comments powered by Disqus