Differences

This shows you the differences between two versions of the page.

Link to this comparison view

it:ad:patterns:home [2019/03/24 12:02] (current)
Line 1: Line 1:
 +# IT:​AD:​Patterns #
  
 +
 +
 +<callout type="​Navigation"​ class="​small">​
 +* [[../​|(UP)]]
 +{{indexmenu>​.#​2|nsort tsort}}
 +* See also:
 +    * [[IT/​AD/​Principles/​]]
 +    * [[IT/​AD/​Design/​]]
 +    * [[General/​Business/​Concepts/​Pattern/​]]
 +* http://​skysigal.com/​blogs/​sigal/​sky/​errata/​entries/​patterns_to_thrive._always
 +
 +
 +</​callout>​
 +
 +
 +<panel title="​Summary">​
 +
 +<uml>
 +!includeurl http://​skysigal.com/​_media/​resources/​configuration/​plantuml/​minimalist.txt
 +
 +class "​Patterns"​ as P
 +class "​Software Architecture Patterns"​ as SAP
 +class "​Software Design Patterns"​ as SDP
 +class "​Algorithm strategy patterns"​ as SDP1
 +class "​Computational design patterns"​ as SDP2
 +class "​Execution patterns"​ as SDP3
 +class "​Implementation strategy patterns"​ as SDP4
 +class "​Structural design patterns"​ as SDP5
 +
 +P <|-- SDP
 +P <|-- SAP
 +
 +SDP <|-- SDP1
 +SDP <|-- SDP2
 +SDP <|-- SDP3
 +SDP <|-- SDP4
 +SDP <|-- SDP5
 +
 +
 +class "​Creational Patterns"​ as SDCRP
 +class "​Structural Patterns"​ as SDSP
 +class "​Behavioral Patterns"​ as SDBP
 +class "​Concurrency Patterns"​ as SDCOP
 +
 +SDP5 <|-- SDCRP
 +SDP5 <|-- SDSP
 +SDP5 <|-- SDBP
 +SDP5 <|-- SDCOP
 +
 +
 +
 +</​uml>​
 +
 +
 +</​panel>​
 +
 +
 +## Essential Patterns ##
 +
 +They'​re *all* important! But if one had to hone in on essential ones to understand before attempting resilient software, I'd propose starting with getting the following under your belt:
 +
 +* [[IT/​AD/​Patterns/​DDD/​]]
 +    * [[IT/​AD/​Patterns/​Dependency Injection Strategy/]]
 +* [[IT/​AD/​Patterns/​SOLID/​]]
 +* [[IT/​AD/​Patterns/​Vendors Suck Strategy/]]
 +* [[IT/​AD/​Patterns/​Convention over Configuration Strategy/]]
 +* [[IT/​AD/​Patterns/​Repository Pattern/]]
 +* [[IT/​AD/​Patterns/​Command Pattern/]]
 +* [[IT/​AD/​Patterns/​CQRS/​]]
 +* [[IT/​AD/​Patterns/​TripleA'​s Strategy/]]
 +
 +
 +
 +## Strategies ##
 +
 +* [[IT/​AD/​Patterns/​Vendors Suck Strategy/]]
 +* [[IT/​AD/​Patterns/​MS is a Vendor Strategy/​]]:​ you get the point...
 +* [[IT/​AD/​Patterns/​MS Sells VS (not Good Practices) Strategy]]: When in doubt, a good thing to remember...
 +* [[IT/​AD/​Patterns/​Namespace As Problem Boundary Strategy/​]]:​ a lot of devs don't know what a Namespace is for.
 +* [[IT/​AD/​Patterns/​Gift Package Strategy/​]]:​ quick: what's the first thing the client experiences of your app? The [[IT/#​UI/​]]?​
 +* [[IT/​AD/​Patterns/​Complex is not Complicated Strategy/]]
 +* [[IT/​AD/​Patterns/​AppSettings Are Dead Strategy/]]
 +* [[IT/​AD/​Patterns/​Enums Start with Undefined Strategy/]]
 +* [[IT/​AD/​Patterns/​Version Your Messages Strategy/]]
 +* [[IT/​AD/​Patterns/​SASS/​]]
 +* [[IT/​AD/​Patterns/​Naming Strategies/​]]
 +* [[IT/​AD/​Patterns/​Convention over Configuration Strategy/]]
 +
 +
 +
 +## Documentation ##
 +* [[IT/​AD/​Patterns/​State Boldy, Justify, Give Alternatives Strategy/]]
 +
 +## App Architecture ​ Patterns ##
 +* [[IT/​AD/​Patterns/​DDD/​]]:​ the most important pattern an application architect can learn.
 +* [[IT/​AD/​Patterns/​DDD/​Entities/​]]
 +* [[IT/​AD/​Patterns/​Tier Strategy/]]
 +* [[IT/​AD/​Patterns/​SASS/​]]
 +
 +
 +## Architecture Strategies ##
 +* Usability:
 +    * [[IT/​AD/​Patterns/​Help is for Failures Strategy/​]]:​ if your UI needs a help doc to explain it...it'​s poor [[IT/#UX/]] design. ​
 +* Security:
 +    * [[IT/​AD/​Patterns/​TripleA'​s Strategy/​]]:​ Authentication,​ Authorisation,​ Auditing (if your not Auditing, you're security isn't up to snuff yet).
 +    * [[IT/​AD/​Patterns/​Security is an Application Concern/]]
 +    * [[IT/​AD/​Patterns/​Don'​t drop your pants Strategy/​]]:​ don't round-trip your datastore Ids to the client.
 + * [[IT/​AD/​Patterns/​Secure the Line Strategy/​]]:​ ensure SSL is enabled.
 +* API:
 +    * [[IT/​AD/​Patterns/​Version Your Messages Strategy/]]
 +    * [[IT/​AD/​Patterns/​Enums Start with Undefined Strategy/]]
 +* Testability:​
 +    * [[IT/​AD/​Patterns/​AppHost Strategy/]]
 +* Modularity:
 +    * [[IT/​AD/​Patterns/​Composite Application Strategy/]]
 +    * [[IT/​AD/​Patterns/​Contract First Development Strategy/]]
 +* Maintainability:​
 +    * [[IT/​AD/​Patterns/​Vendors Suck Strategy/]]
 +    * [[IT/​AD/​Patterns/​MS is a Vendor Strategy/​]]:​ you get the point...
 +    * [[IT/​AD/​Patterns/​Everything is Perishable Strategy/​]]:​ any tech is like fruit...tempting...but perishable. Protect your BIP by keeping it at arms 
 +    * [[IT/​AD/​Patterns/​Egg Yolk Strategy/​]]:​ encapsulate dependencies. The Drug-Mule Strategy.
 +    * [[IT/​AD/​Patterns/​Many Assemblies Strategy/]]
 +    * [[IT/​AD/​Patterns/​Extension Methods Strategy/​]]:​also known as the Cross-Dresser Strategy.
 +* Responsiveness:​
 +    * [[IT/​AD/​Patterns/​Chunky over Chatty Strategy/​]]:​ and no -- it's not the same as *"​Rottweillers are better than Chiwawas Strategy"​*.
 +    * [[IT/​AD/​Patterns/​Cache Like Crazy Strategy/]] (or [[IT/​AD/​Patterns/​Cache Is King Strategy/​]])
 +    * [[IT/​AD/​Patterns/​Dual Access To Data/]]
 +
 +
 +http://​tvnz.co.nz/​national-news/​govt-cannot-guarantee-public-information-protected-english-5399955
 +
 +
 +## App Component ​ Patterns ##
 +* [[IT/​AD/​Patterns/​Head Last Pattern/]]: hold off on the UX or your app will bind itself too quickly to the UX framework.
 +* [[IT/​AD/​Patterns/​Lowest Framework Profile/]]
 +* [[IT/​AD/​Patterns/​Minimal Dependency Cardinality/​]]
 +* [[IT/​AD/​Patterns/​Dependency Wrapping Strategy/]]
 +* [[IT/​AD/​Patterns/​Factories/​]]
 +* [[IT/​AD/​Patterns/​Service Pattern/]]
 +* [[IT/​AD/​Patterns/​Objects as Messages Strategy/]]
 +* [[IT/​AD/​Patterns/​CQRS/​]]:​ Command Query Responsibility Segregation (separation of data retrieval from data modification).
 +* [[IT/​AD/​Patterns/​Specification Pattern/]]
 +* [[IT/​AD/​Patterns/​IoC/​]]
 +* [[IT/​AD/​Patterns/​DRY Strategy/]]
 +* [[IT/​AD/​Patterns/​DTO Strategy/]]
 +
 +
 +
 +
 +
 +
 +## Development Patterns ##
 +
 +* [[IT/​AD/​Patterns/​SOLID/​]]:​ the most useful pattern that a developer can learn.
 +* [[IT/​AD/​Patterns/​Dependency Injection Strategy/]]
 +* [[IT/​AD/​Patterns/​CQRS/​]]
 +* [[IT/​AD/​Patterns/​Command Pattern/]]
 +* [[IT/​AD/​Patterns/​ACID/​]]
 +* [[IT/​AD/​Patterns/​Repository Pattern/]]
 +* [[IT/​AD/​Patterns/​UnitOfWork Pattern/]]
 +* [[IT/​AD/​Patterns/​IdentityMap/​]]
 +* [[IT/​AD/​Patterns/​KISS Strategy/]]
 +* [[IT/​AD/​Patterns/​SOC/​]]:​ Separation of Concerns Strategy
 +
 +## Persistence Patterns ##
 +
 +* [[IT/​AD/​Patterns/​Reference Data Strategy/]]
 +* [[IT/​AD/​Patterns/​Domain First Strategy/]]
 +* [[IT/​AD/​Patterns/​Enums Mapped To Code Tables Strategy/]]
 +* [[IT/​AD/​Patterns/​Localisable Data Strategy/]]
 +
 +
 +
 +## Presentation Patterns ##
 +
 +* [[IT/​AD/​Patterns/​WIMP/​]]
 +* [[IT/​AD/​Patterns/​MVC/​]]
 +* [[IT/​AD/​Patterns/​MVP/​]]
 +
 +
 +
 +## UX Patterns ​
 +
 +* [[IT/​AD/​Patterns/​Views are not Screens Strategy/]]
 +* [[IT/​AD/​Patterns/​Page Number isn't a Search Criteria Strategy/]]
 +* [[IT/​AD/​Patterns/​Single Page Website Strategy/]]
 +* [[IT/​AD/​Patterns/​Less is More Strategy/]]
 +* [[IT/​AD/​Patterns/​It'​s all Hierarchical after all/]]
 +* [[IT/​AD/​Patterns/​Avoid combining I/O Views/]]: search forms and result lists should be kept separate. ​
 +
 +
 +
 +## GoF Patterns
 +
 +
 +### Creational Patterns ​
 +
 +* **[[IT/​AD/​Patterns/​Abstract Factory/​]]:​** ​ Creates an instance of several families of classes. Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
 +* **[[IT/​AD/​Patterns/​Builder/​]]:​** Separates object construction from its representation. Separate the construction of a complex object from its representation so that the same construction processes can create different representations.
 +* **[[IT/​AD/​Patterns/​Factory Method/​]]:​** Creates an instance of several derived classes. Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
 +* **[[IT/​AD/​Patterns/​Prototype/​]]:​** A fully initialized instance to be copied or cloned. Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
 +* **[[IT/​AD/​Patterns/​Singleton/​]]:​** A class of which only a single instance can exist. Ensure a class only has one instance, and provide a global point of access to it.
 +
 +
 +### Structural Patterns ###
 +
 +* **[[IT/​AD/​Patterns/​Adapter/​]]:​** Match interfaces of different classes.Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
 +* **[[IT/​AD/​Patterns/​Bridge/​]]:​** Separates an object’s interface from its implementation. Decouple an abstraction from its implementation so that the two can vary independently.
 +* **[[IT/​AD/​Patterns/​Composite/​]]:​** A tree structure of simple and composite objects. Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
 +* **[[IT/​AD/​Patterns/​Decorator/​]]:​** Add responsibilities to objects dynamically. ​ Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
 +* **[[IT/​AD/​Patterns/​Facade/​]]:​** A single class that represents an entire subsystem. Provide a unified interface to a set of interfaces in a system. Facade defines a higher-level interface that makes the subsystem easier to use.
 +* **[[IT/​AD/​Patterns/​Flyweight/​]]:​** A fine-grained instance used for efficient sharing. Use sharing to support large numbers of fine-grained objects efficiently. A flyweight is a shared object that can be used in multiple contexts simultaneously. The flyweight acts as an independent object in each context — it’s indistinguishable from an instance of the object that’s not shared.
 +* **[[IT/​AD/​Patterns/​Proxy/​]]:​** An object representing another object. Provide a surrogate or placeholder for another object to control access to it.
 +
 +
 +### Behavioral Patterns
 +* **[[IT/​AD/​Patterns/​Chain of Responsibility/​]]:​** ​ A way of passing a request between a chain of objects. Avoid coupling the sender of a request to its receiver by giving more than one object a  chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
 +* **[[IT/​AD/​Patterns/​Command Pattern/​]]:​** Encapsulate a command request as an object. Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
 +* **[[IT/​AD/​Patterns/​Interpreter/​]]:​** A way to include language elements in a program. Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
 +* **[[IT/​AD/​Patterns/​Iterator/​]]:​** Sequentially access the elements of a collection. Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
 +* **[[IT/​AD/​Patterns/​Mediator/​]]:​** Defines simplified communication between classes. Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.
 +* **[[IT/​AD/​Patterns/​Memento/​]]:​** Capture and restore an object'​s internal state. Without violating encapsulation,​ capture and externalize an object’s internal state so that the object can be restored to this state later.
 +* **[[IT/​AD/​Patterns/​Observer/​]]:​** A way of notifying change to a number of classes. Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
 +* **[[IT/​AD/​Patterns/​State/​]]:​** Alter an object'​s behavior when its state changes. Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
 +* **[[IT/​AD/​Patterns/​Strategy/​]]:​** Encapsulates an algorithm inside a class. Define a family of algorithms, encapsulate each one, and make them interchangeable. ​           Strategy lets the algorithm vary independently from clients that use it.
 +*  **[[IT/​AD/​Patterns/​Template/​]]:​** Defer the exact steps of an algorithm to a subclass. Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.
 +* **[[IT/​AD/​Patterns/​Visitor/​]]:​** Defines a new operation to a class without change. Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.
 +I must also mention and credit goes to http://​www.dofactory.com/​Patterns/​Patterns.aspx for the most of the above information.
 +
 +
 +
 +## Communication Patterns ##
 +
 +* http://​en.wikipedia.org/​wiki/​Robustness_principle
 +
 +
 +## Gaming Patterns
 +
 +* http://​gameprogrammingpatterns.com/​
 +
 +
 +##Warnings ##
 +
 +* [[IT/​AD/​Patterns/​Designing from the UI will kill your company/]]
 +
 +
 +## Resources ##
 +
 +* [Silk](http://​msdn.microsoft.com/​en-us/​library/​hh396380.aspx)
 +* [http://​prodinner.codeplex.com/​](http://​prodinner.codeplex.com/​)
 +* [http://​www.asp.net/​mvc/​samples](http://​www.asp.net/​mvc/​samples)
 +* https://​en.wikipedia.org/​wiki/​A_Pattern_Language