What's the difference between design patterns and design principles?

Question

I'm new to Ruby on Rails, and I went through these articles.

• Design Patterns in Ruby: Observer, Singleton
• Design Patterns in Ruby

But I couldn't understand the actual difference between design patterns and design principles. Could someone please explain the distinction?

Solution 1

Design Principles:

Design principles are core abstract principles that we are supposed to follow while designing software. Remember they aren't concrete - rather abstract. They can be applied in any language, on any platform regardless of the state as long as we are within the permissible conditions.

Examples:

• Encapsulate what varies.
• Program to interfaces, not to implementations.
• Depend upon abstractions. Do not depend upon concrete classes.

Design Patterns:

They are solutions to real-world problems that pop up time and again, so instead of reinventing the wheel, we follow the design patterns that are well-proven, tested by others, and safe to follow. Now, design patterns are specific; there are terms and conditions only in which a design pattern can be applied.

Examples:

• Singleton Pattern ( One class can only have one instance at a time )

• Adapter Pattern ( Match interface of different classes )

The following analogy will help you understand the difference better:

Principle: We should teach others in order to educate ourselves as well as others, and overall make our nation a progressive nation.

Pattern: In our country, each medical doctor graduate is supposed to teach 6 months in a far-away village to complete his/her degree.

Solution 2

I think the answer from @ArslanAli is worth summarizing.

• Principles apply to all of programming. You should have a very good reason any time you choose not to follow principles.
• Patterns apply to specific, common problems. You should have a very good reason any time you choose to implement a pattern.

Solution 3

Design Principle

Design principles provide high-level guidelines to design better software applications. They do not provide implementation guidelines and are not bound to any programming language. The SOLID (SRP, OCP, LSP, ISP, DIP) principles are one of the most popular sets of design principles.

Single Responsibility Principle

Open/Closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

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 can keep in mind while designing or creating classes for our application. SRP does not provide specific implementation steps but it's up to you how you implement SRP in your application.

Design Pattern

Design Pattern provides low-level solutions related to the implementation, of commonly occurring object-oriented problems. In other words, the design pattern suggests a specific implementation for the specific object-oriented programming problem. For example, if you want to create a class that can only have one object at a time, then you can use the Singleton design pattern which suggests the best way to create a class that can only have one object.

Design patterns are tested by others and are safe to follow, e.g. Gang of Four patterns: Abstract Factory, Factory, Singleton, Command, etc.

Solution 4

Principles are best practices to follow to allow scalable architecture and software craftmanship. Design patterns are techniques about how to do the design and architect your code. Each design pattern has a different use case and is applicable to a different scenario. On the other hand principles ; in most cases you need to follow them to have code quality. And yes some principles imply some design patterns : Ex. Open/Closed principle closely implies strategy pattern . Dependency injection has strong ties to MVC pattern.

Solution 5

To some extent, we can refer principles as a set of rules that we can follow in every step of programming, but patterns are a set of structured solutions for some specific problems that we may face during coding -not always happening.

View more solutions

Comments

[dbugger]

A principle is an abstraction, a guide to design. A pattern is an implementation that solves a particular problem.

[jaco0646]

"Program to interfaces" and "Depend upon abstractions" is the same thing. Just sayin'. ;)