What NOT to learn when learning how to code.

It's so easy to waste time.

So easy, in fact, that on average, we spend up to a month (or 26 days) wasting time every year.

Just think about that for a moment. A whole month lost to being idle, unproductive tasks, and aimless scrolling, basically doing nothing. It's a crazy amount of time, right?

Now, here's the thing, learning anything new takes time. And when it comes to learning how to code, there's no exception.

It's a journey that demands dedication, effort, and yes, a significant investment of time. But as usual, there’s a catch - if we don't use that time effectively, and if we don't make the most of it, we might as well be doing nothing.

Now, I know what you're thinking. "Tell me something I don't already know." We're all aware that time is precious, and that it's a finite resource we should cherish and utilise wisely. Plus, I'd like to believe that none of us consciously set out to waste our own time.

But the truth is, when it comes to learning how to code, there are skills, practices, and paths that can lead us astray, devouring our time without offering much in return.

I’m a strong believer in making every moment count. Your time as a budding new programmer is too valuable to be squandered on skills that won't truly propel you forward.

That’s why I’m going to discuss the skills that might seem enticing but ultimately offer little value, the practices that hinder our progress, and the aspects we often overlook in our pursuit of coding excellence.

So let’s not waste any more time, here’s what you need to stop learning:

Outdated or Obsolete Technologies 📆

Remember Floppy Disks?

Don’t worry not many people do and for good reason. They’re so outdated they’ve become obsolete. Alongside many other techie stuff including cassettes, VHS tapes and heck even DVDs at this point!

Just as fashion trends come and go, technologies also have their moment in the spotlight before gracefully stepping aside for newer, more innovative solutions.

Yet, despite this, some new programmers find themselves investing precious time and effort in learning technologies that have faded away.

By focusing on technologies that have little practical application in today's landscape, we risk limiting our opportunities and hindering our progress.

Take, for example, COBOL, a once-prominent language that ruled the mainframe era. While it served its purpose in its heyday, the demand for COBOL developers has significantly dwindled over the years.

Sure, there may be a few legacy systems that still require its expertise and maintenance, but investing substantial time in mastering COBOL today might leave you stranded behind, and far out of touch with the modern programming community.

What are the risks of learning outdated or obsolete technologies?

There are quite a few consequences of not staying up-to-date with current trends and technologies:

1. You risk becoming irrelevant in a fast-paced industry that thrives on innovation.

2. You limit your marketability to employers and restrict your career growth potential.

3. Failing to adapt to emerging trends can result in missed opportunities.

Just as the world embraces new technologies, industries and projects gravitate towards languages and tools that offer greater efficiency, scalability, and security.

By prioritising your learning efforts towards these in-demand skills, you position yourself as a valuable asset, ready to tackle the challenges of the present and future.

Overly Specific or Niche Skills 🔬

They say the best thing to do when starting to learn how to code is to stick to learning one language at a time.

However, you should be mindful to choose that one language or skill carefully. It's easy to be captivated by the thought process of having highly specialised skills. The idea of delving deep into a niche area, and becoming a master of a specific technology or framework, can be enticing for many.

But it’s worth knowing about the potential disadvantages that can happen to those who invest too heavily in skills with limited practical application.

Imagine for example there was a programming language designed explicitly for a specific hardware platform. While it might offer unparalleled performance within its niche, its usefulness outside that context becomes severely limited.

Spending countless hours mastering the intricacies of such a language might seem appealing, but when things change and new platforms emerge, your expertise could become irrelevant.

Similarly, proprietary frameworks exclusive to a particular company or industry can lead to a trap. Yes, they may provide efficiency within their specific domain, but their relevance fades once you step outside those boundaries. Investing significant time in such frameworks risks pigeonholing your skills and inhibiting your ability to adapt to different projects and industries.

What are the benefits of learning less overly niche skills?

By contrast, skills that possess broader applicability and can be easily transferred across projects and industries offer long-term value and flexibility.

For example, proficiency in popular programming languages like Python, Java, or JavaScript equips you with a foundation that spans multiple domains.

These skills open doors to a multitude of opportunities and enable you to collaborate with a diverse range of professionals.

By prioritising skills that can be applied across different projects and industries, you ensure that your expertise remains in demand, and your career options remain open.

