Architektura oprogramowania

Różnica między wzorcami architektonicznymi a podejściami architektonicznymi

Wzorzec architektoniczny (ang. architectural pattern)
To sprawdzony schemat organizacji systemu, rozwiązujący konkretne problemy projektowe w określonym kontekście.

• Cechy:
• Jest ogólny i powtarzalny.
• Może być częścią większej architektury.
• Dotyczy struktury i komunikacji komponentów.
• Przykłady:
• MVC (Model-View-Controller)
• MVVM
• MVP
• CQRS
• Event Sourcing
• Broker, Pipe-and-Filter

Podejście architektoniczne (ang. architectural style/approach)
To szeroka filozofia lub paradygmat projektowania systemów informatycznych.

• Cechy:
• Obejmuje całościowe podejście do struktury systemu.
• Dotyczy organizacji całych aplikacji lub systemów rozproszonych.
• Określa sposób podziału systemu na warstwy, moduły, usługi.
• Przykłady:
• Architektura warstwowa (Layered)
• Architektura mikrousługowa (Microservices)
• Architektura heksagonalna (Hexagonal, Ports and Adapters)
• Architektura monolityczna
• Architektura event-driven

----------------------------------------------------------------------------------------------------------------------------- 

Architektury warstwowe

Opierają się na podziale systemu na warstwy logiczne lub fizyczne.

 

Architektura warstwowa (Layered Architecture)
Podejście architektoniczne jak i wzorzec. Dzieli system na logiczne warstwy, takie jak warstwa prezentacji, warstwa biznesowa i warstwa dostępu do danych.

Architektura trójwarstwowa (Three-Tier Architecture)
Wzorzec architektoniczny. UI, logika aplikacji i baza danych jako osobne warstwy fizyczne.

Architektura wielowarstwowa (Multitier Architecture)
Wzorzec architektoniczny. Podobna do warstwowej architektury, ale z podziałem na więcej niż trzy warstwy, co może obejmować warstwę prezentacji, warstwę aplikacji, warstwę biznesową, warstwę danych itp.

Architektury skoncentrowane na domenie: 
Podejścia architektoniczne. To szersze podejście, które kładzie nacisk na model domenowy i logikę biznesową, zwykle obejmuje różne wzorce (np. cebulowa, heksagonalna, czystego kodu).
Architektura cebulowa, Architektura czystego kodu, Architektura heksagonalna, Architektura oparta na self-contained systems 

-----------------------------------------------------------------------------------------------------------------------------

Architektury komponentowe

System składa się z wyraźnie zdefiniowanych, niezależnych części.

Architektura oparta na komponentach (Component-Based Architecture)
System jest podzielony na niezależne komponenty, które są łatwo wymienne i odporne na zmiany.

Architektura oparta na wtyczkach (Plugin Architecture)
Pozwala na dynamiczne rozszerzanie funkcjonalności systemu poprzez dodawanie wtyczek.

Architektura oparta na funkcjonalnościach (Feature-Driven Architecture)
System jest podzielony na funkcjonalności, z których każda jest odpowiedzialna za określoną część biznesową. 

Architektura oparta na obiektach (Object-Based Architecture)
System jest zorganizowany wokół obiektów, a interakcje między nimi są centralne dla architektury. 

Architektura oparta na wrapperach (wrapper-based architecture)
Komponenty systemu są opakowywane (ang. wrapped) przez dodatkowe warstwy pośredniczące – tzw. wrappery – w celu osiągnięcia separacji, kompatybilności, elastyczności lub rozszerzalności.

Architektura oparta na różnorodności (Diversity-Based Architecture)
Stawia na różnorodność komponentów i podejść w systemie w celu zwiększenia odporności i elastyczności. Ten sam komponent logiczny implementowany jest na wiele sposobów (np. przez różne zespoły, w różnych językach programowania). Stosowane w lotnictwie, systemach nuklearnych i kosmicznych.

-----------------------------------------------------------------------------------------------------------------------------

 Architektury mikrostruktur

Architektura mikrousługowa (Microservices Architecture)
Rozbicie systemu na mniejsze, niezależne mikrousługi, które komunikują się ze sobą poprzez API. Ułatwia skalowanie i utrzymanie systemu.  

Architektura mikrofrontendowa (Micro-Frontend Architecture)
Frontend podzielony na mniejsze, niezależne moduły (analogicznie do mikrousług).

