How to Find Your Programming Guru

In the pursuit of the elegant art of calligraphy, I found myself enrolled in a class led by a revered master. I arrived eager and full of expectation, notebook in hand, ready to soak up her wisdom. However, to my surprise, she didn’t instruct, nor did she ask anything of me. Instead, she merely drew.

For the first few lessons, I watched her silently, a knot of disappointment growing in my stomach. ‘When will I learn? When will she teach me something?’ I found myself thinking. I was waiting for a step-by-step guide, a detailed tutorial on how to create the beautiful strokes and intricate patterns that she seemed to produce effortlessly. But such instructions never came.

This continued for three lessons, each marked by her silent drawing and my silent frustration. Then, during the fourth lesson, something shifted. Out of boredom more than anything else, I began to study her actions more closely. I observed her grinding the ink block with a deliberate yet gentle touch. I watched as she carefully added water to the inkstone, maintaining a balance between too much and too little. I noted the way she dipped her brush into the ink, ensuring it was evenly coated but not drenched.

In those quiet moments, I was learning more than I realized. I was picking up on the subtleties of her art, the tiny nuances that made each stroke on the paper a testament to mastery. I was learning about the patience, the meticulous preparation, and the profound respect for the tools and materials that underpinned the practice of calligraphy.

Acknowledging this shift in my perspective, my mentor finally approached me during that fourth lesson. Without a word, she handed me a brush. It was her way of recognizing my readiness, a silent confirmation that my real education in calligraphy had begun.

In retrospect, those first three lessons were not devoid of instruction as I had initially thought. Instead, they were a profound lesson in observation, patience, and respect for the art form. My mentor was indeed teaching, but not in the conventional sense that I had expected. This experience was a powerful reminder that learning often takes forms we might not anticipate and that mentors often guide us in ways we might not immediately understand.

I’ve be writing a lot about learning, especially programming and tutorials hold an invaluable position. They serve as the bridge between the learner and the vast sea of knowledge, breaking down complex programming concepts into digestible chunks. Tutorials, being an amalgamation of the wisdom of teachers, insights from senior programmers, and the experience of many gurus, provide a structured and practical path for novices and intermediates alike.

The Value of a Mentor

Before diving into the ‘how,’ let’s start by understanding the ‘why.’ Why is a mentor so important?

They can offer advice, suggest strategies, provide feedback, and help you avoid common pitfalls.

Additionally, a mentor can give you a boost when you’re feeling down, cheer you on when you’re doing well, and help you stay strong through life’s ups and downs. They’re someone you can lean on when you’re unsure, celebrate with when things go right, and rely on to help you stay balanced through all the twists and turns of your personal and work life.

The Quest for the Right Mentor

Choosing an ideal mentor is a real struggle, similar to choosing an ideal life mate. You require a person whose qualifications and passions align with your own. Their mentoring style should fit your preferred learning methods and their beliefs ought to line up with your own. But as important is the mentor’s willingness and availability to devote time and energy to your development. The most outstanding mentor in the world won’t be of much use if they are too busy to mentor you, after all. It’s akin to dating in that you’re obviously seeking compatibility and availability…

Unfortunately, these factors and the practical realities of life mean that finding the right mentor can be challenging. Not everyone you admire or wish to learn from will have the time, interest, or ability to commit to a traditional mentoring relationship.

The Digital Age: A Treasure Trove of Mentors

Luckily, we live in an era where physical distance and limited personal connections no longer restrict our access to potential mentors. The digital age has transformed the way we acquire knowledge. Today, anyone can learn anything from anyone, anywhere, at any time.

Many learning platforms like Udemy, Udacity, Frontend Masters and Pluralsight (to name a few) offer a wealth of information. Industry leaders, subject matter experts, and accomplished professionals share their knowledge, experiences, and insights on these platforms. This opens up a world of possibilities for those seeking mentors.

Making Anyone Your Mentor

The secret to turning anyone into your mentor is in how you make use of their resources. If you discover someone whose ideas spark something in you, delve into their work. Consume their videos, pour over their books, follow their podcasts, take their online courses, or peruse their blogs. As you soak up their knowledge, you’re essentially being guided by them. An amazing educator I’ve been following is ThePrimeagen. Trust me, you’ll want to catch up to his learning express — it’s blazingly fast!