The key is to strike a balance between specialisation and versatility.

Inefficient Coding Practices 🐌 

The quest for efficiency is an eternal pursuit when it comes to programming.

As developers, we often strive to write the ‘perfect code’ (whatever that may be), where everything runs smoothly and seamlessly.

Yet, despite this aspiration, many of us find ourselves unknowingly succumbing to the clutches of inefficient coding practices, hindering our productivity, maintainability, and scalability.

Examples of inefficient coding practices

Inefficient coding practices can impede progress, introduce complexity, and make our codebases resemble a web of confusion.

Here are some common offenders:

1. Excessive use of global variables: Over-reliance on global variables leads to code that is tightly coupled and lacks modularity. Making changes becomes a delicate dance, as one misstep can cause an avalanche of unintended consequences.

2. Poor error handling: Without proper error handling, our code becomes brittle and fragile, unable to effectively handle unexpected situations. Robust error handling, on the other hand, equips our code with resilience, enabling it to recover gracefully from unforeseen challenges.

3. Lack of modularity: Code that lacks modularity becomes a like a giant fortress, resistant to change and growth. By embracing modularity, and breaking our code into cohesive, reusable components, we unlock the power of flexibility and scalability.

By adopting best practices from the start for writing clean, efficient, and maintainable code, you can avoid the tangled web of confusion and take advantage of the true power of programming.

Focusing Too Much on Theory 📚

When it comes to learning how to code, theory and practice go hand-in-hand 🤝.

Theoretical knowledge lays the foundation, providing us with the conceptual understanding necessary to understand the fundamentals of coding.

But when theory takes the lead and practice is left in the shadows, we risk neglecting one core thing: real-world application.

It’s like a musician who spends years mastering music theory, yet has never laid their hands on an instrument.

That musician may understand the complexities of musical composition, but without the practical experience of playing an instrument, their skills remain dormant.

Similarly, focusing too much on theory in programming can leave us with a wealth of knowledge but a limited ability to transform that knowledge into tangible outcomes.

Theory should mainly serve as a guide that highlights the path towards understanding. It should teach us fundamental concepts, design patterns, and algorithms.

To bridge the gap between theory and practice, you must actively engage in coding exercises and real-world projects.

By immersing yourself in coding exercises, you can reinforce your understanding of concepts and develop problem-solving abilities. Real-world projects will expose you to the complexities of building software within the constraints of time, resources, and user requirements.

Tips to strike a balance between theory and practice

1. Embrace project-based learning: Seek out opportunities to work on practical projects that align with your interests. Building real-world applications allows you to apply theoretical knowledge in a meaningful context, uncovering the nuances of the development process.

2. Participate in coding challenges: Engage in coding competitions and challenges that push your problem-solving skills to new heights. These exercises sharpen your abilities and expose you to a diverse range of coding scenarios.

3. Contribute to open-source projects: Collaborating on open-source projects exposes you to real-world development practices and allows you to work alongside experienced programmers. It's a valuable opportunity to learn from others and contribute to the wider programming community.

4. Seek feedback and code reviews: Actively seek feedback on your code and participate in code reviews. Constructive criticism helps refine your coding style, encourages best practices, and gives you examples of alternative approaches.

5. Never stop learning: Continuously expand your theoretical knowledge while actively applying it in practice. Stay updated with the latest trends, frameworks, and technologies, and explore how they can be implemented in real-world scenarios.

Conclusion

Remember, each passing moment presents an opportunity. A chance to invest in yourself, your knowledge, and your future.

Your learning time is precious, and how you choose to utilise it will shape your journey as a programmer.

By recognising the risks of investing in outdated technologies and overly specific skills, you can redirect your efforts towards tools and languages that offer long-term value and versatility. Embracing efficient coding practices ensures that your code is not only functional but also maintainable and scalable.

Striking a balance between theory and practice allows you to solidify your understanding and apply your knowledge to real-world projects. Whilst engaging in coding exercises and continuously seeking growth opportunities will propel you towards becoming a well-rounded and productive programmer.

Seize each moment, embrace the challenges, and unlock your full potential as a productive programmer.

Your future awaits, and your time is now - so don’t waste another second.

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 🌱

And stay in touch on 🐦 @evergrowingdev