How to Learn as a Developer

Being a software developer is enjoyable and feels like having a superpower, allowing us to construct things through computers by writing and reading code. We are fortunate to have one of the best jobs in the world, in my opinion. However, like any other profession, it has its challenges.

It often seems like a new front-end framework or technology emerges every week, which can be overwhelming. This may lead us to feel the need to catch up constantly and learn what we've missed, fostering a sense of inadequacy if we don't know everything.

Nonetheless, it's crucial to maintain continuous growth as a developer. Learning how to acquire new skills efficiently and discerning what to focus on, while filtering out distractions, is a key skill for achieving success in this field.

In this post, I aim to explore considerations for learning new things, discuss strategies for efficient learning, and emphasize the importance of maintaining a positive mindset without succumbing to stress over not knowing everything.

We Don't Need to Know Everything

First and foremost, there's no requirement for us to be familiar with every new thing that emerges. It's beneficial to possess a strong foundational skill set and build upon that. No developer has a comprehensive knowledge of every technology, spanning from back-end to front-end—it's simply impractical.

While some developers may boast a broad skill set, they might lack specific expertise in certain areas. On the other hand, there are developers who focus on fewer technologies but specialize deeply in a particular domain.

It's crucial to identify our preferences and interests, distinguishing between passing trends and enduring technologies. Frequently, newly introduced technologies are heavily promoted, only to be forgotten over time.

As a junior developer, there's often a temptation to dive into every exciting new technology. However, with experience, we develop a sense of discernment, recognizing when something is merely hyped at the moment. It becomes prudent to wait a bit before fully embracing or learning the ins and outs of the latest trend.

The T-Shaped Developer Approach

A practical model to consider is becoming a "T-shaped developer." This means developing deep expertise in one area (the vertical bar of the T) while maintaining a broader but less deep understanding across multiple related domains (the horizontal bar). This approach balances specialization with versatility.

For example, you might specialize deeply in React frontend development while maintaining working knowledge of Node.js, databases, UX principles, and basic DevOps. This approach allows you to be highly valuable in your specialty while still being able to collaborate effectively across different areas of development.

Tutorials vs. Personal Projects

It's easy to fall into the trap of "tutorial hell," where we endlessly watch tutorials and replicate what instructors build, limiting our creativity and independence in project development.

While tutorials have their place, it's essential not to get stuck in this cycle, continuously consuming without applying the knowledge to our own projects.

How to Maximize Tutorial Benefits:

One approach is to modify the tutorial application. For instance, if we're learning to build an e-shop for clothing, we can create our own twist by developing an e-shopping application with a completely different UI that focuses on selling food. This way, we're not just mimicking the teacher's work; we're absorbing essential information and techniques and applying them to create something unique.

Maintaining a personal project, unrelated to our daily work, is invaluable. Such a project serves as a platform for experimentation and problem-solving, fostering growth and continual learning as developers.

Breaking Free from Tutorial Dependency

To truly break free from tutorial dependency, consider these additional strategies:

The 80/20 Rule: Complete about 80% of a tutorial, then finish the last 20% on your own. This forces you to apply what you've learned without step-by-step guidance.
Deliberate Challenge: After completing a tutorial, set yourself a related but different challenge that requires applying the same concepts in a new context.
Teach What You've Learned: Try explaining the tutorial concepts to someone else or write a blog post about it. Teaching solidifies understanding and reveals gaps in knowledge.
Code Review Your Tutorial Work: Once you've completed a tutorial project, review your code as if you were critiquing someone else's pull request. Look for improvements, alternative approaches, and opportunities to refactor.

Seasoned Developers and Tech Trends

Experienced developers possess a practical insight into distinguishing genuine technology trends from mere hype. There are specific reasons why seasoned developers exercise caution before hastily adopting every new technology:

Practical Experience: Having witnessed trends come and go, experienced developers, who were once junior enthusiasts themselves, learn from their past mistakes. This accumulated experience enables them to compare new technologies with existing solutions, evaluating whether they genuinely offer improvements or are simply iterations of the past.
Understanding Core Principles: Years of coding and problem-solving contribute to a profound understanding of fundamental programming principles. This knowledge allows experienced developers to discern the practical benefits of new technologies and make informed decisions about their relevance.
Time Efficiency: Learning and implementing a new technology can be time-consuming. Seasoned developers prioritize efficiency and avoid investing time in technologies that may not address their specific challenges. Instead, they may choose to investigate and draw conclusions based on the practical merits of the new technology.

