Merge pull request #77 from isaqb-org/71-chapter-4-integration-method…

…s-protocols-transform-and-enhance-to-new-learning-goal-structure

#71: chapter 4 (integration) revised (was chapter 3), shortened text

docs/03-integration/00-structure.adoc → docs/04-integration/00-structure.adoc

@@ -3,11 +3,11 @@
 // ====================================================
 
 // tag::DE[]
-== Integration
+== Integrationsmethoden & Protokolle
 // end::DE[]
 
 // tag::EN[]
-== Integration
+== Integration methods & protocols
 // end::EN[]
 
 include::01-duration-terms.adoc[{include_configuration}]

docs/04-integration/02-learning-goals.adoc

@@ -0,0 +1,105 @@
+=== {learning-goals}
+
+// tag::DE[]
+[[LZ-4-1]]
+==== LZ 4-1: Integrationsstrategien gegenüberstellen (am Beispiel von DDD Strategic Design)
+
+* Strategic Design aus dem Domain-Driven Design (DDD) und dessen Beziehungspatterns (z. B. Anti-Corruption Layer, Shared Kernel, Customer/Supplier) verstehen und erklären.
+* Modulgrenzen eines Systems anhand von "Bounded Context" darstellen, beschreiben und SOLL/IST-Vergleiche anstellen.
+* Anhand der Qualitätsziele begründen welche Patterns aus dem Strategic Design für eine Integration/Schnittstelle verwendet werden können und welche Patterns nicht.
+
+[[LZ-4-2]]
+==== LZ 4-2: Technische Integrationsmechanismen auswählen und begründen
+
+* Bewertung der Vor- und Nachteile von technischen Integrationsmechanismen wie Frontend-Integration, Middle-Tier Integration (REST, RPC, Messaging) oder Datenbankintegration anhand spezifischer Qualitätsziele des System und notwendiger Erfahrung/Skills der betreuenden Entwicklungsteams.
+* (OPTIONAL) Frontend-Integration (Links, Client-Side Includes, Microfrontends, etc.) und Middleware für Legacy-Systeme sowie deren Auswirkungen vergleichen.
+* (OPTIONAL) Praktische Anwendung in brow-field Szenarien: Integration von Legacy-Datenmodellen durch Transformation und Mapping.
+
+[[LZ-4-3]]
+==== LZ 4-3: Konsistenzmodelle erklären und auswählen (CAP Theorem)
+
+* Erklärung des CAP-Theorems: Abwägung zwischen Konsistenz, Verfügbarkeit und Partitionstoleranz.
+* Notwendigkeit von Partitionstoleranz verstehen.
+* Vergleich von ACID- und BASE-Modellen: Garantien, Verluste und Tradeoffs sowie daraus resultierende Einsatzmöglichkeiten in verteilten Systemen verstehen.
+* Unterschied zwischen "Consistency" bei ACID und BASE anhand praktischer Beispiele erklären.
+* (OPTIONAL) Praxisbeispiel zu ACID-Transaktionen und BASE-Transaktionen in verteilten Systemen.
+* CP- vs. AP-Systemdesign anhand von Qualitätszielen begründen.
+* (OPTIONAL) Praxisbeispiel: Wahl eines geeigneten Konsistenzmodells basierend auf Systemanforderungen wie Latenz und Skalierbarkeit.
+* (OPTIONAL) Produktbeispiele aus unterschiedlichen Kategorien (z. B. NoSQL, Konfigurationswerkzeuge, Service Discovery) kennen.
+
+[[LZ-4-4]]
+==== LZ 4-4: Resilience Patterns benennen
+
+* (OPTIONAL) Messaging Patterns: Request/Reply, Publish/Subscribe und deren Resilience-Eigenschaften.
+* Resilience-Strategien für dezentrale Datenhaltung und redundante Architektur.
+* Unterschiede zwischen High-Availability und Resilience verstehen und Praxisbeispiele nennen
+* (OPTIONAL) Nutzung von Mechanismen wie Circuit Breaker, Bulkhead und Graceful Degradation zur Sicherstellung der Verfügbarkeit in Szenarien, wo Systemteile unterschiedliche Verfügbarkeitsanforderungen haben.
+
+[[LZ-4-5]]
+==== LZ 4-5: Sicherheitsauswirkungen von Integrationsmethoden kennen und berücksichtigen
+
+* (OPTIONAL) Vergleich von Authentifizierungs- und Autorisierungsmechanismen (z. B. OAuth, Kerberos).
+* Auswirkungen von synchroner (z. B. RPC) vs. asynchroner Integration (z. B. Messaging) auf Sicherheit und Datenintegrität.
+* Implementierung sicherer Schnittstellen und Makroarchitektur für verteilte Systeme.
+
+[[LZ-4-6]]
+==== LZ 4-6: (OPTIONAL) Event-getriebene Architekturen kennen und entwerfen
+
+* Einführung in Event-Driven Architectures (EDA): Publizieren von Domain Events zur Entkopplung von Systemen.
+* Entwurf einer EDA mit Messaging-Systemen wie RabbitMQ oder Kafka.
+* Herausforderungen und Lösungen bei Backpressure und dezentraler Datenhaltung.
+
+// end::DE[]
+
+// tag::EN[]
+
+[[LG-4-1]]
+==== LG 4-1: Compare Integration Strategies (Using the Example of DDD Strategic Design)
+
+* Understand and explain Strategic Design from Domain-Driven Design (DDD) and its relationship patterns (e.g., Anti-Corruption Layer, Shared Kernel, Customer/Supplier).  
+* Represent and describe the module boundaries of a system using "Bounded Context" and perform AS-IS/TO-BE comparisons.  
+* Justify which patterns from Strategic Design can or cannot be used for an integration/interface based on quality goals.  
+
+[[LG-4-2]]
+==== LG 4-2: Select and Justify Technical Integration Mechanisms
+
+* Evaluate the advantages and disadvantages of technical integration mechanisms such as frontend integration, middle-tier integration (REST, RPC, Messaging), or database integration based on specific quality goals of the system and the required experience/skills of the development teams.  
+* (Optional) Compare frontend integration (e.g., links, client-side includes, microfrontends) and middleware for legacy systems and their impacts.  
+* (Optional) Practical application in brownfield scenarios: integration of legacy data models through transformation and mapping.  
+
+[[LG-4-3]]
+==== LG 4-3: Explain and Select Consistency Models (CAP Theorem)
+
+* Explain the CAP theorem: trade-offs between consistency, availability, and partition tolerance.  
+* Understand the necessity of partition tolerance.  
+* Compare ACID and BASE models: guarantees, compromises, and trade-offs, as well as their resulting applicability in distributed systems.  
+* Explain the difference between "consistency" in ACID and BASE using practical examples.  
+* (Optional) Provide practical examples of ACID and BASE transactions in distributed systems.  
+* Justify CP vs. AP system design based on quality goals.  
+* (Optional) Practical example: choosing a suitable consistency model based on system requirements such as latency and scalability.  
+* (Optional) Know product examples from different categories (e.g., NoSQL, configuration tools, service discovery).  
+
+[[LG-4-4]]
+==== LG 4-4: Identify and select Resilience Patterns
+
+* (Optional) Messaging Patterns: Request/Reply, Publish/Subscribe, and their resilience properties.  
+* Resilience strategies for decentralized data storage and redundant architecture.  
+* Understand the differences between high availability and resilience and provide practical examples.  
+* (Optional) Use mechanisms like Circuit Breaker, Bulkhead, and Graceful Degradation to ensure availability in scenarios where system components have different availability requirements.  
+* Understand the impact of resilience patterns on well-known operations metrics like MTTR and MTBF and their interdependency with fast delivery of bugfixes/releases.
+
+[[LG-4-5]]
+==== LG 4-5: Understand and Consider Security Implications of Integration Methods
+
+* (Optional) Compare authentication and authorization mechanisms (e.g., OAuth, Kerberos).  
+* Analyze the impact of synchronous (e.g., RPC) vs. asynchronous integration (e.g., Messaging) on security and data integrity.  
+* Implement secure interfaces and macroarchitecture for distributed systems.  
+
+[[LG-4-6]]
+==== LG 4-6: (Optional) Understand and Design Event-Driven Architectures (EDA)
+
+* Introduction to Event-Driven Architectures (EDA): publishing domain events to decouple systems.  
+* Design an EDA with messaging systems like RabbitMQ or Kafka.  
+* Address challenges and solutions for backpressure and decentralized data storage.  
+
+// end::EN[]

docs/curriculum-flex.adoc

@@ -47,7 +47,7 @@ include::01-motivation/00-structure.adoc[{include_configuration}]
 include::02-modularization/00-structure.adoc[{include_configuration}]
 
 <<<
-include::03-integration/00-structure.adoc[{include_configuration}]
+include::04-integration/00-structure.adoc[{include_configuration}]
 
 <<<
 include::05-rollout/00-structure.adoc[{include_configuration}]