High-Quality Code with Only a Few Development Principles.

When everything is urgent, and the clock starts before Visual Studio has loaded ReSharper.

It sets the requirement for a high code quality from day one. Any anti-patterns, unreadable code, friction will come back and require extra time from you and your colleagues. 

On top of that, we always concentrate on users first to make sure they are firmly understood, taken care of and feels good about the digital product, process and communication at all times to ensure they keep requesting new features. 

By following a few development principles to ensure that you have the right tools, to raise your own code quality, but also your colleagues through code reviews, better solutions will be made. You have properly heard of some of them before and if not, don’t worry it’s never too late to learn. I would recommend focusing on one principle at a time and try to build a routine in your daily work, with the following principles, and of course team up with a colleague. 

Here are a few principles that I will recommend you learn, to build better solutions and makes it more enjoyable to come back to your old code.

This principle aims to lower the technical debt and remove any redundancies in your code.

Don’t Repeat Yourself

There should only be one way to implement a particular code block, so when you have to go back to your code, you only have to update it once and have that automatically applied to every instance of the code in question.

This is not a principle but an acronym for five principles. The purpose of SOLID is to make software that is easy to maintain and extend. Besides that, it also helps to avoid code smells and makes it easier to refactor code. I know it sounds almost too good to be true, and which CTO would not love to have a developer, who creates easy maintainable, extendable code and avoiding code smells. 

SOLID will make your coding life happier, and by following these few principles, the quality of your work will be improved. But be aware, that's it’s not something you will learn how to master overnight. It requires your full attention to implement new habits around the principles.

Single Responsibility Principle Open Closed Principle Liskov Substitution Principle Interface Segregation Principle Dependency Inversion Principle

You know the feeling, when you have to go back to some old codes implemented by a colleague, or even worse, yourself, and extend it with the latest feature request. This principle helps you to create readable, reusable, testable among other great things by avoiding looooong functions.

Single Level of Abstraction Principle

Break up your function into small functions, by the level of abstraction. Your methods should aim to just do one thing. 

"Functions should just do one thing, and they should do it well."

-  Robert Martin

To avoid breaking the DRY principle I won’t repeat the internet by explaining the principles in detail here.

I hope this gives you some appetite to dive deep into code principles Read more about the principles here;  SLAP SOLID DRY