Breaking down all of software development to simple best practices isn’t easy—or even all that possible. The way one engineer approaches work is completely different from the next.
But certain practices and guidelines unite developers and product managers. With these guidelines put in place, software development becomes a smoother process for all!
Here are five best practices in the world of software development. If you keep it simple, commit regularly, and thoroughly test your work, you will have a better time building your code and delivering quality software efficiently and on schedule.
Let’s take a look.
Keep it simple
There’s a temptation to make code that is overly complicated to read, full of strings which you might need in the future, or just a general mess. Writing complex and esoteric code might have been fashionable 30 years ago—showing off all your sophisticated skills—but now code needs to be clear and efficient.
Since Max Kanat-Alexander, software developer for Google, said we should reduce complexity to simplicity, there has been a cultural shift to creating streamlined code. If you ever doubt the quality of your code, remember these two principles:
- DRY
- YAGNI
DRY: Don’t repeat yourself
Don’t Repeat Yourself. Computers are smart. They’re not like humans who constantly need to be told something in order to remember it. Tell your computer once and it will know it until you tell it to forget it.
Don’t repeat yourself for the sake of repeating yourself (Source)
That’s why duplication is waste. Whether that’s waste lines in code or wasted time in the process, repeating yourself is just wasting time and putting greater strain on the code, your budget, and you. The DRY principle might not apply in every single instance, but it’s a great guideline.
In sum: Avoid repetition—instead, look at abstraction, automation, and intelligent implementation of code.
YAGNI: You are not gonna need it
Just because it might save time in the future doesn’t mean you need to make it now (Source)
You Are Not Gonna Need It. Would you build a bridge over a small stream in case it becomes a crashing white water river? Probably not, right? Because that’s unnecessary, even if it might save headaches later down the line.
If you don’t need a piece of code now, don’t include it. Always focus on the task at hand and don’t try to second guess what the future will bring. You’re a programmer, not a mystic. Even if you were correct in guessing where the project would eventually lead you, there’s a possibility that you’ll find it isn’t exactly how you planned it.
Besides, adding code that isn’t immediately important wastes time and resources that you probably can better spend elsewhere.
Have a backout plan
Experimenting and changing things as you go is an easy way to cut down on revision time later. But it is also a surefire way to take your code far in the wrong direction, with no easy way back.
Instead, commit your work often and regularly. This way you’ll always be able to rewind to a point where you hadn’t got lost in the weeds.
This is a habit, one that is very much something you don’t really appreciate the value of until it’s too late. If you don’t keep committing, you could be adding days or weeks to your projects as you try to find the error, correct it, and then start again on a different path. Even there, there’s no guarantee that the new path will be the right one—that’s the perfect moment to make a commit, anyway!
(Learn how to set up a CI/CD pipeline.)