Architektura oparta na agregatach (Aggregate-Oriented Architecture)
Koncentruje się na grupowaniu danych w agregaty, co ułatwia skalowanie i zarządzanie danymi w systemie.

Architektura oparta na self-contained systems (SCS)
To wzorzec architektoniczny, struktura kodu i zależności
System jest podzielony na samodzielne moduły, które zawierają wszystko, co jest potrzebne do działania, włącznie z własnym interfejsem użytkownika i bazą danych. 
SCS skupia się na podziale domeny na mniejsze, niezależne systemy. Każdy Self-Contained System implementuje swoją własną domenę (lub jej fragment). SCS to raczej podejście do modularności i autonomii domenowych systemów niż wzorzec modelowania samej domeny. 

Architektura oparta na komórkach (Cellular Architecture)
System jest podzielony na małe komórki, które mogą działać niezależnie, ale również współpracować ze sobą.

Architektura oparta na modelu aktorów (Actor Model Architecture)
Modeluje interakcje między komponentami jako aktorów, którzy przetwarzają komunikaty asynchronicznie. 

Architektura oparta na wielodomenowości (Multidomain Architecture)
Działa w kontekście systemów, które muszą współpracować ze sobą, ale są odpowiedzialne za różne dziedziny biznesowe. 

----------------------------------------------------------------------------------------------------------------------------- 

Architektury zdecentralizowane / rozproszone 

System nie jest zorganizowany wokół jednego centralnego komponentu.

Architektura mikrousługowa (Microservices Architecture)
Rozbicie systemu na mniejsze, niezależne mikrousługi, które komunikują się ze sobą poprzez API. Ułatwia skalowanie i utrzymanie systemu. 

Architektura P2P (Peer-to-Peer Architecture)
System, w którym każdy komputer (lub "peer") ma równoważną rolę, współpracując bez centralnego zarządzania.Węzły są równorzędne – np. BitTorrent, blockchain.  

Architektura typu Hub and Spoke
Istnieje centralny punkt (hub) odpowiedzialny za koordynację i komunikację, oraz wiele odnóg (spoke) – niezależnych, wyspecjalizowanych komponentów/systemów.

Architektura brokerowa (Broker Architecture)
Komponenty komunikują się przez pośrednika (np. message broker).

Architektura oparta na funkcjach (Function as a Service - FaaS)
Podobna do architektury bezserwerowej, gdzie funkcje są jednostką podstawową, ale w przypadku FaaS są wywoływane na żądanie.

Architektura oparta na usługach (Service-Oriented Architecture - SOA)
System jest rozbity na usługi, które są niezależne i mogą być używane przez różne części systemu.

Architektura oparta na inteligencji rozwieszonej (Distributed Intelligence Architecture)
System jest zaprojektowany tak, aby posiadał inteligencję rozproszoną, umożliwiającą skoordynowane działanie wielu komponentów.

Architektura oparta na pozycji (Location-Based Architecture)
Działa w oparciu o położenie fizyczne komponentów systemu, co jest istotne w przypadku systemów rozproszonych i mobilnych.

Architektura oparta na rozproszonym konsensusie (Distributed Consensus Architecture)
Wykorzystuje algorytmy konsensusu do koordynacji działań między rozproszonymi komponentami systemu.

Architektura oparta na przetwarzaniu na krańcach (Edge Computing Architecture)
Wykorzystuje zasoby przetwarzania na krańcach sieci w celu zoptymalizowania wydajności systemu.

Architektura oparta na zasobach (Resource-Based Architecture)
System jest projektowany wokół zasobów, a dostęp do nich jest zarządzany poprzez interfejsy API.

Architektura oparta na interfejsach API (API-First Architecture)
Kładzie nacisk na projektowanie interfejsów API jako centralnego elementu systemu.

Architektura oparta na transakcjach (Transaction-Based Architecture)
Zarządza transakcjami między różnymi komponentami systemu.
-----------------------------------------------------------------------------------------------------------------------------

Architektury komunikacyjne / pośredniczące 

Koncentrują się na przepływie informacji i separacji nadawcy/odbiorcy. 

Architektura brokerowa (Broker Architecture)
Komponenty komunikują się przez pośrednika (np. message broker). 

Architektura proxy (Proxy-Based Architecture)
Wykorzystuje proksy, aby pośredniczyć w dostępie do zasobów, co może pomagać w kontrolowaniu dostępu i bezpieczeństwie. 

