🧑‍🏫 How To Learn Programming From The Pros
Tags: beginners, programming, learning, codenewbie
Published: 2023-09-14 12:21:23

## Tapping into the expertise of experienced devs to boost your learning journey.

---
I have always really admired (and sometimes slightly envied) smart people.

Now it’s not that I think I’m stupid, but no matter how clever you think you are, at some point, you’ll come across (and be humbled by) a truly brilliant mind.

I find this especially happens a lot in the world of software engineering.

As programming can be such a complex thing, there’s always going to be someone who can solve a problem you’ve been having for hours mere in minutes!

There have been a few Senior Devs I have come across at work where I wish I could spend just 1 day in their head.

Or just borrow their brain for like an hour or so just to see how they think. I’m _convinced_ it would make me a better programmer.

However, sadly that’s not possible, but what _is_ possible is to **learn** from them.

Tapping into the hard-earned wisdom of experienced developers through mentorship and knowledge sharing can provide a shortcut to ramping up your skills.

That’s why I want to talk about the most effective strategies for absorbing precious programming know-how from the pros.

We’ll look at techniques for connecting with mentors, asking illuminating questions, applying advice through targeted practice, and understanding your own optimal learning style.

With some purposeful strategies to learn from the experts, you can avoid unnecessary struggle and take your coding skills to new heights!

Let's get started...

## The Importance of Learning from Others 👥

### Why Reinvent the Wheel?

