7 Programming Myths that waste your time

Summary

In a reflective and insightful video, Fireship challenges some of the most commonly held beliefs among programmers that often end up being counterproductive. Emphasizing the irrelevance of many 'trendy' technologies in real-world applications, the video touches on the importance of understanding the durability of existing technologies like WordPress and PHP. It discusses how programmers are lured by modern technologies and concepts but often find themselves stuck in redundant cycles. Beyond the shiny allure of modern tech lies the reality that many programming paradigms and practices are just myths that lead to wasted time, whether it's focusing too much on 'clean coding' or believing in the necessity of optimizing for performance prematurely. Fireship's engaging narrative dismantles these myths and highlights the true skills and approaches needed to thrive.

Highlights

• The realization that best practices and trendy technologies often don't serve the end user as much as we think 🤔.
• Critical tech like banking systems still run on 'dinosaur' technologies, proving their lasting power 🦕.
• The crash of early-adopted technologies serves as a cautionary tale for rushing to new tech 📉.
• Programming cults often limit more than liberate; balance is key 🔄.
• Focusing too much on clean code can lead to time wasted on unnecessary complexities ⏳.
• Understanding that 100% test coverage might inflate a sense of security without improving quality 🛡️.
• AI coding tools are a double-edged sword; they're helpful but can lead to complacency if misused ⚔️.

Key Takeaways

• You don't need the latest tech to be relevant; older technologies like PHP and Java are still widely used and valuable 🌐.
• Adopting new technologies too early can backfire; stick with reliable tech until the new ones prove themselves 🚀.
• Beware of programming dogmas; there's no one-size-fits-all in coding methodologies 👨‍💻.
• 'Clean code' principles are helpful, but overly focusing on them can lead to inefficiency 🧼.
• 100% test coverage does not guarantee high code quality; focus on meaningful tests instead 🔍.
• Optimize for performance only when necessary; premature optimization can lead to wasted resources 💨.
• Don’t depend too much on AI for coding; it’s meant to assist, not replace human logic and problem-solving 💡.

Overview

Reflecting on years of coding, the creator points out a common trap programmers fall into, chasing trends and 'best practices' that often prove irrelevant or wasteful. Technologies like PHP and Java, although viewed as outdated by some, still form the backbone of countless applications and industries worldwide. This contradiction stems from a perception that newer equals better, which isn't always the case in the practical world of coding and development.

The video discusses how the excitement and productivity promised by new frameworks and coding philosophies can lead to obsessive behavior, or 'cults.' The narrative challenges the idea that there's only a singular 'right' way to code, warning against extreme adherence to any one philosophy. Fireship uses personal anecdotes to highlight how many programming 'rules' may not be as universally applicable as once thought.

Delving deeper into misconceptions about coding, the video addresses the pitfalls of striving for clean code, excessive test coverage, and premature optimization, all of which can defocus developers from creating what truly matters — functioning and successful software. Additionally, the video provides a critical look at AI tools, urging caution in their use to ensure programmers strengthen, rather than diminish, their problem-solving skills.

Chapters