Architektura pipeline'owa (Pipe and Filter)
Dane przepływają przez kolejne „filtry”, które je przetwarzają (np. w systemach ETL). 

Architektura oparta na harmonogramie zadań (Job Scheduling Architecture)
System jest zoptymalizowany do efektywnego harmonogramowania i wykonywania zadań w określonych momentach.

Architektura typu Hub and Spoke
Istnieje centralny punkt (hub) odpowiedzialny za koordynację i komunikację, oraz wiele odnóg (spoke) – niezależnych, wyspecjalizowanych komponentów/systemów.

Architektura zdarzeniowa (Event-Driven Architecture)
Komponenty systemu komunikują się poprzez wysyłanie i odbieranie zdarzeń. Sprzyja elastyczności i skalowalności systemu.

Architektura oparta na strumieniach zdarzeń (Event Stream Architecture)
Wykorzystuje strumienie zdarzeń do komunikacji między komponentami systemu. 

Architektura oparta na zdarzeniach biznesowych (Business Event-Driven Architecture)
Koncentruje się na obsłudze zdarzeń biznesowych, co ułatwia reakcję systemu na zmiany w biznesie. 

Architektura oparta na kolejce (Message Queue Architecture)
Wykorzystuje kolejki komunikatów do asynchronicznego przekazywania informacji między komponentami systemu.

Architektura oparta na komunikatach (Communicating Sequential Processes - CSP)
Modeluje interakcje między komponentami za pomocą komunikatów, co ułatwia projektowanie równoległych i współbieżnych systemów.

Architektura oparta na protokołach (Protocol-Based Architecture)
Określa strukturę komunikacji między komponentami systemu poprzez zdefiniowanie protokołów komunikacyjnych. 

Architektura oparta na strumieniach danych (Data Stream Architecture)
Wykorzystuje przepływy danych do przetwarzania informacji w czasie rzeczywistym. 

Architektura oparta na opływach informacji (Flow-Based Architecture)
Koncentruje się na przepływie informacji przez system i związanych z tym transformacjach.

Architektura oparta na równoważeniu obciążeń (Load Balancing Architecture)
Zapewnia równomierne rozłożenie obciążenia między różnymi komponentami systemu, co pomaga w utrzymaniu wydajności.

Architektura oparta na reaktywności (Reactive Architecture)
Projektowanie systemu, aby był skalowalny, elastyczny i odporny na błędy, poprzez reaktywne podejście do przetwarzania danych i reakcji na zdarzenia. 

Architektura oparta na strumieniach komunikatów (Message Streaming Architecture)
Wykorzystuje przepływy komunikatów do asynchronicznego przetwarzania i przesyłania informacji.

Architektura oparta na modelu aktorów (Actor Model Architecture)
Modeluje interakcje między komponentami jako aktorów, którzy przetwarzają komunikaty asynchronicznie.

Architektura oparta na strumieniach zdarzeń biznesowych (Business Event Streaming Architecture)
Skupia się na przetwarzaniu i analizie strumieni zdarzeń biznesowych w czasie rzeczywistym. 

Architektura oparta na asynchroniczności (Asynchronous Architecture)
Skupia się na asynchronicznej komunikacji między komponentami, co pomaga w zminimalizowaniu opóźnień i poprawie wydajności.

Architektura oparta na równoczesnym przetwarzaniu (Concurrency-Based Architecture)
Projektuje system z myślą o efektywnym przetwarzaniu równoczesnym.

Architektura oparta na modelu zdarzeń (Event-Model Architecture)
Modeluje interakcje w systemie za pomocą zdarzeń, ułatwiając analizę i reakcję.

Architektura oparta na podejściu bezstanowym (Stateless Architecture)
Każde żądanie od klienta jest obsługiwane niezależnie od poprzednich żądań, co ułatwia skalowanie.

Architektura oparta na integracji (Integration-Based Architecture)
Skupia się na efektywnej integracji różnych komponentów i systemów.

Architektura klient-serwer (Client-Server Architecture)
System jest podzielony na dwie główne części: klienta, który dostarcza interfejs użytkownika, i serwera, który obsługuje logikę biznesową i przechowuje dane. Klient wysyła żądania, serwer odpowiada (np. klasyczne aplikacje webowe).

Architektura trójwarstwowa (Three-Tier Architecture)
UI, logika aplikacji i baza danych jako osobne warstwy fizyczne. 