As a programmer, it can be tempting to try tackling every [coding challenge](https://dev.to/evergrowingdev/7-coding-challenge-websites-to-sharpen-your-skills-1097) from scratch. After all, isn't that how you get better - by figuring things out yourself? Well, yes and no.

While hands-on practice is critical, there is also huge value in leaning on the solutions and experiences of those further along the coding journey.

Take debugging, for example. If you run into a runtime error, you could potentially [spend hours](https://dev.to/evergrowingdev/stuck-on-code-heres-how-to-unblock-yourself-3bo9) in a fruitless rabbit hole trying to fix it.

Or, you could ask a mentor or senior and learn that this is a common bug with a simple resolution. The latter approach saves tremendous time and frustration.

Or let's say you need to add user authentication into a web app.

Rather than building a system from the ground up, an experienced developer can point you to proven libraries and guides to implement authentication in a robust, secure way with much less effort.

### Shortening the Learning Curve

Experienced programmers have already overcome much trial and error in mastering technologies and problem spaces.

Tapping into their expertise through mentorship allows you to skip years of potential struggles.

[Surveys](https://guider-ai.com/blog/mentoring-statistics-the-research-you-need-to-know/) of new professionals consistently find that finding a mentor accelerates skill development tremendously compared to learning solo.

Mentored engineers also tend to be more productive and get promoted faster according to industry data.

**The message is clear:** connecting with seasoned pros meaningfully speeds up your growth.

Don't try to figure everything out alone - build on the hard-earned lessons of those ahead of you.

## Identifying Potential Mentors 🔍

### In the Workplace

If you're early in your programming career, look around your workplace for more experienced developers who could provide mentorship.

Ideally, seek out those who are supportive team players, skilled at explaining concepts, and passionate about developing others.

Make it clear you value their expertise and are eager to learn.

Offer to buy them coffee and pick their brain, or set up recurring 1-on-1s to review projects and ask questions.

If they seem open to the idea, propose establishing an official mentorship relationship.

### Online Communities

You don't have to limit yourself to in-person mentors.

Online platforms like GitHub, StackOverflow and various programming forums are full of experienced developers willing to guide newcomers.

Study users' profiles to find those who regularly provide thoughtful answers.

Pay close attention to their feedback on your posts, and don't be shy about asking follow-up questions.

You can even connect 1-on-1 over chat or video calls to get personalised mentoring.

### Events and Meetups

Attending industry events, conferences, and local meetup groups lets you expand your network.

Look for speakers or attendees wearing "Ask Me For Help!" stickers or similar indicators they're open to questions.

After presentations or panels, be bold and approach speakers to ask engaging questions.

Request to connect on LinkedIn and continue the conversation.

If you meet helpful developers, tell them you'd love to follow up if any mentorship opportunities arise.

Over time, these events are a chance to cultivate promising mentor relationships.

## Effective Communication Techniques 🗣

### Active Listening

When receiving guidance from a mentor, don't just passively hear what they're saying.

Employ active listening tactics like maintaining eye contact, nodding, leaning forward and summarising key points back to them.

This shows you are fully engaged and absorbing their wisdom, which encourages them to keep sharing insights.

Taking notes is also wise so you can review the advice later.

Active listening produces a productive mentor relationship. Mentors want to feel their time and effort to help you is well spent rather than wasted.

Show them that their years of experience are **valued**.

### Asking the Right Questions

Well-crafted, open-ended questions bring out the most substantial guidance from mentors.

Avoid simple yes/no or dead-end questions. Instead ask things like:

- "What was the thought process behind this design pattern?"
- "How did you identify that optimisation opportunity?"
- "Why is this particular library better than alternatives?"

Prepare questions ahead of time around challenges you're facing or concepts you want to understand better.

Ask your mentor for feedback on how you can improve your questions.

### Being Open to Criticism

It's likely a skilled mentor will point out flaws in your code or gaps in your knowledge.

Welcome this constructive criticism, even when tough to hear.

Remind yourself they're **helping you improve**.

If you feel defensive, take a moment to calm those emotions before responding.

Then sincerely thank your mentor for identifying areas you can work on.

Ask for specific examples to illustrate their points and commit to applying the feedback.

With practice, you can get comfortable receiving criticism and view it as helpful rather than as a personal attack.

This emotional intelligence and maturity will serve you well in the mentor-mentee relationship.

## Structuring the Learning Process 🗓

### Regular Check-ins

Schedule regular 30-60 minute check-ins with your mentor, such as weekly or bi-weekly.

Come prepared with an agenda - questions you have, concepts to clarify, projects to review. Share any wins and difficulties since your last meeting.

These recurring touchpoints provide focus and continuity, guiding your learning in a targeted direction vs. haphazardly.

**Consistency also strengthens** your mentor relationship.

### Actionable Goals

Collaborate with your mentor to define specific, measurable goals based on what you aim to achieve through your mentorship. Set realistic deadlines for accomplishing each goal.

For example, "Use object-oriented principles to refactor this code base by X date." Track your progress between meetings.

Review completed and upcoming goals each check-in.

Well-defined goals and metrics motivate you while allowing your mentor to clearly see your growth.

### Project-Based Learning

Supplement meetings by working on coding projects that put your mentor's guidance into practice.

Develop mini-apps, contribute to open source, or [build products](https://dev.to/evergrowingdev/how-to-build-things-people-want-to-use-4g5n) for a portfolio.

With hands-on application, you transition from passively absorbing information to actively upskilling.

Projects also provide real examples to discuss with your mentor and get feedback.

## Harnessing Collective Knowledge 📚

### Pair Programming

[Pair programming](https://dev.to/evergrowingdev/the-ultimate-guide-to-effective-pair-programming-5aej) with a mentor involves working together in real-time to code a feature.

Your mentor does some of the work while you observe, and then you trade-off.

This exposes you directly to their thought process and skills.

Speak up often to ask questions and understand why they are making certain decisions.

Effective pair programming requires clear communication, dividing tasks, and checking your ego.

Follow your mentor's lead rather than assert your own ideas, and be receptive to feedback.

### Code Reviews

Ask your mentor to do regular code reviews where they inspect your completed work and suggest improvements.

Be open-minded, as this highlights both strengths and areas needing growth.

Code reviews teach good practices and prevent you from reinforcing [bad habits](https://dev.to/evergrowingdev/dont-let-these-bad-habits-destroy-your-code-learning-dreams-22n3).

Common newbie mistakes like inconsistent naming, tangled logic, ignored errors and more will come to light.

Use code reviews to identify and correct these pitfalls in your skills.

### Reading Code Together

Pour over code bases together with your mentor, especially well-written ones like open-source projects.

Discuss the structure, syntax choices, and design patterns used.

Reading high-quality code expands your exposure to how experienced developers problem-solve and organise programs.

Tackle reading sessions systematically, file-by-file.

Take notes on effective techniques you observe that you can apply in your own work.

## Balancing Independent Learning ⚖️

### Applying Learned Knowledge

The guidance you gain from your mentor is most impactful when quickly applied.

As soon as possible after your check-ins, implement the advice in your own projects. This cements newly learned concepts while fresh.

Review your notes afterwards to **highlight key takeaways**.

Follow up with your mentor to share successes and seek clarification on anything you struggled with.

This feedback loop aids your retention.

## Understanding Your Learning Style

Everyone [absorbs information differently](https://dev.to/evergrowingdev/how-to-choose-the-right-learning-style-for-you-3fa).

Reflect on your preferences - do you prefer big-picture concepts first, or hands-on coding?

Learn through reading, videos or discussion?

Communicate these insights to your mentor so they can tailor their approach.

For example, if you love [diagrams](https://dev.to/evergrowingdev/5-top-free-diagramming-tools-for-software-development-a4a), they can visually explain programming architecture.

Adapting the mentoring style to your needs accelerates your growth.

### When to Ask for Help

Aim to independently research issues before turning to your mentor.

But know when to curb your frustration and seek their help.

If you've hit a dead end after 30-60 minutes of troubleshooting, it's time to consult an expert rather than waste more time stuck.

Find the balance between self-driven learning and efficiency through mentor guidance.

## Conclusion

Learning to code requires perseverance through [hurdles](https://dev.to/evergrowingdev/dealing-with-the-things-that-hold-you-back-when-learning-to-code-1lgn).

But you can ease the path by connecting with programming veterans - their insights help you avoid needless struggles and accelerate growth.

Effective mentorship is a two-way endeavour. As the mentee, you must actively listen, ask thoughtful questions, implement advice, and stay humble.

Of course, mentorship is a **two-way street**.

For it to flourish, you must put in the work - actively listening, asking thoughtful questions, implementing advice, and staying humble.

Do this, and you’ll form bonds that provide lifelong learning.

Even masters were once beginners.

They remember the struggles of starting out all too well. So when given the chance to guide eager newcomers, most are happy to pay it forward.

Surround yourself with supportive mentors and experts whose expertise can lift you to the next level.

Your learning will blossom, and one day you may even mentor others and be the brain they want to steal.

From your fellow ever-growing dev,

Cherlock Code

---
💙 **If you liked this article...**

I publish a weekly newsletter to a community of ever-growing developers, seeking to improve programming skills and stay on a journey of continuous self-improvement. Focusing on tips for powering up your programming productivity 🚀.

Get more articles like this straight to your inbox.

[Let’s grow together 🌱](https://evergrowingdev.substack.com/)

And stay in touch on **𝕏** [@evergrowingdev](https://twitter.com/intent/follow?screen_name=evergrowingdev)

---

![Dev Pages](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/h1wes8tue36lankryvq3.png)

And if you're looking for the right tools to build awesome things, check out [Devpages.io](https://devpages.io), **an ultimate hub I built with 100s of developer tools and resources** 🛠