The Adapter Pattern: Create One, Use Many

Creating interface as your contract with outside world. Use multiple plugs in multiple sockets with the help of an adapter.

Bridge Design Pattern for Begineers

Bridge Design Pattern is one of the gang-of-four-design-patterns. Bridge Design Pattern comes under the Structural Design pattern. It helps us to decouple the abstraction and implementation. Due to which the abstraction and implementation can be developed and fixed separately.

Understanding the Observer Design Pattern

There are 23 classic design patterns described in the original book Design Patterns: Elements of Reusable Object-Oriented Software. In this article, I am going to describe how the Observer pattern works and when it should be applied.

The Singleton Pattern In TypeScript

The Singleton Pattern In TypeScript. Singleton is a creational design pattern, which ensures that only one object of its kind exists and provides a single point of access to it for any other code. Typescript has all the required tools for us to actually ensure that the above statement is 100% true.

Builder Design Pattern in Java for Beginners

Builder Design Pattern in Java for Beginners. Builder Design Pattern is a creational design pattern used for creation of complex objects. Let’s see how we can implement builder design pattern in Java: First of all you need to create a static nested class and then copy all the arguments from the outer class to the Builder class; Java Builder class should have a public constructor with all the required attributes as parameters; Java Builder class should have methods to set the optional parameters and it should return the same Builder object after setting the optional attribute; The final step is to provide a build() method in the builder class that will return the Object needed by client program. For this we need to have a private constructor in the Class with Builder class as argument.

Understanding the Builder Design Pattern

I am going to describe how the builder pattern works and when it should be applied. There are 23 classic design patterns described in the book Design Patterns. The builder pattern is a design pattern designed to provide a flexible solution to various object creation problems in object-oriented programming. The intent of the Builder design pattern is to separate the construction of a complex object from its representation.

How to Create Abstract Syntax Tree with Acorn

JavaScript parser — Acorn and AST are useful things. They help us automatically and efficiently edit source code. This post shows you how to build and edit the AST of JavaScript code.

Dependency Injection in Rust using Waiter DI

Dependency injection is a technique which is largely used to avoid tight coupling inside the applications, by abstracting objects/modules and inverting the dependency flow. Of course this is a simplified explanation of it but, if you are here, I believe that we are familiarized with the technique and you might have googled “dependency injection in rust”, or something like that, in order to know specifically how to use it in Rust. Dependency Injection in Rust using Waiter DI

The Command Pattern with Go

The Command Pattern With Go. A simple yet powerful object-oriented design pattern. Design patterns bring simplicity, organization and scalability to any fitting situation. Go is a bit different than other languages that are capable of object-oriented programming.

Design Patterns, Smalltalk, and the Lost Art of Reading Code

Kyle Brown, IBM Fellow, CTO Cloud Architecture. The last year has not been kind to a book that I believe to be one of the classic, and most important works of computer science — the book ...

40 Tips For Becoming A Better Coder At Your Workplace

Being a programmer is all about learning how to search for the ... 40. Track your progress. Learning to code takes time and can be ... You'll be much more motivated to work if you enjoy your workspace and technical setup.

Node.JS and Singleton Pattern

All software engineers should be familiar with design patterns. One of the most known and common one is the singleton pattern. If you want to understand this pattern and how to use it with Node.JS read this quick and easy tutorial.

9 Tips for Writing Scalable JavaScript Code

I'm using tips to write scalable code I’m going to share below, you'll see 9 Tips for Writing Scalable JavaScript Code

Exploring Design Patterns in Python

Exploring Design Patterns in Python. How to implement reusable models into your programming experience

The Biggest Misconception in JS Community

If you are trying to get a good understanding of what’s composition vs inheritance, you probably search on google etc., read articles and watch videos around “composition vs inheritance”. Here’s the problem, you are going to learn incorrect definition of composition.

5 Design Patterns Every Developer Should Learn

Top Design Patterns to Get You Started. In this article, I am going to go through five different design patterns that I believe every developer should learn.

7 JavaScript Design Patterns Every Developer Should Know

A template for every project? Sounds amazing, isn’t it? That’s also a level of coding I’m striving for. One of the ways to achieve it is using design patterns, which help to write well-structured, beautiful, and organized codes. In this story, we will discover some of the common design patterns used in JavaScript. Let’s get into it.

Chain of Responsibility Design Pattern in Modern C++

Chain of Responsibility is a Behavioural Design Pattern that provides facility to propagate event/request/command/query to the chain of loosely coupled objects. Chain of Responsibility Design Pattern in Modern C++ lets you pass requests along a chain of handlers & upon receiving a request, each handler decides either to process the request or to forward it to the next handler in the chain.

Introduction to Circuit Breaker Pattern: How to Build Better Software

In any application, different sets of services/third-party APIs communicate either asynchronously (out of score from current context) or synchronously or sometimes both (rare cases).

Composition Over Inheritance

Moving towards single activity architecture involved moving code from activities to fragments ensuring maximum reusability and readability.