Book 09
Software Architecture
Design principles and architectural styles that keep large codebases organized and maintainable.
Contents
- 01Actor Model1The actor model builds concurrent systems from actors: independent units with private state that communicate only by sending each other asynchronous messages.
- 02Adapter Pattern2The 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.
- 03Backend for Frontend3Backend 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.
- 04Builder Pattern4The 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.
- 05Circuit Breaker Pattern5The circuit breaker pattern protects a system by stopping calls to a failing dependency for a while and failing fast instead of waiting on timeouts.
- 06Clean Architecture6Clean architecture is a way of structuring software in layers so that the core business rules never depend on frameworks, databases, or user interfaces.
- 07Client-Server Architecture7Client-server architecture splits a system into clients, which request data or actions, and servers, which provide them, as when a browser requests a page.
- 08Cohesion8Cohesion 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.
- 09Consensus Algorithm9A 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.
- 10Consistent Hashing10Consistent hashing spreads keys across a changing set of servers so that adding or removing a server moves only a small share of the keys.
- 11CQRSCommand Query Responsibility Segregation11CQRS is an architectural pattern that separates the code that changes data, called commands, from the code that reads data, called queries, into two models.
- 12Decorator Pattern12The decorator pattern adds behavior like logging or caching to an object by wrapping it in another with the same interface, without changing the original.
- 13Dependency Injection13Dependency injection is a design technique in which an object receives the other objects it needs from the outside instead of creating them itself.
- 14Design Pattern14A design pattern is a proven, reusable solution to a common problem in software design, described as a general template rather than as finished code.
- 15Distributed System15A distributed system is a set of computers that work together over a network and appear to their users as a single system.
- 16Domain-Driven Design16Domain-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.
- 17DRYDon't Repeat Yourself17DRY is a software design principle stating that every piece of knowledge or logic should have one authoritative representation instead of being duplicated.
- 18Event Sourcing18Event 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.
- 19Event-Driven Architecture19Event-driven architecture is a software design style in which services communicate by producing and reacting to events, such as an order being placed.
- 20Factory Pattern20The factory pattern is a creational design pattern that moves object creation into a dedicated function or class, so callers never name the concrete class.
- 21Fault Tolerance21Fault tolerance is the ability of a system to keep working correctly, perhaps at reduced capacity, when some of its hardware or software components fail.
- 22Hexagonal Architecture22Hexagonal architecture is a way of structuring software so the core business logic talks to the outside world only through ports and swappable adapters.
- 23High Availability23High availability is the ability of a system to stay operational nearly all the time, mainly by removing single points of failure through redundancy.
- 24Horizontal Scaling24Horizontal scaling (scaling out) increases a system's capacity by adding machines and spreading the work across them, rather than making one machine bigger.
- 25KISS PrincipleKeep It Simple, Stupid25The KISS principle is a design guideline stating that systems work best when kept as simple as possible, so developers should avoid unnecessary complexity.
- 26Layered Architecture26Layered architecture splits an application into horizontal layers, such as presentation, business logic, and data access, each calling only the layer below it.
- 27Loose Coupling27Loose coupling is a design principle in which components depend on each other as little as possible, so one can change without breaking the others.
- 28Microservices28Microservices are an architectural style where an application is split into small, independently deployable services that communicate over a network.
- 29Monolith29A monolith is a software application built and deployed as a single unit, where all features share one codebase, one process, and usually one database.
- 30Multi-Tenancy30Multi-tenancy is an architecture in which one running system serves many customers, called tenants, while keeping each tenant's data and settings separate.
- 31MVCModel–View–Controller31MVC 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.
- 32MVVMModel-View-ViewModel32MVVM (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.
- 33Observer Pattern33The observer pattern is a behavioral design pattern in which an object, the subject, automatically notifies a list of subscribers whenever its state changes.
- 34Peer-to-PeerP2P34Peer-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.
- 35Refactoring35Refactoring is the process of restructuring existing code to make it cleaner and easier to maintain without changing what the code does from the outside.
- 36Repository Pattern36The repository pattern hides data access behind a collection-like interface, so business code can load and save objects without knowing where they are stored.
- 37Saga Pattern37The saga pattern runs a transaction spanning several services as a sequence of local steps, undoing completed steps with compensating actions if one fails.
- 38Scalability38Scalability 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.
- 39Separation of Concerns39Separation of concerns is a design principle that divides a program into distinct parts, each responsible for one clearly defined aspect of its behavior.
- 40Service Discovery40Service discovery is how services in a distributed system find the current addresses of other services, which change as instances start, stop and move.
- 41Service-Oriented Architecture41Service-oriented architecture builds enterprise software from reusable, network-accessible services that communicate with each other through standard contracts.
- 42Sidecar Pattern42The sidecar pattern runs a helper process next to an application, sharing its lifecycle and network, to add features such as logging, proxying or security.
- 43Singleton Pattern43The 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.
- 44SOLIDSingle Responsibility, Open–Closed, Liskov Substitution, Interface Segregation, Dependency Inversion44SOLID is a set of five object-oriented design principles that help developers write code that is easier to understand, extend, test, and maintain.
- 45Strangler Fig Pattern45The 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.
- 46Strategy Pattern46The strategy pattern is a behavioral design pattern that puts interchangeable algorithms behind one interface, so code can switch between them at run time.
- 47Technical Debt47Technical 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.
- 48Twelve-Factor App48A 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.
- 49Vertical Scaling49Vertical scaling (scaling up) increases a system's capacity by giving a single machine more CPU, memory or faster storage, instead of adding more machines.
- 50YAGNIYou Aren't Gonna Need It50YAGNI 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.