# Architecture Styles and Patterns

> Architecture styles (layered, pipeline, microkernel, service-based, event-driven, space-based, microservices, ...) and architecture patterns, their trade-offs.

## Concepts

- [Architectural Pattern](https://arc.fuet.ch/concepts/styles-patterns/architectural-pattern.md): An architectural pattern is a proven, reusable solution to a problem that keeps recurring in systems. Its description covers context, problem, solution and consequences, so you can see the trade-offs before you choose.
- [Architectural Pattern vs. Design Pattern](https://arc.fuet.ch/concepts/styles-patterns/architectural-pattern-vs-design-pattern.md): An architectural pattern shapes the structure of a whole system. A design pattern solves a narrower problem in one subsystem. Architectural choices are costly to change later, so they deserve more upfront effort.
- [Architecture Style](https://arc.fuet.ch/concepts/styles-patterns/architectural-style.md): An architecture style is a set of design constraints: which elements may appear and how they may relate. Following the constraints gives a system certain desirable properties. Every style also has costs.
- [Blackboard Pattern](https://arc.fuet.ch/concepts/styles-patterns/blackboard-architecture.md): The blackboard pattern lets independent expert modules build a solution together through one shared memory. A control component decides which module runs next. It began in speech recognition and is now used for LLM agent teams.
- [Broker Pattern](https://arc.fuet.ch/concepts/styles-patterns/broker-pattern.md): The broker pattern organizes a distributed system around one central component. Decoupled parts interact through remote calls, and the broker coordinates them. It forwards requests and returns results and errors. The whole system depends on it.
- [Clean Architecture](https://arc.fuet.ch/concepts/styles-patterns/clean-architecture.md): Clean Architecture arranges code in circles. Source code dependencies point only inward, toward the business rules. Web, database, and frameworks stay on the outside, so the rules can be tested without them.
- [Lambda Architecture](https://arc.fuet.ch/concepts/styles-patterns/lambda-architecture.md): Lambda architecture sends incoming data down two paths. A slow batch path gives accurate results. A fast speed path gives quick, less accurate results. Queries combine both, at the cost of duplicated logic.
- [Layered Architecture](https://arc.fuet.ch/concepts/styles-patterns/layered-architecture.md): Layered architecture splits a system into layers with separate responsibilities. A higher layer may use a lower one, never the reverse. This keeps dependencies orderly and makes parts easier to change, test and reuse.
- [Layers and Components Decomposition](https://arc.fuet.ch/concepts/styles-patterns/layers-and-components-decomposition.md): Layers and components split a system two ways. Layers stack by kind of work, and upper layers use lower ones. Components are vertical slices that each cover one function. Together they form a grid.
- [Layers Pattern](https://arc.fuet.ch/concepts/styles-patterns/layers-pattern.md): The Layers pattern splits software into layers with separate responsibilities. A higher layer may use a lower layer, never the reverse. This keeps dependencies under control, at the cost of some latency and pass-through work.
- [Microkernel Pattern](https://arc.fuet.ch/concepts/styles-patterns/microkernel-pattern.md): A microkernel keeps only the most basic mechanisms in a small core. Everything else runs outside it as ordinary programs. This can help stability, but it costs performance.
- [Microservices Architecture](https://arc.fuet.ch/concepts/styles-patterns/microservices-architecture.md): Microservices split a system into small services, each built around one business capability and deployable on its own. The style gains team autonomy and flexibility, but it adds network, data, and operations costs.
- [Model-View-Controller Pattern](https://arc.fuet.ch/concepts/styles-patterns/model-view-controller-pattern.md): MVC splits an interactive application into a model (the domain), views (output) and controllers (input). Keeping presentation apart from the domain lets several views show the same data.
- [Pipe-and-Filter](https://arc.fuet.ch/concepts/styles-patterns/pipe-and-filter-pattern.md): Pipe-and-Filter splits a big processing job into small, independent steps called filters. Pipes pass each step's output to the next. You can add, remove, or reorder steps, but all steps must agree on the data format.
- [Pipes and Filters](https://arc.fuet.ch/concepts/styles-patterns/pipes-and-filters.md): Pipes and Filters splits a large processing task into small, independent steps called filters. Pipes pass each step's output to the next. You can add, remove, or reorder steps, but the slowest step limits speed.
- [Publish-Subscribe Pattern](https://arc.fuet.ch/concepts/styles-patterns/publish-subscribe-pattern.md): Publish-subscribe lets a sender announce events without knowing who receives them. A broker or event bus copies each event to every interested subscriber. Senders and receivers stay independent, at the cost of latency, weaker ordering, and harder tracing.
- [Service-Oriented Architecture](https://arc.fuet.ch/concepts/styles-patterns/service-oriented-architecture.md): Service-Oriented Architecture (SOA) organizes software as services that consumers reach through defined interfaces. Providers and consumers may belong to different organizations. The term is loose, and a central hub can become a bottleneck.