Architektura RESTful
Styl architektury oparty na HTTP i zasobach (często błędnie utożsamiany z API).

Architektura klient-serwer (Client-Server Architecture)
System jest podzielony na dwie główne części: klienta, który dostarcza interfejs użytkownika, i serwera, który obsługuje logikę biznesową i przechowuje dane. Klient wysyła żądania, serwer odpowiada (np. klasyczne aplikacje webowe). 

Architektura RPC (Remote Procedure Call)
RPC to styl komunikacji, w którym jedna aplikacja może wywołać funkcję na innej maszynie tak, jakby była lokalna.

Architektura gRPC (Google Remote Procedure Call)
gRPC to nowoczesna, wysokowydajna implementacja RPC od Google, oparta na HTTP/2 i Protocol Buffers (protobuf).

Architektura GraphQL
GraphQL to alternatywa dla REST, stworzona przez Facebooka, gdzie klient decyduje, jakie dane chce otrzymać w jednym zapytaniu.

----------------------------------------------------------------------------------------------------------------------------- 

Architektury uproszczające konfigurację / development 

Upraszczają pracę dewelopera, często kosztem elastyczności. 

Architektura monolityczna (Monolithic Architecture)
Cała aplikacja jest zbudowana jako jeden blok, co może ułatwić rozwój, ale może prowadzić do trudności w skalowaniu i utrzymaniu.

Architektura oparta na konwencji (Convention Over Configuration Architecture)
Stawia na stosowanie konwencji w celu minimalizacji konieczności konfiguracji. 

------------------------------------------------------------------------------------------------------------------------------ 

Architektury skoncentrowane na domenie (Domain-Centric Architectures) 

Architektury, w których najważniejsza jest logika biznesowa i model domenowy. Ich wspólnym celem jest oddzielenie reguł domeny od technologii, frameworków i infrastruktury.


Architektura zorientowana na domenę (Domain-Driven Design, DDD-based Architecture)
To filozofia/model myślenia o budowie systemów skoncentrowanych na domenie biznesowej.
To zestaw zasad i praktyk do projektowania oprogramowania skupionego na zrozumieniu i odwzorowaniu rzeczywistej domeny biznesowej.
Nie jest architekturą techniczną to raczej sposób patrzenia na problem i sposób projektowania domeny.
Centralne miejsce zajmuje model domenowy i logika biznesowa. Skupia się na zrozumieniu dziedziny biznesowej i mapowaniu jej na strukturę systemu. 

Architektura cebulowa (Onion Architecture)
To wzorzec architektoniczny, struktura kodu i zależności
Wariant DDD: warstwy koncentryczne wokół domeny.
W Onion Architecture rdzeń (centrum cebuli) to warstwa domenowa zawiera encje, modele domenowe i logikę biznesową.
Warstwa domeny jest absolutnie niezależna od technologii, frameworków czy infrastruktury.
Warstwa domenowa (Core Domain) jest otoczona kolejnymi pierścieniami: 
    Warstwa aplikacji (Application Services) — realizuje przypadki użycia domeny.
    Warstwa infrastruktury (Infrastructure) — integracje, bazy danych, zewnętrzne systemy.
    Warstwa prezentacji (UI) — interfejs użytkownika.

Architektura czystego kodu (Clean Architecture)
To wzorzec architektoniczny, struktura kodu i zależności
Domena w centrum, z wyraźnym rozdziałem zależności.
Skupia się na ochronie i izolacji modelu domenowego oraz logiki biznesowej od reszty systemu.
Warstwa domenowa jest niezależna od frameworków, baz danych, interfejsów użytkownika.
Dzięki temu ułatwia rozwój, testowanie i utrzymanie aplikacji z silnym naciskiem na domenę. 

Architektura heksagonalna (Hexagonal Architecture, Ports and Adapters)
To wzorzec architektoniczny, struktura kodu i zależności
Izoluje logikę domenową od zewnętrznych zależności, takich jak baza danych czy interfejs użytkownika, za pomocą portów i adapterów.
Hexagonal Architecture nie jest samą domeną, ale to wzorzec, który pozwala domenie być „czystą”, niezależną od infrastruktury i technologii. Dzięki portom i adapterom możemy wymieniać implementacje zewnętrzne, ale logika biznesowa pozostaje stabilna i spójna. To ułatwia realizację podejścia Domain-Driven Design i wzmacnia model domenowy.

