Book 09
Software Architecture
Design principles and architectural styles that keep large codebases organized and maintainable.
Contents
- 01Adapter Pattern1The adapter pattern is a structural design pattern that wraps an existing class in a new interface, so code expecting one interface can use an incompatible one.
- 02Backend for Frontend2Backend for frontend is an architecture pattern in which each kind of client, such as a web or mobile app, gets its own small backend tailored to its needs.
- 03Builder Pattern3The builder pattern builds a complex object step by step through a separate builder object, with named steps instead of a long constructor full of arguments.
- 04Circuit Breaker Pattern4The circuit breaker pattern protects a system by stopping calls to a failing dependency for a while and failing fast instead of waiting on timeouts.
- 05Clean Architecture5Clean architecture is a way of structuring software in layers so that the core business rules never depend on frameworks, databases, or user interfaces.
- 06Client-Server Architecture6Client-server architecture splits a system into clients, which request data or actions, and servers, which provide them, as when a browser requests a page.
- 07Cohesion7Cohesion is a measure of how closely the responsibilities inside a module, class, or service belong together, and high cohesion is a sign of good design.
- 08Consensus Algorithm8A consensus algorithm lets a group of machines agree on a single value or an ordered log of decisions, even when some of them crash or messages are lost.
- 09Consistent Hashing9Consistent hashing spreads keys across a changing set of servers so that adding or removing a server moves only a small share of the keys.
- 10CQRSCommand Query Responsibility Segregation10CQRS is an architectural pattern that separates the code that changes data, called commands, from the code that reads data, called queries, into two models.
- 11Decorator Pattern11The decorator pattern adds behavior like logging or caching to an object by wrapping it in another with the same interface, without changing the original.
- 12Dependency Injection12Dependency injection is a design technique in which an object receives the other objects it needs from the outside instead of creating them itself.
- 13Design Pattern13A design pattern is a proven, reusable solution to a common problem in software design, described as a general template rather than as finished code.
- 14Distributed System14A distributed system is a set of computers that work together over a network and appear to their users as a single system.
- 15Domain-Driven Design15Domain-driven design is an approach to building software that models the code closely on the business domain, using the same language as the domain experts.
- 16DRYDon't Repeat Yourself16DRY is a software design principle stating that every piece of knowledge or logic should have one authoritative representation instead of being duplicated.
- 17Event Sourcing17Event sourcing is a design pattern that stores every change to an application's state as an immutable event and rebuilds current state by replaying them.
- 18Event-Driven Architecture18Event-driven architecture is a software design style in which services communicate by producing and reacting to events, such as an order being placed.
- 19Factory Pattern19The factory pattern is a creational design pattern that moves object creation into a dedicated function or class, so callers never name the concrete class.
- 20Fault Tolerance20Fault tolerance is the ability of a system to keep working correctly, perhaps at reduced capacity, when some of its hardware or software components fail.
- 21Hexagonal Architecture21Hexagonal architecture is a way of structuring software so the core business logic talks to the outside world only through ports and swappable adapters.
- 22High Availability22High availability is the ability of a system to stay operational nearly all the time, mainly by removing single points of failure through redundancy.
- 23Horizontal Scaling23Horizontal scaling (scaling out) increases a system's capacity by adding machines and spreading the work across them, rather than making one machine bigger.
- 24KISS PrincipleKeep It Simple, Stupid24The KISS principle is a design guideline stating that systems work best when kept as simple as possible, so developers should avoid unnecessary complexity.
- 25Layered Architecture25Layered architecture splits an application into horizontal layers, such as presentation, business logic, and data access, each calling only the layer below it.
- 26Loose Coupling26Loose coupling is a design principle in which components depend on each other as little as possible, so one can change without breaking the others.
- 27Microservices27Microservices are an architectural style where an application is split into small, independently deployable services that communicate over a network.
- 28Monolith28A monolith is a software application built and deployed as a single unit, where all features share one codebase, one process, and usually one database.
- 29MVCModel–View–Controller29MVC is an architectural pattern that splits an application into a Model for data and logic, a View for display, and a Controller that handles user input.
- 30MVVMModel-View-ViewModel30MVVM (Model-View-ViewModel) is a UI pattern where a ViewModel holds a screen's state and actions and the View binds to it, so the UI follows state changes.
- 31Observer Pattern31The observer pattern is a behavioral design pattern in which an object, the subject, automatically notifies a list of subscribers whenever its state changes.
- 32Peer-to-PeerP2P32Peer-to-peer (P2P) is a network design in which peers connect and share resources directly, each acting as both client and server, with no central server.
- 33Refactoring33Refactoring is the process of restructuring existing code to make it cleaner and easier to maintain without changing what the code does from the outside.
- 34Repository Pattern34The repository pattern hides data access behind a collection-like interface, so business code can load and save objects without knowing where they are stored.
- 35Saga Pattern35The saga pattern runs a transaction spanning several services as a sequence of local steps, undoing completed steps with compensating actions if one fails.
- 36Scalability36Scalability is a system's ability to handle growing amounts of work, such as more users or data, by adding resources without a drop in performance.
- 37Separation of Concerns37Separation of concerns is a design principle that divides a program into distinct parts, each responsible for one clearly defined aspect of its behavior.
- 38Service Discovery38Service discovery is how services in a distributed system find the current addresses of other services, which change as instances start, stop and move.
- 39Service-Oriented Architecture39Service-oriented architecture builds enterprise software from reusable, network-accessible services that communicate with each other through standard contracts.
- 40Sidecar Pattern40The sidecar pattern runs a helper process next to an application, sharing its lifecycle and network, to add features such as logging, proxying or security.
- 41Singleton Pattern41The singleton pattern is a creational design pattern that ensures a class has only one instance and provides a single, global point of access to it.
- 42SOLIDSingle Responsibility, Open–Closed, Liskov Substitution, Interface Segregation, Dependency Inversion42SOLID is a set of five object-oriented design principles that help developers write code that is easier to understand, extend, test, and maintain.
- 43Strangler Fig Pattern43The strangler fig pattern is a way to replace a legacy system gradually by routing features to new code one at a time until the old system can be retired.
- 44Strategy Pattern44The strategy pattern is a behavioral design pattern that puts interchangeable algorithms behind one interface, so code can switch between them at run time.
- 45Technical Debt45Technical debt is the future cost of extra work created when developers choose a quick or limited solution now instead of a better approach that takes longer.
- 46Twelve-Factor App46A twelve-factor app is a web application built according to twelve practices that make it portable, easy to deploy, and simple to scale in the cloud.
- 47Vertical Scaling47Vertical scaling (scaling up) increases a system's capacity by giving a single machine more CPU, memory or faster storage, instead of adding more machines.
- 48YAGNIYou Aren't Gonna Need It48YAGNI is a principle from extreme programming that says not to build a feature or abstraction until you actually need it, rather than because you might later.