The Strategic Technology Adoption Framework

One approach seasoned developers often use is a structured framework for evaluating new technologies:

Problem Assessment: What specific problem does this new technology solve?
Comparison: How does it compare to existing solutions I already know?
Community Evaluation: Is there a growing, supportive community around it?
Longevity Prediction: Is this likely to be around in 2-3 years?
Learning Curve Analysis: What's the investment-to-benefit ratio for learning this?

Using this framework helps make more objective decisions about where to invest your learning time and energy.

Learning from Code Exploration

A key practice in my learning process involves regularly delving into others' code to gain insights into diverse problem-solving approaches and construction methods. At work, I often review pull requests to observe different problem-solving strategies employed by my colleagues. This not only provides inspiration but also offers varied perspectives on what constitutes readable and high-quality code.

When incorporating open-source third-party libraries, I make it a habit to examine the codebase. This allows me to understand the author's coding style and, at times, motivates me to explore the possibility of creating my own version. Reading through code, whether from colleagues or open-source projects, serves as an effective technique to draw inspiration and discover novel problem-solving methods.

Working on coding challenges, such as those on LeetCode, can be valuable practice. Whether we successfully solve a problem or encounter difficulties, reviewing solutions from other developers is an excellent method for learning and gaining inspiration on different approaches to problem-solving.

Effective Code Reading Techniques

To make the most of code exploration:

Start with the Entry Points: Begin by understanding how the application or library initializes and flows.
Focus on One Feature: Don't try to understand everything at once. Pick a specific feature and trace its implementation.
Use Debugging Tools: Set breakpoints and step through code execution to see how it works in real-time.
Map Relationships: Draw diagrams of how different components interact.
Reimplement Key Parts: Try to rewrite small sections in your own style to deeply understand the logic.

All About Building Good Habits

Creating positive habits is crucial. Our focus should revolve around establishing an environment conducive to learning and personal growth. While acknowledging the challenge, our goal is to consistently surround ourselves with optimal conditions and effective tools. This approach ensures that we maximize the use of our time and consistently strive for improvement.

Creating a Sustainable Learning Routine

Developing a sustainable learning routine is essential for long-term growth. Consider these approaches:

Time Blocking: Allocate specific time blocks for learning activities. Even 30 minutes of focused learning daily is more effective than irregular multi-hour sessions.
Learning Environment: Create a designated physical or digital space optimized for learning. This might include a distraction-free workspace, bookmarked resource libraries, or development environments set up specifically for experimentation.
Spaced Repetition: Instead of cramming, spread out your learning over time. Tools like Anki can help with retaining technical concepts through flashcards and spaced repetition.
Progress Tracking: Maintain a learning journal or use tools like GitHub contributions to visualize your progress. Seeing your growth over time provides motivation to continue.
Accountability Systems: Find a learning partner, join a study group, or participate in coding challenges with others to maintain accountability.

Understand and Not Memorize

When delving into new concepts, prioritize comprehension over memorization. Avoid rote learning and instead focus on understanding the intricacies of the code or technology. Developing a robust mental model contributes to easier learning, providing clarity on where a concept fits and its applications.

Consider the scenario of grappling with a bubble-sort algorithm. While numerous implementations exist, it's counterproductive to simply copy solutions without understanding the underlying logic. Instead, invest time in comprehending the solution by scrutinizing each line's purpose.

Mere imitation offers no substantial benefit. Dedicate efforts to unraveling the logic behind the code. Enhance your understanding by actively engaging with the material. Take a pen and paper, visualize the list of numbers, and sketch how the list evolves with each iteration. This hands-on approach fosters a deeper understanding of the subject matter.

Mental Models for Complex Concepts

For truly complex topics, developing solid mental models is crucial:

Analogies and Metaphors: Relate new concepts to familiar ones. For example, understanding React's component lifecycle by comparing it to a human's life stages.
Visual Representations: Create diagrams or flowcharts to visualize abstract concepts. Tools like Excalidraw or Mermaid can help map out complex systems.
Explain in Simple Language: If you can't explain a concept in simple terms, you don't fully understand it. Practice the "ELI5" (Explain Like I'm 5) technique.
Connect to Existing Knowledge: Always try to connect new information to concepts you already understand, building a web of related knowledge rather than isolated facts.

Sharing Technical Knowledge

A valuable practice you might be familiar with is sharing your knowledge with others. Teaching is a powerful method to reinforce our understanding and assess our mastery of a subject. If we struggle to convey a topic to someone else, it serves as an indication that we need to revisit and deepen our understanding.

Various approaches can be employed for this purpose. One method involves maintaining a private working journal where we document and articulate the tasks we are engaged in or have completed. Another effective strategy is to create a blog, offering a platform to articulate and share knowledge. By writing about topics we are passionate about and explaining concepts in our own words, we not only solidify our understanding but also contribute to the collective knowledge pool.

Knowledge Sharing Avenues for Developers

Beyond personal blogs, consider these platforms for sharing your knowledge:

Code Reviews: Offer detailed, constructive feedback that explains not just what to change but why.
Internal Tech Talks: Volunteer to present new technologies or techniques to your team.
Open Source Contributions: Contribute to documentation or code examples in open source projects.
Stack Overflow: Answering questions forces you to articulate your understanding clearly.
Mentoring Junior Developers: One-on-one mentoring creates a feedback loop that benefits both parties.

Embrace Mistakes for Learning

A crucial aspect of learning new things is the willingness to make mistakes. Fear of making errors should not hinder our progress. It's in the process of recognizing and correcting mistakes that concepts truly stick in our minds. Experimenting with code without fear is a valuable approach.

Avoiding mistakes due to fear keeps us in the comfort zone, a place that hinders progress. Stepping out of this zone is essential for growth and advancing our skills.

Creating Safe Spaces for Failure

To embrace mistakes productively:

Sandbox Projects: Create low-stakes projects specifically for experimentation where breaking things doesn't matter.
Version Control: Make liberal use of branches and commits so you can always return to a working state.
Test-Driven Development: Writing tests first provides a safety net for experimentation.
Post-Mortems: When things go wrong, conduct a personal post-mortem to extract learning, not to assign blame.
Celebrate Instructive Failures: Reframe failures as valuable learning experiences rather than setbacks.

Maintaining a Positive Mindset

It's crucial not to be too harsh on yourself because everyone faces challenges. If mastering programming were effortless, everyone would grasp it instantly. Learning, especially when tackling something new, can be challenging. Treat yourself with kindness and allow for breaks, even extended ones like a few days. Recalling the information becomes easier each time we revisit what we're trying to learn.

A positive mindset is a vital factor in the learning process, aiding in better retention of new information.

Combating Imposter Syndrome

Many developers, regardless of experience level, face imposter syndrome. Combat this by:

Documenting Achievements: Keep a "victory log" of problems solved and concepts mastered.
Normalizing Not Knowing: Understand that even senior developers regularly search for solutions and reference documentation.
Focusing on Growth: Compare yourself to your past self, not to others whose journey and circumstances differ.
Community Connection: Join communities where developers openly discuss challenges and learning journeys.
Practicing Self-Compassion: Talk to yourself as you would to a friend or colleague learning something new.

Balancing Depth and Breadth in Learning

One of the ongoing challenges for developers is determining how deeply to learn various technologies. Should you become an expert in a narrow domain or develop working knowledge across many areas?

The answer often depends on your career goals and the demands of your current role, but most successful developers find value in a balanced approach:

Core Competencies: Identify 1-3 core technologies or domains where you want to develop deep expertise. These should align with your interests and career trajectory.
Adjacent Skills: Develop working knowledge in technologies that complement your core competencies. For a frontend developer, this might include UX design principles or backend API concepts.
Awareness Level: Maintain awareness of broader industry trends and emerging technologies without necessarily investing time in learning them deeply.
Regular Assessment: Periodically review and adjust your learning priorities based on industry direction and personal interests.

This balanced approach ensures you have marketable depth while maintaining enough breadth to adapt to changes in the technical landscape.

Conclusion

In the realm of software development, continuous learning is an inherent aspect of our roles. While it adds an enjoyable dimension to our work, there are moments when grappling with new technologies can be challenging.

Developing effective strategies to facilitate the learning process is crucial. Learning how to discern between technologies that are currently essential or those that don't align with our current goals is a valuable skill. This skill not only streamlines our learning journey but also enables us to focus on technologies that are pertinent and align with our interests at a given moment.

Remember that learning is not a linear process—progress often comes in bursts followed by plateaus. The joy of software development lies not just in building things, but in the continuous growth and discovery along the way. By embracing a thoughtful, strategic approach to learning, we can enjoy the journey while building valuable skills that will serve us throughout our careers.

As software developers, honing this skill contributes significantly to our professional growth and efficiency, allowing us to navigate the ever-changing technological landscape with confidence and purpose.