DEV Community: Arun Mahara

Design Patterns

Arun Mahara — Sat, 27 Nov 2021 20:12:33 +0000

Design pattern is a broad, reusable solution to common problems in software design. It shows relationships and interactions between classes or objects Design patterns represent the best practices used by experienced object-oriented software developers. Design patterns are solutions to general problems that software developers faced during software development. These solutions were obtained by trial and error by numerous software developers over quite a substantial period of time.

Design Pattern are classified into three categories:

Creational Patterns: These design patterns provide a way to create objects while hiding the creation logic, rather than instantiating objects directly using new operator. This gives program more flexibility in deciding which objects need to be created for a given use case.

Structural Patterns: These design patterns concern class and object composition. Concept of inheritance is used to compose interfaces and define ways to compose objects to obtain new functionalities.

Behavioral Patterns: These design patterns are specifically concerned with communication between objects.

Some of the well known design patterns are given below:

Singleton Pattern: It is essential in a scenario where only one instance needs to be created, for example, a database connection. It is only possible to create an instance when the connection is closed or you make sure to close the open instance before opening a new one. This pattern is also referred to as strict pattern, one drawback associated with this pattern is its daunting experience in testing because of its hidden dependencies objects which are not easily singled out for testing.

Prototype Pattern: It is based on prototypical inheritance whereby objects created to act as prototypes for other objects. In reality, prototypes act as a blueprint for each object constructor created.

Constructor Design Pattern: This is a special method that is used to initialize the newly created objects once a memory is allocated. Since JavaScript is typically object-oriented, it deals with objects most, therefore I intend to delve in to object constructors.

Abstract Factory Pattern: It is a creational concerned with the creation of objects without the need for a constructor. It provides a generic interface for creating objects, where we can specify the type of factory objects to be created. Therefore, we only specify the object and the factory instantiates and returns it for us to use. It is wise for us to use factory pattern when the object component set up has a high level of complexity and when we want to create different instances of objects easily depending on the environment we are in. We can also use factory pattern when working with many small objects sharing the same properties and when composing objects that need decoupling.

Module Design Pattern: In the module design pattern, there is an improvement from the prototype pattern. The different types of modifiers (both private and public) are set in the module pattern. You can create similar functions or properties without conflicts. There is the flexibility of renaming functions publicly. The daunting part of this is the inability to override the created functions from the outside environment.

SOLID Principles

Arun Mahara — Sat, 27 Nov 2021 19:42:04 +0000

SOLID is one of the most popular sets of design principles in object-oriented software development. The goal of the SOLID principles is to reduce dependencies so that engineers change one area of software without impacting others. These principles outline best practices for designing software while keeping in mind the project's long-term maintenance and expansion. Adopting these techniques can also help avoid code smells, restructure your code, and design Agile or adaptive software.

SOLID stands for:
• S - Single-Responsibility Principle
• O - Open-Closed Principle
• L - Liskov Substitution Principle
• I - Interface Segregation Principle
• D - Dependency Inversion Principle

Single-Responsibility Principle: A class should have only one cause to change, which means it should only have one task.
Here I have created different classes(Addition, Subtraction, Multiplication, Division) which have one job to do.

Open-Closed Principle: Objects or entities should be open for extension but closed for modification.

Liskov Substitution Principle: Let q(x) be a property provable about objects of x of type T. Then q(y) should be provable for objects y of type S where S is a subtype of T.
This means that every subclass or derived class should be substitutable for their base or parent class.

Interface Segregation Principle: A client should never be forced to implement an interface that it doesn’t use, or clients shouldn’t be forced to depend on methods they do not use.

Dependency Inversion Principle: Entities must depend on abstractions, not on concretions. It states that the high-level module must not depend on the low-level module, but they should depend on abstractions.

OOP

Arun Mahara — Sat, 27 Nov 2021 16:07:37 +0000

Object-oriented programming (OOP) is nothing but that which allows the writing of programs with the help of certain classes and real-time objects. It is a programming paradigm that relies on the concept of classes and objects. It is used to structure a software program into simple, reusable pieces of code blueprints (usually called classes), which are used to create individual instances of objects.
• OOP models complex things as reproducible, simple structures.
• Reusable, OOP objects can be used across programs.
• Allows for class-specific behavior through polymorphism.
• Easier to debug, classes often contain all applicable information to them.
• Secure, protects information through encapsulation.

There are certain features or mechanisms which makes a JavaScript Object-Oriented like:
Classes: A code template for creating objects.

Object: Objects are variables which can contain many values.

Encapsulation: The process of wrapping property and function within a single unit.

Inheritance: A concept in which some property and methods of an Object is being used by another Object.