Software Engineering

Software engineering is an invaluable profession in today’s world, so much so that a  substantial amount of programs are being spearheaded to include the next generation. Ensuring that they have viable options in the future.  With all the attention being paid to software development, building products requires focusing on design principles – the procedure of writing and combining codes on systems.

While creating codes is necessary, they can become extremely difficult to manage, if/when a product requires a future maintenance or reformation of codes. 

Do you remember the codes you scripted for a website application? Do you recall a moment when you were perplexed and had no idea how you wrote those codes? Or a period you generated either PHP, Python or Node.js scripting languages and had trouble conveying it to a colleague?

Those challenging situations are indications that you may have  underestimated the need-to-know fundamental concepts and principles which are essential for developing quality software solutions.

These existing design principles act as a guide to developing efficient, robust and scalable applications.  Here are some principles every software engineer should live by:


This design principle stands for “You aren’t gonna need it”. As a Software engineer, you and your client alike want to develop something revolutionary. For instance, a client may want to build a software that generates payroll, that is artificially intelligent, with  augmented reality, and even launches rockets to space! While this passion is admirable, you should encourage your clients to set their sights on more realistic and attainable goals. 

The questions being asked at this stage should be:

  • How essential are these functionalities for the final product? 
  • If we stripped off these extra will we still have a good product?
  • Was this part of your original vision or is this a last minute addition?

A good mantra to live by is to ask yourself a question; “is this necessary?”. The main focus is on building necessary functionalities and not piling the product with gratuitous features.


This design principle stands for “Don’t Repeat Yourself”, and it revolves around the concept of avoiding code repetitions. This can be done by using other programming constructs like “functions and methods”, and making common codes reusable by moving them to “functions or methods”. 

When DRY is appropriately implemented, modifying a piece of code or software entity X does not require you to change other or similar entities to the original entity X.  The use of code generators and automatic build systems is also an exemplary implementation of the DRY principle.

Why? Because code generators provide support in automatically generating written codes, whereas automatic build systems assist in downloading required files and libraries for projects.


This design principle stands for “Keep it simple, stupid”. Simplicity is key as a software engineer. So, while developing software applications, it is paramount that codes are kept as simple as possible. With the KISS principle ask yourself; “Do I write codes to be implemented for a product and become puzzled a few hours later?”. 

If your answer is YES, it’s an indication that your codes are not simple or clear enough. There’s a possibility that you’ve added elaborate constructs to your code. To rectify your codes and ensure they are much more simple to implement, review and re-write the codes where necessary.


SOLID is a set of design principles that was made famous by Robert Cecil Martin, who also goes by the “Uncle Bob” sobriquet. Martin opined that successful software will always necessitate a shift in the development phases over time.

Software becomes rigid, and fragile, in the absence of good design principles. To solve these problematic design patterns, the SOLID principles were created.

Regardless of the software programming language or framework you currently use, one or more of these principles can be applied to your development process. 

S – Single Responsibility Principle: Implies that every entity in a software should do one thing – solve just one problem. Using this principle makes your code easier to test, and aids in avoiding unexpected problem areas of future changes of codes.

O – Open Closed Principle: Indicates that software entities should be open for extension but closed to modification. With consideration  to the fact that changing of source codes can lead to bugs or errors, to comply with this principle, ensure your codes are easily extendable. This principle also makes your code revisable.

L – Liskov Substitution Principle: Here, every derived entity in your software can be substituted by their parent class. An advantage of employing this principle is the avoidance of unexpected consequences of changes, and a variety of issues while updating and extending your source code.

I – Interface Segregation Principle: Requires you to make interfaces specific to a particular task. Simply put, larger interfaces should be divided into smaller ones. By doing so, you can ensure that implemented interfaces address the tasks that are relevant to them.

D – Dependency Inversion Principle: Here, you are expected to focus on abstraction, not concretions of codes. Essentially, rather than high-level modules of a software relying on low-level modules, both will mirror common features to function.

Using the 5 in 1 design principles mentioned above allows you to reduce dependencies while changing an area of your software without affecting other parts. Furthermore, they are intended to make your software designs easier to understand, maintain, and to build agile software applications.

In conclusion, practicing the YAGNI, DRY, KISS and SOLID design principles allows you, as a software engineer, to function much more efficiently and as a result more effectively. These design principles cut out unnecessarily laborious efforts and allow you to hone in on the relevant tasks at hand. 

To find out more about these design principles, contact us at to chat with our software engineers.