Architektura oparta na self-contained systems (SCS)
To wzorzec architektoniczny, struktura kodu i zależności
System jest podzielony na samodzielne moduły, które zawierają wszystko, co jest potrzebne do działania, włącznie z własnym interfejsem użytkownika i bazą danych. 
SCS skupia się na podziale domeny na mniejsze, niezależne systemy. Każdy Self-Contained System implementuje swoją własną domenę (lub jej fragment). SCS to raczej podejście do modularności i autonomii domenowych systemów niż wzorzec modelowania samej domeny.

Architektura oparta na kontekście biznesowym (Business Context Architecture)
Projektuje system, aby był zorientowany na biznes, z uwzględnieniem kontekstu i celów biznesowych.

Architektura oparta na zdolnościach (Capability-Based Architecture)
Skupia się na definiowaniu i zarządzaniu zdolnościami systemu. 

Architektura oparta na językach domenowych (Domain-Specific Language - DSL Architecture)
Tworzy specjalne języki domenowe, które ułatwiają komunikację między różnymi komponentami systemu.

------------------------------------------------------------------------------------------------------------------------------ 

Architektury chmurowe / zorientowane na środowisko wykonawcze

Skupiają się na sposobie uruchamiania, skalowania i utrzymywania aplikacji – w szczególności w środowiskach cloud-native.


Architektura serwerless (Serverless Architecture) 
System oparty na funkcjach (FaaS), bez zarządzania serwerami. System oparty na funkcjach bezserwerowych, gdzie infrastruktura zarządzana jest przez dostawcę chmury, a programiści skupiają się na kodzie funkcji. 

Architektura oparta na funkcjach (Function as a Service - FaaS)
Podobna do architektury bezserwerowej, gdzie funkcje są jednostką podstawową, ale w przypadku FaaS są wywoływane na żądanie.

Architektura oparta na chmurze (Cloud-Native Architecture)
Projektowanie z myślą o elastyczności, dostępności i skalowalności w chmurze.

Architektura oparta na kontenerach (Container-Based Architecture)
Wykorzystuje technologie kontenerów, takie jak Docker, do izolacji i dostarczania oprogramowania w jednolitym środowisku. 

Architektura oparta na kontenerach izolowanych (Isolated Container Architecture)
Wykorzystuje kontenery do izolowania i zabezpieczania komponentów systemu.

------------------------------------------------------------------------------------------------------------------------------ 

Architektury sterujące stanem, regułami lub zachowaniem

Skupione na tym, jak system reaguje i podejmuje decyzje.


Architektura oparta na regułach (Rule-Based Architecture)
System jest zbudowany wokół zestawu reguł, które decydują o zachowaniach w różnych scenariuszach.

Architektura oparta na aspektach (Aspect-Oriented Architecture)
Separuje różne aspekty systemu, takie jak logika transakcji czy bezpieczeństwo, umożliwiając łatwe zarządzanie aspektami globalnymi.

Architektura oparta na kontekstach (Context-Oriented Architecture)
Działa w oparciu o konteksty, umożliwiając dostosowywanie funkcjonalności systemu do zmieniającego się otoczenia.
Pozwala systemowi dostosowywać swoje zachowanie i funkcjonalność dynamicznie w zależności od aktualnego kontekstu — czyli sytuacji, otoczenia, stanu użytkownika czy warunków zewnętrznych.

Architektura Command Query Responsibility Segregation (CQRS)
Oddzielenie zapytań od komend (często łączone z Event Sourcingiem).

Architektura Event Sourcing 
Stan systemu oparty wyłącznie na sekwencji zdarzeń.

Architektura oparta na scenariuszach (Scenario-Based Architecture)
Projektuje system z myślą o różnych scenariuszach użycia, co ułatwia dostosowanie do różnych przypadków użycia.

Architektura Blackboard
Komponenty współpracują poprzez wspólną "tablicę wiedzy" – np. w AI, regułach.

------------------------------------------------------------------------------------------------------------------------------ 

Architektury zorientowane na bezpieczeństwo / dostęp

Skupione na uprawnieniach i izolacji.


Architektura oparta na uprawnieniach (Capability-Based Security Architecture)
Zarządza dostępem do funkcji systemu na podstawie zdolności użytkownika. 

