Importance of Solid Principles in Software Engineering and its examples in TypeScript

In software engineering, writing maintainable, scalable, and flexible code is crucial. It makes development easier, faster, and more efficient. However, as syst

In software engineering, writing maintainable, scalable, and flexible code is crucial. It makes development easier, faster, and more efficient. However, as syst

In software engineering, writing maintainable, scalable, and flexible code is crucial. It makes development easier, faster, and more efficient. However, as systems become more complex, it's easy for code to become messy and difficult to maintain and scale. Fortunately, SOLID principles in TypeScript offer a solution. 

In this blog, we will discuss the importance of SOLID principles in software engineering, SOLID principles code, and explore how to apply them in TypeScript to write clean, maintainable, and scalable code.

What are SOLID Principles?

First, let’s understand the Importance of SOLID principles in TypeScript and how SOLID principles make software designs simpler to comprehend!

Reducing dependencies allows engineers to alter one component of software without affecting others, which is the main objective of the SOLID principles. They are also meant to make designs simpler to comprehend, update, and expand. In the end, applying these design principles helps software engineers avoid problems and create flexible, efficient, and agile software.

What are SOLID Principles in Software Engineering? SOLID principles are a set of software design principles that guide developers on how to write maintainable, scalable, and flexible code. They are:

S: Single-responsibility Principle

To understand what are SOLID principles better, you need to know that the single-responsibility concept is a key aspect of it, which states that a class should only be accountable for one activity and one change-related reason. It becomes easier to implement single responsibility principle as it helps in maintaining the code's modularity and reusability. The same thing goes for modules and functions as well. There are many other benefits of single responsibility principle.

Here is an example of single responsibility principle:

class Company {

  public createEmployeeAccount(){

    // write logic

  }

  public generateEmployeeSalary(){

    // write logic

  }

  public calculateEmployeeLeave(){

    // write logic

  }

}

In the Company class mentioned above, you see an example of violating the single-responsibility principle and how to fix it in TypeScript. Since the concept of a single duty is violated, we ought to categorize the Company class into several degrees of responsibility. The concept of responsibility, according to SOLID, is a justification for change.

We observe in the company class that it tries to complete three tasks at once, which is incorrect. As an alternative, we might divide this obligation into three groups like in the given below:
 

class EmployeeAccount {

  public createEmployeeAccount(){

    // write logic

  }

}

class EmployeeSalary {

  public generateEmployeeSalary(){

    // write logic

  }

}

class EmployeeLeave {

  public calculateEmployeeLeave(){

    // write logic

  }

}

Now that the classes are separated, each has just one obligation, one responsibility, and just one change that needs to be made. Our code is now easier to understand and explain.

O: Open Closed Principles

Now let’s move to what is open closed principle!

Software entities should be open for extension but closed for modification, in accordance with the open-closed paradigm. Let’s look at the open-closed principle and how it helps in extending the codebase in TypeScript.

To know how to implement open-closed principle, write a code that follows this principle:

class Programmer{

      writing(){

        return