You don’t need personal, one on one interaction to learn from someone. You can acquire knowledge, adopt successful strategies, and learn from the failures of others without having a direct relationship with them. If you are disciplined, focused, and motivated, you can glean meaningful and practical insights from these indirect mentoring relationships.

The Advantage of Multiple Mentors

Another benefit of the digital age is that it allows you to have multiple mentors. Different mentors can offer different perspectives and advice, thus enriching your understanding of your field. You can have a mentor for technical skills, another for leadership skills, and yet another for work life balance. This multi mentor approach can offer a more well-rounded, holistic approach to your personal and professional development.

The idea of mentorship has been completely transformed by the digital era, notwithstanding the significance of conventional mentoring connections. It gives you the power to direct your learning process, draw on the knowledge of world-renowned experts, and work with a variety of mentors who can all be catered to your unique needs and interests. When it comes to seeking and taking advice from mentors, the world really is your oyster. It’s like creating your own custom guru

Creating Your Own Gurus

Using tutorials or instructional films as a jumping off point for self initiated learning is a practical way to make anybody become your mentor, especially when acquiring technical skills online. Here is how to go about it: Consider the following scenario: You are following a lesson, and the teacher says, “Now, we are going to create a navbar on the website,” or “We’ll now set up a route on our server.” Pause the video and follow along actively rather than passively. Consider doing this as your task and go it alone.

By doing this, you are not just copying what the instructor does, but actively learning and the concepts. This exercise forces you to think critically, solve problems, and learn from your mistakes. It may be challenging and time consuming, but the rewards are well worth it. When you eventually hit play again, you’ll have a far deeper understanding of the topic at hand, and you’ll be better able to absorb the nuances and finer details of the instructor’s approach.

This method turns the teacher from just someone who gives out info into a mentor who sets jobs, starts your thinking, and helps guide your learning trip. It’s like making a “digital guide” who can lead you, even if they aren’t chatting with you directly. This powerful way can make your learning trip more hands-on, fun, and rewarding.

Let’s imagine you’re taking JavaScript course and you’re following along with a tutorial about creating a function to add two numbers. You paused the video before the solution was provided and attempted to solve the problem yourself. Your solution was:

function add(x, y) {
  let sum = x + y;
  return sum;
}

Then you continued the video and watched the solution of the instructor:

function addNumbers(firstNumber, secondNumber) {
  // Validate input types
  if (typeof firstNumber !== 'number' || typeof secondNumber !== 'number') {
  throw new Error('Both inputs must be numbers');
  }
  // Calculate the sum
  let sumOfNumbers = firstNumber + secondNumber;
  // Return the result
  return sumOfNumbers;
}

When you look at both ways to solve the problem, you notice they both do the same thing: they add two numbers. But, how they do it is a bit different. The teacher’s way checks the type of numbers before doing the addition, and the names used are very descriptive. You might think, “My solution is not even close…”

Don’t worry, getting things wrong is part of the journey. Making mistakes is one of the best ways to learn. This step of comparing your work to the teacher is like giving yourself a progress report. You realize that while both ways are correct and do the same job, there are different paths to reach the same end. As you keep trying you’ll get better and better at JavaScript.

Alright, let’s chat about a really cool way to check how you’re doing. But before that, let’s talk about one of my favorite artists, Pablo Picasso.

Picasso loved playing around with his art. He’d take an animal sketch and start stripping it down. He wanted to see how simple he could make it, using just a few lines, but still make it look like the animal. You gotta check out these incredible drawings below.

Now you’re probably thinking, “What’s this got to do with coding?”

Well, let’s dive into that.

Let’s consider a complex JavaScript function that traverses an object and searches for a specific key value pair, in this case, a key named ‘extension’ and a value ‘jpeg’.

Here’s the complex version:

function searchKeyValue(obj) {
    for (let key in obj) {
        if (typeof obj[key] === 'object' && obj[key] !== null) {
            if (searchKeyValue(obj[key])) {
                return true;
            }
        } else {
            if (key === 'extension' && obj[key] === 'jpeg') {
                console.log('found key: ', obj[key])
                return true;
            }
        }
    }
    console.log('did not found key!')
    return false;
}
const testObj = {
    id: 1,
    image: {
        name: 'testImage',
        extension: 'jpeg'
    }
}
console.log(searchKeyValue(testObj)); // Should print 'found key: jpeg' and return true