Architektura oparta na wrapperach (wrapper-based architecture)
Komponenty systemu są opakowywane (ang. wrapped) przez dodatkowe warstwy pośredniczące – tzw. wrappery – w celu osiągnięcia separacji, kompatybilności, elastyczności lub rozszerzalności.

Architektura proxy (Proxy-Based Architecture)
Wykorzystuje proksy, aby pośredniczyć w dostępie do zasobów, co może pomagać w kontrolowaniu dostępu i bezpieczeństwie. 

Architektura oparta na aspektach (Aspect-Oriented Architecture)
Separuje różne aspekty systemu, takie jak logika transakcji czy bezpieczeństwo, umożliwiając łatwe zarządzanie aspektami globalnymi.

Architektura oparta na kontroli dostępu (Access Control Architecture)
Skupia się na zabezpieczeniach i zarządzaniu dostępem do zasobów w systemie.

Architektura oparta na zarządzaniu identycznością (Identity Management Architecture)
Skupia się na zarządzaniu tożsamością użytkowników, dostępu i uprawnień w systemie.

Architektura oparta na politykach (Policy-Based Architecture)
Wprowadza mechanizmy zarządzania na podstawie określonych polityk. 

------------------------------------------------------------------------------------------------------------------------------

Architektury graficzne / wizualne

System opisany za pomocą struktur graficznych lub diagramów.


Architektura oparta na grafie (Graph-Based Architecture)
Struktura systemu jest reprezentowana jako graf, co ułatwia analizę i zarządzanie zależnościami między komponentami.

Architektura oparta na wykresach (Chart-Based Architecture)
Struktura systemu jest reprezentowana za pomocą różnych wykresów, co ułatwia zrozumienie i dokumentowanie architektury.

------------------------------------------------------------------------------------------------------------------------------

Architektury oparte na danych i modelach 

System jako struktura do modelowania, przetwarzania i eksploracji danych.


Architektura oparta na analizie danych (Data-Centric Architecture)
Koncentruje się na efektywnym gromadzeniu, przetwarzaniu i prezentowaniu danych.

Architektura oparta na modelowaniu (Model-Driven Architecture - MDA)
Wykorzystuje modele jako centralne elementy architektury, co pozwala na automatyzację generowania kodu. 

Architektura oparta na semantyce (Semantic Architecture)
Koncentruje się na znaczeniu informacji, co ułatwia zrozumienie i współpracę między komponentami systemu.

Architektura oparta na zasobach (Resource-Based Architecture)
System jest projektowany wokół zasobów, a dostęp do nich jest zarządzany poprzez interfejsy API.

Architektura oparta na magazynach danych (Data Warehouse Architecture)
Koncentruje się na centralnym repozytorium danych — tzw. hurtowni danych — służącym do konsolidacji, integracji i analizy danych pochodzących z różnych źródeł. Stosowana jest głównie w systemach Business Intelligence (BI) oraz raportowania i analizy danych historycznych.

Architektura oparta na maszynowym uczeniu (ML-Based Architecture)
Centralnie uwzględniają modele uczenia maszynowego jako komponenty systemowe, a nie tylko jako dodatek analityczny. Jej celem jest dostarczanie funkcjonalności opartych na predykcji, klasyfikacji, wykrywaniu anomalii, personalizacji itp., często w sposób automatyczny i ciągły. 

Architektura oparta na planie strategicznym (Strategic Planning Architecture)
System jest projektowany z myślą o długoterminowych celach i planach strategicznych organizacji.

Architektura oparta na scenariuszach (Scenario-Based Architecture)
Projektuje system z myślą o różnych scenariuszach użycia, co ułatwia dostosowanie do różnych przypadków użycia.

Architektura oparta na regułach biznesowych (Business Rules Architecture)
Centralizuje i zarządza regułami biznesowymi w systemie. 

Architektura oparta na zasobach (Resource-Based Architecture)
Koncentruje się na zarządzaniu i dostępie do zasobów, takich jak pliki, bazy danych, czy usługi. 

------------------------------------------------------------------------------------------------------------------------------ 

Architektury zorientowane na cele i rezultaty (Goal-/Outcome-Oriented Architectures)

Projektuje się systemy, które niekoniecznie mają ustaloną strukturę, ale dążą do osiągnięcia określonych efektów, np. spełnienia celów biznesowych, spełnienia kontraktów SLA, dostarczenia wartości użytkownikowi. 


Architektura oparta na efektach (Effect-Based Architecture)
Skupia się na efektach i rezultatach, jakie system ma osiągnąć, bardziej niż na konkretnych mechanizmach czy komponentach. 

