Design Pattern: Flyweight Pattern in TypeScript
Flyweight pattern uses shared object to save resources and optimize memory use. This article demonstrates Flyweight pattern implementations in TypeScript.
Design Pattern: Facade Pattern in TypeScript
Facade adds a new layer around a bunch of subsystems, and wraps those. Clients interact with the Facade, and are not aware of the systems. This article demonstrates Facade pattern implementations in TypeScript.
Design Pattern: Decorator Pattern in TypeScript
Decorator pattern adds new functionality to existing implementation, without changing the existing implementation. The additional functionality is added to individual objects (not to the entire class). This article demonstrates Decorator pattern implementations in TypeScript.
Design Pattern: Composite Pattern in TypeScript
Compsite pattern enables a single object and a list of objects to operate the same way. That way the client does not need to know if it is using a single object or a list, while using it. So the usage becomes simple in that case. This article describes Composite pattern implementation in TypeScript.
Design Pattern: Decorator Pattern in Go
Decorator pattern add new functionality to an existing implementation by adding a new layer. The responsibility/functionality is added to individual objects. This article demonstrates Decorator pattern implementations in Go.
Design Pattern: Bridge Pattern in TypeScript
Bridge pattern implementation separates the Abstraction and implementation. That way we can switch the implementation at runtime and use the implementation flexibly. This article is about Bridge pattern implementation in TypeScript.
Design Pattern: Composite Pattern in Go
Using Composite pattern we can make an object and a group of objects, behave the same way. The client will not know any difference between an object and object group/list while using it. This article demonstrates Composite pattern implementations in GoLang.
Design Pattern: Adapter Pattern in TypeScript
Adapter pattern is used to create a bridge between two incompatible interfaces. Due to some change in the system, or new implementation if we need to enable any existing interface to use the new interface. In that case Adapter pattern can help. This article is about Adapter pattern implementations in TypeScript.
Design Pattern: Bridge Pattern in Go
Bridge pattern is used to provide flexibility to an implementation, that has frequent changes in the implementation. Bridge pattern archives that by decoupling implementation and abstraction. This article demonstrates Bridge pattern implementation in Go.
Design Pattern: Adapter Pattern in Go
Adapter pattern helps by enabling an interface to adapt to a new interface. This is useful when we have an existing interface, and some new requirement comes or we need to adapt to some interface that is developed separately. By following the Open/Closed principle, the adapter pattern keeps the existing interface as is, ads the adapter implementation as a bridge to then new interface. This article demonstrates Adapter pattern implementations in Go.