Design patterns and design principles are both important concepts in software engineering, but they refer to different things.
Design Patterns are techniques for how to design and architect your code. They are reusable low-level solutions to commonly occurring software design problems, so instead of inventing the wheel, we follow design patterns that are well-proven, tested by others, and safe to follow.
Each design pattern has a different use case and applies to a different scenario, they are also typically specific to a programming language or technology and often provide implementation details.
Examples of Design Patterns:
Adapter Pattern (converts the interface of a class into another interface that clients expect, allowing classes to work together)
Active Record Pattern (a database table or view is wrapped into a class)
MVC Pattern (separates application's logic into three interconnected components: the Model, the View, and the Controller)
Singleton Pattern (one class can only have one instance at a time)
Design principles, on the other hand, are general (high-level) guidelines that help inform good software design to ensure scalable software architecture and mastery. In most cases, you need to follow them to have quality code. They are more abstract and less prescriptive than design patterns and are typically not dependent on any specific programming language or technology.
For example, the Single Responsibility Principle (SRP) suggests that a class should have only one reason to change. This is a high-level statement that we should keep in mind while designing or creating classes for our application. SRP does not provide specific implementation steps and it is up to developers how they implement it in their applications.
Sometimes, design principles imply some design patterns. For example, the Open/Closed principle closely implies the Strategy pattern. Meanwhile, the Dependency Injection principle has strong ties to the MVC pattern.
Examples of Design Principles:
DRY Principle (Don't Repeat Yourself)
KISS Principle (Keep It Simple, Stupid)
Single Responsibility Principle (a class should have only one reason to change)
SOLID Principles (an acronym for five design principles)
Design Patterns are specific (low-level) solutions to specific problems. You should have a very good reason every time you decide to implement a pattern.
Design Principles are general (high-level) guidelines that help inform good software design. You should have a very good reason every time you decide not to follow principles.
Both concepts are important for building high-quality software, and they can be used in conjunction to create robust and maintainable systems.
I hope you found this information helpful, stay tuned for more content! :)
Did you find this article valuable?
Support Andrew Savetchuk by becoming a sponsor. Any amount is appreciated!