Software Patterns: Why they are important?
In this story i want to talk about software patterns? What are they? Why they are important? How patterns are organized? And what are some of the most popular software patterns?
What is a pattern?
A pattern in software describes a particular recurring design problem that arises in specific design context, and presents a well proven generic scheme for its solution.
A pattern is a three-part rule, which expresses the relation between a certain context, a problem and a solution.
Context: a situation giving rise to a problem
Problem: the recurring problem arising in that context
Solution: a proven resolution of the problem
Why do we need software patterns?
Patterns help you build on the collective experience of skilled software engineers. They capture existing, well-proven experience in software development and help to promote good design practice. Every pattern deals with a specific, recurring problem in the design or implementation of a software system.
Other than this they help with a serious problem in software engineering: you hire a newcomer to a project and no matter how well they know the programming language, it takes them months to get up to speed with how things are done in your project before they can be productive.
The software industry has been trying to come up with ways to improve this. Standardization of programming languages was one way. Standard libraries (class libraries nowadays) has been another way; however, one of the most important ways has perhaps been designing patterns. So, are software patterns important? Very.
Pattern Categories
Architectural Patterns
An architectural pattern expresses a fundamental structural organization schema for software systems. It provide a set of predefined subsystems, specifies their rehabilitates, and includes rules and guidelines for organizing the relationship between them.
Design Patterns
A design pattern provides a scheme for refining the subsystems or components of a software system, or the relationships between them. It describes a commonly-recurring structure of communicating components that solves a general design problem with a particular context.
Idiom
An idiom is an low level pattern specific to a programming language. An idiom describes how to implement particular aspects of components and relationships between them using features of a given language.
Popular Architectural Patterns
- Layered (n-tiers) - https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch01.html
- Event driven - https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch02.html#idp949504
- Microservices - https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch04.html#idp1166176
- Space based - https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch05.html#idp1264816
- Client server -https://en.wikipedia.org/wiki/Client%E2%80%93server_model
- Master slave - https://subscription.packtpub.com/book/big_data_and_business_intelligence/9781783989126/1/ch01lvl1sec10/the-master-slave-architecture
- Pipes and filters -https://docs.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters
- Blackboard -https://en.wikipedia.org/wiki/Blackboard_(design_pattern)
- Broker -http://www.openloop.com/softwareEngineering/patterns/architecturePattern/arch_Broker.htm
- Model-View-Controller -https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller
- Micro-kernel - https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch03.html#idp1081312
- CQRS -https://docs.microsoft.com/en-us/azure/architecture/patterns/cqrs
- Event Sourcing - https://martinfowler.com/eaaDev/EventSourcing.html
- Peer to peer -https://www.sciencedirect.com/topics/computer-science/peer-to-peer-architectures
- Event bus - https://medium.com/elixirlabs/event-bus-implementation-s-d2854a9fafd5
Popular Design Patterns
Creational Patters
- Singleton -https://sourcemaking.com/design_patterns/singleton
- Prototype -https://sourcemaking.com/design_patterns/prototype
- Object pool -https://sourcemaking.com/design_patterns/object_pool
- Builder -https://sourcemaking.com/design_patterns/builder
- Factory -https://sourcemaking.com/design_patterns/factory_method
- Abstract factory -https://sourcemaking.com/design_patterns/abstract_factory
Structural Patterns
- Adapter -https://sourcemaking.com/design_patterns/adapter
- Bridge -https://sourcemaking.com/design_patterns/bridge
- Composite -https://sourcemaking.com/design_patterns/composite
- Decorator -https://sourcemaking.com/design_patterns/decorator
- Facade -https://sourcemaking.com/design_patterns/facade
- Flyweight -https://sourcemaking.com/design_patterns/flyweight
- Private class data -https://sourcemaking.com/design_patterns/private_class_data
- Proxy -https://sourcemaking.com/design_patterns/proxy
Behavioral patterns
- Chain of responsibility -https://sourcemaking.com/design_patterns/chain_of_responsibility
- Command -https://sourcemaking.com/design_patterns/command
- Interpreter -https://sourcemaking.com/design_patterns/interpreter
- Iterator -https://sourcemaking.com/design_patterns/iterator
- Mediator -https://sourcemaking.com/design_patterns/mediator
- Memento -https://sourcemaking.com/design_patterns/memento
- Null object -https://sourcemaking.com/design_patterns/null_object
- Observer -https://sourcemaking.com/design_patterns/observer
- State -https://sourcemaking.com/design_patterns/state
- Strategy -https://sourcemaking.com/design_patterns/strategy
- Template method -https://sourcemaking.com/design_patterns/template_method
- Visitor -https://sourcemaking.com/design_patterns/visitor
Hope you found this article useful. In the near future I plan to write a separate article for each pattern.
Thanks for reading. 😊
https://kristogodari.com/blog/english/software-patterns-why-they-are-important/
