Note: Here are not exhausted knowledge about patterns.
Design patterns are a well-described solution to the most commonly encountered problems which occur during software development and represents the best practices evolved over a period of time by experienced software developers. They promote reusability which leads to a more robust and maintainable code.
- Patterns create objects for you, rather than having you instantiate objects directly. This makes program more flexibility in deciding which objects need to be created for a given case.
- Patterns are specifically concerned with communication between objects.
- Command
- Iterator
- Template Method
- Strategy
- Visitor
- Chain of responsibility
- Dependency Injection (not gof)
- Null Object (not gof)
- Value Object (not gof)
- Patterns show class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality.
Functional programming has its own set of patterns that have evolved out of the functional style.
- Tail Recursion
- Mutual Recursion
- Filter-Map-Reduce
- Memoization - To cache the results of a pure function call to avoid performing the same computation more than once
- Lazy sequence - To create a sequence whose members are computed only when needed—this allows us to easily stream results from a computation and to work with infinitely long sequences
- Focused Mutability - To use mutable data structures in small, performance-sensitive parts of a program hidden inside of a function while still using immutable data throughout the majority
The main resources were book Functional Programming Patterns in Scala and Clojure, the blog post from pavelfatin.com, and wikipedia page Design_Patterns