Architektura oparta na kontekście biznesowym (Business Context Architecture)
Projektuje system, aby był zorientowany na biznes, z uwzględnieniem kontekstu i celów biznesowych.

Architektura oparta na analizie ryzyka (Risk-Driven Architecture)
Projektuje system tak, aby minimalizować ryzyko związane z projektowaniem, wdrażaniem i utrzymaniem. 

Architektura oparta na kontroli kosztów (Cost-Control Architecture)
Projektuje system tak, aby minimalizować koszty związane z jego utrzymaniem i eksploatacją. 

Architektura oparta na różnorodności (Diversity-Based Architecture)
Stawia na różnorodność komponentów i podejść w systemie w celu zwiększenia odporności i elastyczności. Ten sam komponent logiczny implementowany jest na wiele sposobów (np. przez różne zespoły, w różnych językach programowania). Stosowane w lotnictwie, systemach nuklearnych i kosmicznych. 

------------------------------------------------------------------------------------------------------------------------------

Architektury operacyjne i systemowe 

Skupione na automatyzacji, konfiguracji, monitorowaniu, utrzymaniu i zarządzaniu systemem jako całością.

Architektura oparta na automatyzacji (Automation-Based Architecture)
Koncentruje się na automatyzacji procesów w celu usprawnienia zarządzania i utrzymania systemu.

Architektura oparta na monitoringu (Monitoring-Based Architecture)
Umieszcza duży nacisk na monitorowanie systemu, co ułatwia diagnozowanie problemów i utrzymanie.

Architektura oparta na konfiguracji (Configuration-Based Architecture)
Umożliwia dostosowanie i konfigurację systemu poprzez ustawienia zdefiniowane w plikach konfiguracyjnych.

Architektura oparta na ciągłej dostawie (Continuous Delivery Architecture)
Projektuje system tak, aby umożliwić ciągłą dostawę i wdrażanie oprogramowania.

Architektura oparta na kontroli kosztów (Cost-Control Architecture)
Projektuje system tak, aby minimalizować koszty związane z jego utrzymaniem i eksploatacją.  

Architektura oparta na kontroli wersji (Version Control Architecture)
Zarządza i śledzi wersje komponentów systemu, ułatwiając zarządzanie zmianami.

Architektura oparta na automatycznym dostosowywaniu (Autonomic Computing Architecture)
System jest projektowany tak, aby mógł samodzielnie dostosowywać się do zmieniających się warunków i wymagań.

Architektura oparta na wirtualizacji (Virtualization-Based Architecture)
Wykorzystuje technologie wirtualizacji do izolacji i zarządzania zasobami systemowymi. 

------------------------------------------------------------------------------------------------------------------------------

Architektury analityczne i predykcyjne 

Skoncentrowane na analizie danych, przewidywaniu i adaptacji systemu na podstawie obserwacji. 

Architektura oparta na analizie zachowania (Behavior Analysis Architecture)
Analizuje zachowanie systemu w czasie rzeczywistym, umożliwiając dynamiczną adaptację do zmian.

Architektura oparta na eksploracji danych (Data Exploration Architecture)
Umożliwia badanie i analizę danych w celu pozyskania nowych informacji. 

Architektura oparta na przewidywaniu (Prediction-Based Architecture)
Wykorzystuje modele przewidywania w celu dostosowania systemu do zmieniających się warunków.

Architektura oparta na rozpoznawaniu wzorców (Pattern Recognition Architecture)
Wykorzystuje techniki rozpoznawania wzorców w celu analizy danych i podejmowania decyzji.

Architektura oparta na analizie ryzyka (Risk-Driven Architecture)
Projektuje system tak, aby minimalizować ryzyko związane z projektowaniem, wdrażaniem i utrzymaniem. 

Architektura oparta na wizualizacji (Visualization-Based Architecture)
Skupia się na prezentacji danych i informacji w sposób zrozumiały dla użytkowników.

Architektura oparta na efektach (Effect-Based Architecture)
Skupia się na efektach i rezultatach, jakie system ma osiągnąć, bardziej niż na konkretnych mechanizmach czy komponentach.

Architektura oparta na maszynowym uczeniu (Machine Learning Architecture)
Wykorzystuje techniki uczenia maszynowego w celu automatyzacji procesów lub podejmowania decyzji w systemie. 