• 00:00 - 00:30: Introduction to Programming Myths The chapter reflects on the author's midlife realization that a significant portion of their life as a programmer has been spent writing code that was ultimately useless or abandoned. The author questions the value of 'best practices' and 'game-changing' frameworks, noting that what seemed important in programming often did not matter to the end user. This chapter challenges common programming myths and highlights the futility the author felt in chasing productivity illusions.
• 00:30 - 01:00: Debunking Nine Smart Ideas In this chapter, the focus is on debunking nine common misconceptions that many programmers fall prey to. These 'smart ideas' are often traps that waste time and steer programmers away from productivity. The chapter aims to reveal why these ideas are misleading and provides guidance on avoiding them. One key myth discussed is the belief that using the latest technology makes one more relevant. Contrary to popular belief, proficiency in older technologies like WordPress and PHP, which power a significant portion of the web, or Java, which dominates the enterprise sector, can actually enhance employability.
• 01:00 - 01:30: Old Technologies vs. New Technologies The chapter explores the juxtaposition of old and new technologies in the tech world. Traditional technologies like SQL databases and C++ remain prevalent, especially in the real world and job market, where change is slow. Despite the appeal of modern technologies like Nex.js, Kotlin, NoSQL, and Rust, which promise cutting-edge improvements, the text warns against feeling inadequate for not mastering these newer options immediately. It highlights that many critical systems, like banking, still rely on older technologies, such as Cobalt for banking and Java, which powers billions of devices. The chapter advises learning new technologies while appreciating the importance and durability of existing ones in various professional contexts.
• 01:30 - 02:00: The Problem with Programming Dogma The chapter titled 'The Problem with Programming Dogma' discusses the dangers of adhering too strictly to new technological trends without considering the long-term implications. It provides an example of a startup called Fauna, which had developed a promising new database. However, despite its initial appeal, the company eventually failed, leaving early adopters at a disadvantage. The chapter warns against adopting new technology prematurely, suggesting a more pragmatic approach that values stability and longevity over novelty.
• 02:00 - 02:30: Clean Code and its Pitfalls The chapter 'Clean Code and its Pitfalls' discusses the challenges of adhering strictly to programming paradigms such as object-oriented or functional programming. The author reflects on their experience with both approaches, noting that while each has its merits, committing fully to one can be limiting. The chapter highlights that JavaScript, as a multi-paradigm language, offers flexibility to balance different coding styles. The resurgence of functional programming in web development around 2018 is also mentioned as context to the ongoing debate about the best programming practices.
• 02:30 - 03:00: Test Coverage and its Misconceptions This chapter discusses the evolution of the author's coding style, initially swayed by strict functional programming paradigms that deemed using classes as unfavorable, even comparing it to being as extreme as 'literally Hitler'. Over time, the author recognized the value of integrating classes, combining lessons from both functional and object-oriented programming. Additionally, the chapter touches on another common coding 'trap' - the pursuit of 'clean code' as popularized by Uncle Bob Martin's book. While the book offers valuable advice for agile software craftsmanship, the author implies there's a balance to be struck in practical application.
• 03:00 - 03:30: Performance Optimization Myths The chapter titled 'Performance Optimization Myths' delves into common coding advice, such as writing small functions, using consistent formatting, and adhering to the DRY (Don't Repeat Yourself) principle. However, it highlights the potential downside of over-application of these principles, where one might focus too much on keeping code clean, leading to excessive refactoring and unnecessary layers of abstraction. The chapter suggests a more balanced approach, which could be summarized by the alternate acronym RUG (Repeat Until Good), acknowledging that some code duplication might be acceptable if it leads to productive and efficient coding.
• 03:30 - 04:00: The AI Programmer Replacement Myth The chapter explores the misconceptions around AI replacing programmers, specifically focusing on the fallacies associated with test coverage as a measure of code protection. It highlights the importance of understanding that while tools like code coverage can offer insights, they are not definitive indicators of code quality. The text discusses the inefficiencies of striving for 100% test coverage and suggests that it can often lead to wasted efforts, as high coverage does not necessarily equate to high-quality code.
• 04:00 - 04:30: Importance of a Solid Problem-Solving Foundation The chapter titled 'Importance of a Solid Problem-Solving Foundation' addresses several misconceptions in software development, particularly concerning test coverage and performance optimization. It argues that focusing solely on test coverage can lead developers to write ineffective tests that do not necessarily identify actual bugs, thereby creating a false sense of security and potentially slowing down the CI builds, which in turn increases costs. The emphasis should be on the quality of tests rather than the quantity. Similarly, the chapter debunks the myth that performance should always be a primary concern; excessively focusing on benchmarking and optimizing code, particularly when it doesn't run at a scale that necessitates such optimizations, is considered a waste of time. The chapter suggests prioritizing other aspects of development that offer more significant long-term benefits.
• 04:30 - 05:00: Brilliant as a Resource for Learning The chapter discusses the common misconceptions in software development, emphasizing the importance of ensuring code correctness before optimizing for performance. It advises against prematurely scaling cloud infrastructure unnecessarily. The author shares a personal realization that a simple VPS is sufficient for a small user base, contrary to the perceived need for a complex serverless architecture. Finally, the chapter addresses the myth that AI will soon replace all programmers, acknowledging the role of AI tools while implying their current limitations.

7 Programming Myths that waste your time Transcription

• 00:00 - 00:30 Recently, I unlocked a new achievement in life, a midlife crisis when I came to the realization that I've spent most of my adult life writing code. And most of that code is total garbage. It's code that never saw the light of a production server and was either abandoned, refactored, or left to rot in the graveyard of GitHub. As I reflected upon this further, I realized that many of the best practices, the hot game-changing frameworks, and the perfect folder structures didn't actually matter to the end user. I wasted countless hours chasing programming dragons that made me feel more productive but ultimately led
• 00:30 - 01:00 nowhere. In today's video, we'll debunk nine smart ideas that waste your time as a programmer. And for each myth, we'll look at how it lures you in, why it's actually a trap, and most importantly, how to not do the things that I have done. Now, one of the main goals of this channel is to show you the latest tech you need to use to be relevant. But it's actually a myth that you need to use the latest tech to be relevant. In fact, you might even become more hirable by focusing on old dinosaur technologies like WordPress and PHP still runs most of the web applications out there. Java runs most of the enterprise world. Most
• 01:00 - 01:30 databases are SQL based and C++ runs most of the low-level systems. However, there are shiny new replacements for tech like this, including Nex.js, Cotlin, NoSQL, and Rust. And the lure is a massive feeling of FOMO if you're not mastering the bleeding edge of these so-called superior technologies. To be clear, I'm not discouraging you from learning these. They're awesome, but it's important to understand that most of the real world, where the jobs exist, are not going to change their dinosaur tech stacks anytime soon. The critical banking systems still run on Cobalt, and Java will still be powering 3 billion
• 01:30 - 02:00 devices long after everybody watching this is dead. Most CTOs are smart enough to know that if it ain't broke, don't fix it. Here's a real life example. A few years ago, engineers from Twitter released a hot new database called Fauna. It was a pretty solid product, and I even made a video about it. But the technology was proprietary, VC funded, and like most startups, the business failed recently. They have no choice but to shut down their servers. And if you were an early adopter, you're now screwed and would have been much better off with a boring SQL database. Adopting tech too early is one thing,
• 02:00 - 02:30 but adhering to programming dogma can waste even more time. The problem with programming is that there are many different ways to solve the same problem, but some people out there believe that there's only one true way to write code. Some common cults out there include the object-oriented purists and the functional programming extremists. I've been a member of both cults and have learned a lot from them, but dedicating your entire life to just one of them is a waste of time. I mostly code in JavaScript, which is a multiaradigm language that can satisfy all of these cults. In 2018, functional programming was having a renaissance in web development. But back then, if you
• 02:30 - 03:00 use classes in your code, you were literally Hitler. And I found myself bending over backwards to try to do everything in the most functional way possible. no mutable state and higher order functions everywhere. But a few years later, after the spell wore off, I eventually realized that classes can be pretty useful. And my code today often includes a combination of things I've learned from both of these cults. But another time waster to watch out for is clean code, which comes from a legendary book written by Uncle Bob Martin, known as the handbook for agile software craftsmanship. Most of the advice in this book is great. Use meaningful
• 03:00 - 03:30 names, write small functions, use consistent formatting, and so on. But some of the advice is a little more nuanced, like the dry principle of don't repeat yourself, which means you shouldn't duplicate or write the same code over and over again. And on the surface, that seems like a good idea. But also, when you try too hard to keep things clean, you might end up with an endless layer of wrappers, interfaces, and pointless indirection. It's paralysis by analysis, and you end up spending more time refactoring than building actual features that people want. I think a better acronym would be rug, repeat until good. duplicate code
• 03:30 - 04:00 at first and then pull it into a single abstraction after the repetition becomes painful. Clean code also recommends test-driven development and testing can be extremely valuable, but it's a myth that 100% test coverage means that your code is well protected. Your boss, who has no programming experience, is likely a big fan of code coverage tooling that will show how much of your source code is executed when a test suite is run. It's interesting, but optimizing for 100% coverage is often a huge waste of time and can often be misleading because high coverage does not equal high
• 04:00 - 04:30 quality. Optimizing for coverage encourages developers to write pointless tests that just touch lines and not catch real bugs. And even worse than wasting time, it provides a full sense of security. And then on top of that, it makes your CI builds even slower, which is going to cost you more money. When it comes to test coverage, it's quality, not quantity that matters. But one thing that truly must matter is performance. Well, actually, it's a myth that you should always optimize for performance. Yet another time waster is benchmarking and optimizing code that just doesn't run at the scale to justify those optimizations. It's far more important
• 04:30 - 05:00 to make sure that your code is correct and then only optimize for performance when it becomes painfully obvious that your code sucks in production. On a similar note, you also don't need to optimize your cloud infrastructure like you're about to scale like Facebook. Like I used to think that I needed this complex serverless micros service architecture with global sharding and edge caching, but it turns out that one small VPS is perfectly fine for my five users. And then finally, that brings us to the elephant in the room, the myth that AI is about to replace all programmers soon. There are some awesome AI codew writing tools out there, but
• 05:00 - 05:30 it's becoming more and more clear that many programmers are now wasting a bunch of time relying too much on AI. For example, Claude Sonnet 3.7 is really good at writing code, but it's also notoriously verbose. You might ask it to build a simple website and it'll just randomly engineer some new JavaScript framework from scratch. And because you forgot how to write code, you'll just approve it and move on with your life. AI programming tools are both the greatest productivity booster I've ever seen in my life, but when used improperly, they can also be the biggest time waster. The key to success is to have a solid foundation in problem
• 05:30 - 06:00 solving. And you can start building that foundation for free today thanks to this video sponsor, Brilliant. A hard truth is that code is useless if you don't understand the math and computer science behind it. Brilliant helps you learn these concepts quickly by providing short, fun, interactive lessons, which is a method proven to be six times more effective than watching video lectures. But most importantly, you'll build critical thinking skills through problem solving, not memorizing. Before you try to jump into Vibe Coding, I'd highly recommend taking their thinking and code course to build a timeless problemolving
• 06:00 - 06:30 foundation where you'll learn how to actually think like a programmer. Try everything Brilliant has to offer for a free for 30 days by visiting brilliant.org/fireship org/fireship or scan the QR code on screen and get 20% off an annual premium subscription.