There's a lot of advice out there for new software engineers, but lots of it isn't true.
For example, some people say that good software engineers don't need to use Google- myth! Or that you have to remember how to code everything without help – myth! Some even say the only way to get a coding job is by doing extra projects on your own – myth!
In this article, we'll talk about 9 more myths about software engineering that aren't true and are just wasting your time.
Myth 1: Intensity Over Consistency
Some people say to succeed in software engineering, you need to work super hard in short bursts. This is called 'intensity'. It's like trying to learn a new programming language in one weekend. You sit down, and just power through an entire 20+ hour long course. But, I believe there's a better way: 'consistency'.
This means working a little bit every day instead of all at once which avoids burnout. Think of it like a race: instead of running super fast and then stopping, it's better to jog at a steady pace. The best way to keep consistent is to have a schedule with breaks so you don't get over tired. Working steadily is better for long-term success and happiness in software engineering.
Myth 2: You Can Learn Everything
Software engineering is huge and always changing. It's impossible to learn everything in it. A better approach is to focus on becoming really good at a few specific areas. At the same time, you should try to have a general idea about other parts of the field.
This way, you're well-rounded, but you're also an expert in what matters most to you.
This is what we call a generalist.
Remember, learning within software engineering never really stops. There's always something new around the corner. However, it's just as important to realize that nobody can know everything and that’s okay.
This balance between constant learning and understanding your own boundaries is what makes a great software engineer.
Myth 3: Hustle Culture is Bad
Some say working too hard is bad. That's partly true, but you shouldn't completely ignore hard work. It's about balance – work hard, but also know when to rest. This way, you can be successful without burning out.
At the end of the day it's all about embracing a healthy way of working. You should be dedicated and eager to learn, but you also need to know when to take a step back and take a break. That way, you can be successful without giving up.
Myth 4: You Need a Ton of Time to Learn Coding
Some think you need to spend all your time coding. It's true, coding does need time and hard work. But, it's not like you have to give up everything else in your life. You can learn a lot if you have good learning materials, and a solid plan for when and how you'll study.
It's not about how many hours you put in, but how you use them.
The most important thing is to practice regularly and stay focused during that time. If you can do that, you don't need to spend every waking moment on coding. You'll be surprised by how much progress you can make even with a balanced schedule.
Myth 5: Reading Books is a Waste of Time
In today's fast-paced world, where short tutorials and videos are everywhere, it might feel like reading books is old-fashioned. But that's not true. Books provide a level of detail and a complete view of a topic that you often can't typically find in quick online sources. Books give you a thorough understanding that's hard to match.
Even though we live in an age of instant information, books haven't lost their value. They are incredibly useful for deep and comprehensive learning. So, while it's great to have quick resources at your fingertips, don't underestimate the power of a good book to enhance your knowledge
Myth 6: The More Code, the Better
There's a common myth that says the best code is the code that has a lot of lines. But this isn't true. Good coding isn't about writing a lot. It's about writing code that works well, is easy to understand, and can be easily changed if needed. You should aim to write code that's clear and to the point.
So, don't focus on how much you're writing. Instead, concentrate on making your code as efficient and readable as possible. The quality of your code is much more important than the quantity. A well-written, concise piece of code is always better than a long, complicated one.
Myth 7: Adding More Programmers Speeds Up Development
There's a popular saying that goes, 'nine women can't make a baby in one month.' This is particularly relevant in the world of software development. Many people think that if a project is falling behind, simply adding more programmers will fix the problem and speed things up. However, this isn't necessarily true. Software development involves much more than just coding. It requires careful planning, effective coordination among team members, and thorough testing.
When you add more people to a project that's already late, it can sometimes make things even slower. This is because more programmers mean more communication is needed, which can be time-consuming. Everyone needs to understand their role and how it fits into the larger project, and this coordination takes effort and time. Additionally, with a larger team, the project's complexity increases. It becomes harder to manage all the different parts and ensure that they all work together seamlessly.
So, while it might seem counterintuitive, adding more programmers to a delayed project can actually lead to more delays.
Myth 8: Good Code Doesn’t Need Documentation
There's a misconception that if code is written well, it doesn't need any documentation. Now this is true to an extent. This idea stems from the belief that good code should be self-explanatory. However, even the most expertly written code cannot explain infrastructure, CI/CD and overall architecture. This is where documentation has a huge place, explaining the overall application.
Moreover, when it comes to scaling or modifying software, documentation provides invaluable context and understanding that the code alone might not convey. It explains the broader architecture, the purpose of various components, and how they interact. This level of detail is especially important when new team members join a project or when handovers occur.
Myth 9: Software Development is Just About Writing Code
Software development isn't just coding. It's also about understanding what the software should do, planning its structure, testing it, deploying it for users, and maintaining it. Software developers are problem-solvers and need skills beyond just coding.
Good luck on your coding journey!
Cheers friend,
Eric
Great points, Eric.
I love that you mentioned it's not only about writing code. No matter the organization size, unless you're working alone from a bunker and have 0 users, you'll need those soft skills at some point!
Bonus Myth 10: Vim makes you a better programmer!
Well, partially. Vim lets you learn tools that always existed, but they got integrated into IDEs, and you don't know they were a thing in the first place—thinking about language servers or debugging protocols.
Ultimately, the tool you're the most comfortable using doesn't have a replacement. Use what you know the best!
All valid points and I completely resonate with them. In the world of software, less can often be more.
I've also covered little more in depth on this point in my latest newsletter article also - https://mindfulmatrix.substack.com/p/beauty-in-simplicity