Now, let’s strip this function down to a more minimal form using recursion and some modern JavaScript features, here are the implementations:

function hasKeyAndValue(obj, key, value) {
    return obj[key] === value;
}
function isObject(value) {
    return value && typeof value === 'object';
}
function findInObj(obj, key, value) {
    return Object.entries(obj).some(([k, v]) =>
        hasKeyAndValue({ [k]: v }, key, value) || (isObject(v) && findInObj(v, key, value))
    );
}
const testObj = {
    id: 1,
    image: {
        name: 'testImage',
        extension: 'jpeg'
    }
}
console.log(findInObj(testObj, 'extension', 'jpeg'));
// Output: true

By dividing the task into three separate functions, we maintain the functionality of the original complex function but enhance its readability and maintainability. Each function now serves a clear, single purpose, it can be reused, making the code easier to understand and modify if necessary. This approach adheres to the principles of clean and modular code, making it a useful practice in programming.

The essence of the findInObj function is to find a specific key-value pair within an object, even if that key-value pair exists in a nested object.

In more abstract terms, the essence of this function can be seen as a combination of three concepts:

• Recursion: The function operates by repeatedly calling itself to delve deeper into nested objects until it either finds a match or exhausts all options.
• Key-Value Pair Matching: The function is built around the concept of finding a specific pair of data — a key and its associated value — within the structure of an object.
• Traversal: The function systematically ‘travels’ through the object, inspecting each key-value pair it encounters.

The simplified version of the function represents these concepts in a more streamlined and efficient manner. Each of the smaller functions encapsulates a single part of this essence: hasKeyAndValue encapsulates key-value pair matching, isObject encapsulates the check necessary for recursion, and findInObj encapsulates the concept of traversal via recursion.

In essence, the function is about searching and pattern matching within the complex structure of a nested object.

So, if you gave this function a go and ended up far from the solution, try to think like Picasso. Did you really get the heart of what you were trying to do? Maybe you made it too simple, and that’s why it didn’t work out? But, if you got close, that’s awesome! You’ve got all the bits and pieces in place. With a little more practice and time, you’ll just keep getting better!

Musicians inspiration

In the music biz, artists often point to other musicians saying, “That’s my jam! They really rocked my world.” Take the Beatles, for instance, they totally had a bromance with Elvis Presley and Buddy Holly. Then there’s Kanye West, who’s into everyone from David Bowie to Jay-Z and even Aphex Twin.

These artists mash up bits and pieces from their musical heroes to create their own special blend of ear candy. It’s like they’re saying, “Hey, my sound might feel a bit familiar, but trust me, it’s got my unique twist!”

Now, as programmers, we’re also doing a funky dance on the work of the coding gods before us. Whether we’re using a programming language, a library, or a framework, we’re totally grooving to the rhythm they set. But unlike rockstars, we coders can be a bit shy about fan-girling over our influences.

Wrapping it all up, the crux of it is that we can and absolutely should draw from many mentors and sources of inspiration. If the Beatles can learn from Elvis, why can’t we learn from multiple JavaScript libraries or Python enthusiasts? My personal coding journey has been like a tour through a massive, eclectic music festival, where I’ve picked up something from every stage.

In the end, it’s all about recognizing that our growth as coders comes not just from formal training or one single mentor, but also from the invisible, online ones, the libraries we use, the code snippets we admire, the forum threads that save us at 2 a.m., and even the bugs that drive us crazy. The key to becoming a proficient coder lies in celebrating all of these influences and leveraging them to enhance our skills.

So, here’s to all the mentors out there, seen and unseen, who play a vital role in shaping our coding symphony. Keep coding, keep learning, and most importantly, keep drawing inspiration from every corner of this vast programming world.

Final Thoughts

In essence, the digital era has ushered in a revolution in mentorship, expanding our access to guidance and wisdom beyond traditional confines. This democratization of learning opens up a treasure trove of resources that can significantly enhance our personal and professional growth. From formal lessons to observing experts, the crux of learning is about soaking up insights from multiple sources. Whether we’re studying calligraphy, learning to code, or pursuing any other form of skill or knowledge, the key lies in being proactive, open, and engaged in our learning journey. As we absorb the insights of mentors around us — both visible and invisible — we keep growing, expanding our horizons, and refining our craft.