Software Design
Everything on SkillVeris tagged Software Design — collected across the glossary, study notes, blog, and cheat sheets.
223 resources across 2 libraries
Study Notes(30)
Abstract Factory Pattern
Provides an interface for creating families of related objects without specifying their concrete classes.
Adapter Pattern
The Adapter pattern converts the interface of a class into another interface clients expect, letting incompatible interfaces work together without modifying ex…
Anti-Patterns to Avoid
A tour of the most common design anti-patterns — recurring bad solutions to recurring problems — and how to recognize and refactor them before they calcify.
Builder Pattern
Separates the construction of a complex object from its representation, building it step by step.
Chain of Responsibility Pattern
A behavioral pattern that passes a request along a chain of handlers until one of them handles it, decoupling senders from receivers.
Choosing the Right Pattern
A practical framework for diagnosing the actual problem in your code first, then matching it to the smallest design pattern that resolves it, and avoiding comm…
Command Pattern
The Command pattern turns a request into a standalone object with a uniform execute() method, decoupling the invoker from the receiver and enabling undo, queui…
Composite Pattern
The Composite pattern composes objects into tree structures to represent part-whole hierarchies, letting clients treat individual objects and compositions of o…
Decorator Pattern
The Decorator pattern attaches additional responsibilities to an object dynamically by wrapping it in one or more decorator objects that share its interface.
Design Patterns in Modern Frameworks
How classic GoF design patterns show up, sometimes disguised under different names, inside React, Spring, Angular, and other modern frameworks.
Design Patterns Interview Questions
A focused prep guide covering the design-pattern questions most frequently asked in technical interviews, with the reasoning interviewers are actually testing…
Design Patterns Quick Reference
A condensed, scan-friendly cheat sheet mapping each core Gang of Four pattern to its intent, the force that triggers it, and a one-line example.
Facade Pattern
The Facade pattern provides a single, simplified interface to a larger, more complex body of subsystem code, making it easier to use without hiding advanced ac…
Factory Method Pattern
Defines an interface for creating an object but lets subclasses decide which concrete class to instantiate.
Iterator Pattern
A behavioral pattern that provides a way to access elements of an aggregate object sequentially without exposing its underlying representation.
Mediator Pattern
A behavioral pattern that centralizes complex communications between related objects into a single mediator object, reducing direct coupling.
Memento Pattern
A behavioral pattern that captures and externalizes an object's internal state so it can be restored later, without violating encapsulation.
Observer Pattern
The Observer pattern lets a Subject notify a dynamic list of Observers automatically whenever its state changes, decoupling event producers from consumers.
Prototype Pattern
Creates new objects by cloning an existing, pre-configured instance instead of constructing from scratch.
Proxy Pattern
The Proxy pattern provides a surrogate or placeholder object that controls access to another object, adding a layer for lazy loading, access control, caching,…
Refactoring to Patterns
How to evolve messy, ad-hoc code toward well-known design patterns incrementally, using the smell-driven refactoring approach popularized by Joshua Kerievsky.
Singleton Pattern
Ensures a class has only one instance and provides a single global point of access to it.
SOLID Principles Recap
A refresher on the five SOLID object-oriented design principles and how they form the underlying rationale for many Gang of Four design patterns.
State Pattern
The State pattern lets an object change its behavior when its internal state changes by delegating to interchangeable State objects that manage their own trans…
Showing 24 of 30.
Interview Questions(193)
What is Polymorphism in OOP?
Polymorphism is the object-oriented principle that lets objects of different classes respond to the same method call in their own class-specific way.
Difference Between Abstraction and Encapsulation
Abstraction hides complexity by exposing only the essential behavior of an object, while encapsulation hides an object’s internal data by bundling it with the…
What are the Four Pillars of OOP?
The four pillars of object-oriented programming are Encapsulation, Abstraction, Inheritance, and Polymorphism — the principles that structure code around objec…
Difference Between Interface and Abstract Class
An interface defines a contract of methods a class must implement with no state, while an abstract class can provide partial implementation and state and serve…
Composition vs Inheritance in OOP
Inheritance models an "is-a" relationship where a class derives from a parent, while composition models a "has-a" relationship where a class is built from othe…
What are SOLID Principles?
SOLID is five object-oriented design principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion — th…
What is Inheritance in OOP?
Inheritance is the object-oriented mechanism by which a class (the subclass) acquires the fields and methods of another class (the superclass), enabling code r…
Method Overloading vs Overriding
Method overloading is defining multiple methods with the same name but different parameter lists within a class, resolved at compile time, while method overrid…
What is Encapsulation in OOP?
Encapsulation is the object-oriented principle of bundling an object’s data with the methods that operate on it and restricting direct access to that data from…
What is a Constructor in OOP?
A constructor is a special method invoked automatically when an object is created that initializes the object’s state, sharing the class’s name and having no r…
What is Abstraction in OOP?
Abstraction is the object-oriented principle of exposing only the essential features and behavior of an object while hiding the underlying implementation compl…
What is a Design Pattern?
A design pattern is a reusable, named solution to a recurring software design problem, expressed as a template of collaborating classes and objects rather than…
What is the Singleton Pattern?
The Singleton pattern restricts a class to exactly one instance and provides a single global access point to that instance, typically via a static method.
What is the Factory Pattern?
The Factory pattern delegates object creation to a dedicated method or class instead of calling a constructor directly, so callers depend on an interface rathe…
What is Dependency Injection?
Dependency injection is a technique where an object receives its dependencies from an external source rather than creating them itself, typically via construct…
What is Coupling and Cohesion in OOP?
Coupling measures how dependent one module or class is on another, while cohesion measures how strongly the responsibilities inside a single module belong toge…
Aggregation vs Composition in OOP
Aggregation and composition are both "has-a" relationships between objects, but composition implies strict ownership where the part cannot outlive the whole, w…
What is the Liskov Substitution Principle?
The Liskov Substitution Principle (LSP) states that objects of a subclass must be substitutable for objects of the base class without altering the correctness…
What is the Strategy Pattern?
The Strategy pattern defines a family of interchangeable algorithms, encapsulates each one behind a common interface, and lets the client swap the algorithm at…
What is Multiple Inheritance?
Multiple inheritance is when a class inherits fields and methods from more than one parent class simultaneously, combining their behavior into a single subclas…
What is a Copy Constructor?
A copy constructor is a special constructor that creates a new object as a duplicate of an existing object of the same class, copying its field values into the…
What is the Open-Closed Principle?
The Open-Closed Principle (OCP) states that software entities — classes, modules, functions — should be open for extension but closed for modification, meaning…
What is the Builder Pattern?
The Builder pattern is a creational design pattern that separates the step-by-step construction of a complex object from its final representation, letting the…
What is the Prototype Pattern?
The Prototype pattern is a creational design pattern that creates new objects by cloning an existing, fully configured instance rather than constructing one fr…
Showing 24 of 193.