Architektura oparta na algorytmach ewolucyjnych (Evolutionary Algorithm Architecture)
System ewoluuje w odpowiedzi na zmieniające się warunki, wykorzystując algorytmy ewolucyjne. 

------------------------------------------------------------------------------------------------------------------------------ 

Architektury sterujące przepływem danych i mutacją stanu

Skoncentrowane na organizacji przepływu danych, transformacji, propagacji zmian i kontroli nad ewolucją stanu systemu. Kluczowe w systemach reaktywnych, strumieniowych i opartych na zdarzeniach.

Architektura Event Sourcing 
Stan systemu oparty wyłącznie na sekwencji zdarzeń.

Architektura Command Query Responsibility Segregation (CQRS)
Oddzielenie zapytań od komend (często łączone z Event Sourcingiem).

Stream Processing Architecture
Przetwarzanie danych w czasie rzeczywistym w postaci ciągłych strumieni (np. Kafka Streams, Apache Flink).

Architektura zdarzeniowa (Event-Driven Architecture)
Komponenty systemu komunikują się poprzez wysyłanie i odbieranie zdarzeń. Sprzyja elastyczności i skalowalności systemu. Komponenty reagują na zdarzenia, zmiany propagowane przez brokery lub kolejki wiadomości.

Architektura Blackboard
Komponenty współpracują poprzez wspólną "tablicę wiedzy" – np. w AI, regułach. Komponenty modyfikują wspólną przestrzeń wiedzy; decyzje wynikają z reakcji na zmiany.

State Machine-Based Architecture
Jawne modelowanie przejść stanów i logiki zmiany stanu (FSM, HFSM, workflow engines).

Reactor Pattern / Reactor Architecture
Sterowanie przepływem danych w reakcji na zdarzenia (np. w systemach niskopoziomowych, I/O, UI).

Functional Reactive Programming (FRP)
Deklaratywna architektura propagacji zmian i transformacji strumieni czasowych.

Architektura oparta na strumieniach komunikatów (Message Streaming Architecture)
Wykorzystuje przepływy komunikatów do asynchronicznego przetwarzania i przesyłania informacji.

Architektura oparta na regułach (Rule-Based Architecture)
System jest zbudowany wokół zestawu reguł, które decydują o zachowaniach w różnych scenariuszach.

Workflow-Based Architecture
Logika przepływu kontrolowana przez zdefiniowane procesy i kroki (np. BPMN, Camunda).

------------------------------------------------------------------------------------------------------------------------------  

 Architektury poznawcze / AI-centric

Skoncentrowane na modelowaniu procesów poznawczych, podejmowaniu decyzji i uczeniu się. Wzorowane na ludzkim rozumowaniu, łączą elementy percepcji, pamięci, planowania i adaptacji.
 

Architektura Blackboard
Komponenty współpracują poprzez wspólną "tablicę wiedzy" – np. w AI, regułach. Komponenty modyfikują wspólną przestrzeń wiedzy; decyzje wynikają z reakcji na zmiany.

Architektura oparta na regułach (Rule-Based Architecture)
System jest zbudowany wokół zestawu reguł, które decydują o zachowaniach w różnych scenariuszach.

Architektura oparta na rozpoznawaniu wzorców (Pattern Recognition Architecture)
Wykorzystuje techniki rozpoznawania wzorców w celu analizy danych i podejmowania decyzji.

Architektura oparta na semantyce (Semantic Architecture)
Koncentruje się na znaczeniu informacji, co ułatwia zrozumienie i współpracę między komponentami systemu.

Architektura oparta na maszynowym uczeniu (Machine Learning Architecture)
Wykorzystuje techniki uczenia maszynowego w celu automatyzacji procesów lub podejmowania decyzji w systemie.  

Architektura oparta na algorytmach ewolucyjnych (Evolutionary Algorithm Architecture)
System ewoluuje w odpowiedzi na zmieniające się warunki, wykorzystując algorytmy ewolucyjne.

Architektury modelujące ludzkie poznanie (Cognitive Architecture)
Architektury modelujące ludzkie poznanie. Zastosowanie m.in. w robotyce, symulacji ludzkich zachowań, sztucznej świadomości. ACT-R, SOAR, Sigma, LIDA, ICARUS, CLARION

------------------------------------------------------------------------------------------------------------------------------   

Materiały:

https://www.mindinventory.com/blog/software-architecture-patterns/