14 Mistakes Beginning Software Developers Make
Mistake: an error, a goof, a slip-up. When you make a mistake, you’ve done something incorrectly. Mistake has a lot of uses, but they all have to do with doing the wrong thing.
One of the good part of the software development industry is also its bad part - which is the ability for anyone to simply teach themselves these technologies and go on to be a software developer.
Don’t get me wrong though. I am in no way calling out self-taught developers(I am more or less one myself 😉). However the ability to get yourself started without any formal introduction or direct mentorship from anyone creates the problem of developing mistake or bad habits along the way. These mistakes could be so subtle and are most of the times non-fatal but from time to time they start showing up as symptoms in your work as a developer. I have identified 14 of these mistakes and if you’ve discovered any not mentioned here, I would be stoked to hear from you on twitter. Now put on your Sherlock Holmes’ hat and let’s go..
Mistake #1 - Not spending time developing your theoretical knowledge
So many times beginning software developers are all about learning the craze of the moment like the hot trending front-end framework right now or going on Stackoverflow and copying tidbits of code and slapping it right on in their project without pausing for a moment and thinking why it works(the theory).
This is wrong because of the disassociation of context. What I mean by this is, what happens when you are to implement the same thing that just “worked” for you on another project or within another context? You will more often stumble because you really didn’t understand what you were doing, you just fumbled your way through and fumbling won’t always help you. For you to master the art of making quality softwares you must be both practical and theoretical.
Knowing your theories well enough would give you a better handle on the said subject. To put it another way: understanding what something is rather than how to use it goes a longer way in making you a better software developer.
Mistake #2 - Not developing softwares in your mind
I admit this is a little bit esoteric but it is worth mentioning. Not taking the time to develop the skill of being able to think like the computer and executing your bits of code in your mind is another mistake beginning developers make. You should be able to glance at a piece of code you or someone else has written and at a higher level execute it in your mind(not like a computer though 😂). You should be able to reason about the code your are reading(do you still read code?) or writing even before you give it to the computer to execute.
Take the time to reason about your program; why it works or why it doesn’t.
Mistake #3 - Avoiding struggles
Most beginning developers I encounter like to avoid struggles. They would be in a roll when something works but when their editor or the compiler start screaming at them because they have done something wrong, then they have hit a brick wall and they are immediately turned off. The next thing they tend to do is to go on looking for someone to solve the problem for them(looking at you google).
Admittedly you wouldn’t have the answers to every problem you come across but taking the initiative of sitting down with a problem and trying to fix it would slowly imbibe in you a genuinely invaluable skill - debugging
Develop the discipline of staying with a problem by yourself. A problem you resolve yourself will better stick with you than one you find by googling and just copy and pasting. Don’t be so quick to avoid the struggle! Things that you work for and strive to get will stick to your memory more. As you struggle you will get frustrated(it is what is!). However find a way to deal with it(take a walk or look at cute cat photos if you will).
Mistake #4 - Not exploring
As beginners(myself included), we tend not to explore. When something work for us we just stick to that way of doing things. Once in a while, throw on your investigator hat and explore stuffs. Try stuffs you never would(obviously not in production). Magic happens when you start exploring, you start having those aha light bulb moments.
While exploring, you will make mistakes, that’s good make the mistakes and listen and ask the question of why that was a mistake and investigate accordingly.
Take out time to explore the codebase of open-source projects. You will discover a wealth of ideas and thinking that your future self would thank you for. So explore!
Mistake #5 - Underestimating your individuality
Now don’t get me started on this one. If we take a survey and ask some entry level developers why they use the tech they do today, it’s most likely that someone they admire uses or used that tech.
This is not necessarily a bad thing, however just using a tech because someone you admire uses it, is not a good idea. Every tech appeals to different group of people. I for one use Vue for front-end development because appeals to me personally. Someone else might use React because it appeals to them.
Taking out time to find your voice or your individuality in your coding career would make you do better at it. Don’t just rush up with the hype of the moment. Again, investigate and find out what works for you. A good example is of my friend Angie Jones, she has been doing astronomically great works with Java and automation testing; that’s her individuality speaking, she didn’t move from one language to the other like most of us do. She instead stayed with what appealed to her.
You bring something unique to the tech world. So celebrate that difference, celebrate the way you reason about problems and solution. Often times you diminish yourself trying to become someone else. Don’t do that! Its good to learn from other people you admire but don’t become them instead become the best you you can be. You are different! celebrate that! bring who you are to the table.
Mistake #6 - Ignoring the history of programming
This might seem trivial and I am very much guilty of this. Learning the history of programming or software development in general would expose you to different schools of thought which would give you a robust understanding of where we came from as an industry from the days of Ada Lovelace and where we are now. You will get to appreciate the history this way.
Do not ignore the history of programming. Find out people that have done notable works in this field and study them as well.
Mistake #7 - Not falling in love with your craft
Do you wake up thinking about software development? Do you smile when reading technical articles or documentation or is it just work for you. The love for your craft will help prepare you when (I didn’t say if) you get frustrated or get stuck on a bug for weeks(this happens).
You would have to figure out a strong reason why you are in this industry. One of my favorite quote goes:
If you know the why for living, you can endure any how
Take the time out to discover what really made you come into this industry and let that guide you in tough times or through tough bugs.
Mistake #8 - Not learning your language
There are concepts, patterns and nuances that are unique to your language of programming. Do learn them, it gives depth to your expressiveness. Learning your language would give you options to chose from when solving problems with them.
Mistake #9 - Not learning patterns and solutions
Remember that time you just copied the fix for a bug? Yeah we all have done it. Here is a thought: what if you were challenged to not use google to get answers on a project? Think on that.
Take the time to learn the solutions you are implementing. Even though you copied it the first time, don’t copy it again. Take your time and learn it and see if you can improve upon it.
Take out time to really learn a particular solution you have been using. This is where your curiosity would be needed. Again, investigate and learn supporting patterns or anti-patterns as well.
Mistake #10 - Glossing over unknown concepts
Granted there are concepts we all are battling on understanding. I mean things you don’t quite get yet. I do have such concepts. But I encourage you to set out time to really learn them or these concepts might embarrass you when you least expect it. Each concepts that you don’t know is an opportunity to grow your knowledge.
When you discover you don’t quite understand something you are using or a piece of code you are writing, make schedule to study that subject matter until it becomes second nature and you can use it without much mental effort. This takes practice and time but the reward is sure worth it.
Mistake #11 - Not listening to the other elements of software development
This one is a big one. Most beginning software developers just want to care about their code but they forget their code is just one piece of the puzzle in a sea of several puzzles - architecture, user experience, design etc. The users don’t see your code! So you have got to learn to see the whole picture. This will let you appreciate how your code fits in on a larger scale. So from time to time investigate these other elements and how they affect your work as a software developer.
Depending on your learning model, set the time to learn about other elements of software development. I mostly do this on weekends when I watch a bunch of talks about the matter or read a blog post about it.
Mistake #12 - Not studying other facets of software development
Most of the time beginning software developers don’t study other facets of software development apart from writing code. They don’t study their tools(when was the last time you dug into the Webpack docs), they don’t study their editors, they don’t learn to git well or even use the terminal to a confident level.
I implore you to learn your tools really well as this will reduce friction while using them. Learn your editor’s shortcuts as well as productivity tips and tricks. Learn to git well!. Also invest time in mastering the terminal as it will be home for your development half the time.
Mistake #13 - Trusting stuff found on the internet as a standard
We are humans we are susceptible to making mistakes(this article is about mistakes!), . Do not take the fact that because you found a tutorial on YouTube and assume it is unquestionably correct and follow it blindly to the letter. Don’t just ingest everything without cross referencing them. Again investigate. Do your research.
I suggest you don’t blindly use solutions presented on the internet without investigating it some more. You can ask questions about that solution in your community and get other opinions on it. And yet again, explore that solution and really prove it!
Mistake #14 - Learning too many things at one time
Concentration is key to mastery and in this industry, there is so much to cover in one life time. Do not be fooled that you can learn everything. I am a big proponent of mastering one thing. Mastering one thing would make you more valuable than fumbling on a lot of stuff that you don’t fully grasp. Note, it’s not how much you gain, its how much you retain that improves you. Don’t be all over the place on every tech that springs up. Find a tech you feel strongly about and that solves your problem and work on that.
You will need discipline here as they are many enticing tech springing out almost every other day. I suggest you develop a plan that allows you really sit on what particular subject or technology and really master it.
So those are the 14 mistakes I have discovered personally that beginning developers are liable to make. I hope the above list would help you make a change and adjust where you find yourself wanting.
We all have gaps in our learning, however we can make those gaps much more narrow if we take out time to revisit those things we ignored while starting out. Again, if there are any other mistakes you have notice you made on your journey as a software developer, feel free to tweet at me. You can also sign up for my newsletter below to get more of such advice.
Code expressively 🚀 🚀,