Intro

When developing software it is important not to forget some important principals

Modularity

Break complex software into smaller, more manageable pieces that can be developed, tested, and maintained independently.

Abstraction

Hide the implementation details of a module or component behind an interface or API, so that users of that component only need to know how to interact with it, not how it works.

Separation of Concerns

Organize software into separate layers, modules, or components, each with a specific responsibility or concern, to minimize dependencies and improve maintainability.

Encapsulation

Limit the visibility of data and functions to only the parts of the software that need to interact with them, to prevent unintended interference and improve maintainability.

Single Responsibility Principle

Ensure that each module or component has only one responsibility, so that changes to one aspect of the software do not affect unrelated parts.

Open/Closed Principle

Design modules and components so that they are open for extension (i.e., new functionality can be added) but closed for modification (i.e., existing functionality does not need to be changed).

Don’t Repeat Yourself (DRY)

Eliminate duplication of code or logic within a software system, to improve maintainability and reduce the risk of errors.

Test-Driven Development

Write automated tests before writing code, to ensure that the code is correct and to improve maintainability.

Continuous Integration and Continuous Deployment (CI/CD)

Automate the process of building, testing, and deploying software, to reduce the risk of errors and to improve efficiency.

Code Reviews

Have other developers review code changes before they are merged into the main codebase, to catch errors and improve maintainability.

Think on ways to incorporate this principals not only on the design phase but also on your daily development activities.