Software Engineering Principals
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.