01

You Aren’t Gonna Need It

It’s simple and self-explanatory — but not everybody follows it. So when adding code, make sure it’s needed right away. Please don’t leave the code hanging because you think it might be helpful later. If you refactor a method/class/file, you shouldn’t be reluctant to remove any methods that are left hanging. Even if they were helpful in the past — they are not anymore.

A day may come when they are needed again, and you can use the git repository to return them from the dead. Most programmers fall into the pit of trying to implement all the functionalities at once from the word go. In the end, some or most of these functionalities become useless.

As an upcoming software developer, always start by adding just a few methods to a class. After that, as your project starts taking shape and new demands arise, you can add more functionalities. That way, you’ll achieve lean development software.

YAGNI saves time, effort, and costs you would have wasted trying to understand or debug the code.

02

Don’t Repeat Yourself (DRY)

When writing your code, don’t repeat yourself. That is, avoid copy-pasting your code in different places. Otherwise, future maintenance will be complex. The reason is that you will have to change the coding in those various places.

Those changes will further necessitate changes in the tests to make the results click green. All of that will need more time, effort, and money.

To avoid such a pitfall, you can extract a common logic into functions.

Additionally, if there are any manual works that you can automate, do so to keep your code lean. For software development, the above steps will help the code's re-usability without having to repeat it.

Keeping a single source of truth will help have a more solid and self-explanatory codebase. Having duplicated code is a waste. You will have to maintain the same logic in two places and do the tests in two areas, and when one place changes, you will have to remember to change the other.

Most of the time, code duplication comes from a lack of system knowledge.

03

Keep it Simple, Simon (Stupid) KISS.

All designs and implementations should be as simple as possible, meaning the KISS (Keep it Simple, Stupid) principle should be followed. It makes code so simple that debugging and further maintenance become simple.

As you code your next big project, ensure your programming is simple and clear to understand. The code shouldn’t give human beings difficulties when modifying or changing it.

• Your methods must be small, not exceeding 40-50 lines.
• Each technique should solve only one problem.
• Do you have a lot of conditions in your project? Make sure you’ve broken them down into smaller blocks of codes.

Always Keep It Simple, Stupid (KISS) allows you and fellow programmers to identify bugs quickly. It also helps you modify and make further changes to the code. It is one of the most common lean principles in agile software engineering.

04

Avoid Premature Optimization.

Premature optimization is the practice that encourages developers to perform unnecessary optimization before it’s proven that it is needed. If you apply KISS and YAGNI, you shouldn’t fall for this.

Don’t get us wrong; it’s good to try to anticipate that something terrible is going to happen. Still, before going into the implementation details, you must check that those optimizations are beneficial.

A straightforward example is scaling. You will not buy 40 servers because you think your new app will be viral. What you will do, instead, is add servers as you need them.

Premature optimization can lead to delays in your code and, therefore, increases the cost of time to market features.

Many know premature optimization as the root of all evil.