- added exercise for lecture 3

.vscode/mcp.json

@@ -0,0 +1,9 @@
+{
+	"servers": {
+		"datalake-fhgr": {
+			"url": "https://datalake-fhgr-mcp.aeol.in",
+			"type": "http"
+		}
+	},
+	"inputs": []
+}

Folien/AISE502_Vorlesung_3_Folien.tex

@@ -649,6 +649,24 @@ Status: accepted | supersedes ADR-004\\[4pt]
 \end{columns}
 \end{frame}
 
+\section{Excercise}
+\begin{frame}{This week's exercise: architecture draft}
+\begin{projektbox}
+\footnotesize Come up with a architecture draft for your project, considering the patterns discussed earlier.
+\begin{itemize}\setlength\itemsep{1pt}
+    \item Identify potential system boundaries
+    \item Sketch the main components and their interactions with eachother
+    \item Discuss which architectural patterns are ruled out by your requirements profile $R(a)$ and constraints
+    \item Justify your choices based on the requirements profile and constraints
+    \item Create a UML System Diagram of your proposed components and their interactions
+\end{itemize}
+\textbf{Deliverable:} UML System Diagram and documentation justifying your architectural choices
+\end{projektbox}
+\vspace{0.15cm}
+\begin{hinweisbox}
+\small Not a warm-up: the architecture will be used to implement your project, later modifications are possible but will lead to increased effort and potential reworks.
+\end{hinweisbox}
+\end{frame}
 % ============================================
 % END
 % ============================================

Folien/Zusammenfassung_Vorlesungen_1-14.md

@@ -0,0 +1,99 @@
+# AISE502: Lecture Overview
+
+## Lecture 1: Architecture as a Decision Problem
+- Understand architecture as the design, justification, and operation of software structure over time.
+- Learn the framework elements: demand, supply, matching rule, decision record, and measurement contract.
+- Distinguish significant, hard-to-reverse architecture decisions from ordinary implementation choices.
+- Compare production systems and see how architectural strengths depend on context.
+- Understand the project, assessment, assumptions, and the two AI dimensions.
+
+## Lecture 2: The Twelve Dimensions and Measurable Requirements
+- Learn the twelve quality dimensions, including scalability, latency, integrity, availability, security, cost, and AI integrability.
+- Understand why quality attributes need instruments and measurable response measures.
+- Turn stakeholder wishes into scenarios and architecturally significant requirements.
+- Build a utility tree and assign High, Medium, and Low weights.
+- Assemble a requirements profile from weights, workload shape, and hard constraints.
+
+## Lecture 3: Supply, Matching, and Decision Records
+- Survey seven patterns: Layered, Modular Monolith, Hexagonal, Microservices, Event-Driven, Pipes-and-Filters, and Serverless.
+- Learn how tactics and structural mechanisms produce capability ratings.
+- Apply the three-stage, non-compensatory fit procedure to an advisory platform.
+- Understand why High requirements can act as veto conditions rather than being averaged away.
+- Record architecture choices with ADR/MADR and a measurement contract.
+
+## Lecture 4: Patterns I
+- Understand Layered Architecture and the cost of cross-layer changes.
+- Learn how a Modular Monolith combines one deployment with domain-oriented module boundaries.
+- Learn Hexagonal Architecture and dependency inversion through a technology-neutral domain core.
+- Derive quality profiles from topology, tactics, engineering implications, and operations.
+- Identify anti-patterns, measurable alarms, and suitable application contexts.
+
+## Lecture 5: Patterns II
+- Understand Microservices as independently deployable business-capability quanta with service-owned data.
+- Analyse the benefits and costs of microservices, including team scaling and distributed failure.
+- Distinguish sagas and compensating actions from genuine rollback.
+- Understand Event-Driven Architecture as temporal decoupling through an intermediary.
+- Apply timeouts, retries, circuit breakers, and fallbacks at distributed boundaries.
+
+## Lecture 6: Pipelines, Serverless, and the C10 Class
+- Understand Pipes-and-Filters for reproducible and composable batch, data, retrieval, and ML pipelines.
+- Understand Serverless/FaaS, including scale-to-zero, cold starts, and cost behaviour under sustained load.
+- Compare all seven patterns and understand why partitioning can be preferable to distribution.
+- Analyse the AI-native advisory-platform class C10 and its inherited requirements.
+- Perform an initial match and justify a hexagonal modular monolith with pipeline and event-driven edges.
+
+## Lecture 7: Formal Fit and the Matching Matrix
+- Work through examples of the shape gate, veto rule, and holistic ordinal comparison.
+- Formalise the three-stage fit procedure and its non-compensatory logic.
+- Interpret individual cells and the complete 7 x 10 matching matrix.
+- Read the matrix by rows and columns and understand the role of hybrid architectures.
+- Introduce fitness functions, DORA metrics, and the measurement contract.
+
+## Lecture 8: Application Classes C1-C5
+- Learn how application classes package recurring requirements, workload shape, measures, and constraints.
+- Derive profiles for Core Banking and Social Media, including their contrasting consistency and availability needs.
+- Analyse Back-Office and ERP systems, where workflow, integration, and governance dominate.
+- Analyse E-Commerce requirements such as latency, availability, evolvability, and revenue sensitivity.
+- Compare the five profiles and connect them to the project walking skeleton.
+
+## Lecture 9: Application Classes C6-C9
+- Learn the Scientific Simulation profile, including reproducibility, deterministic seeds, batch windows, and compute cost.
+- Learn Decision Support/BI requirements such as refresh contracts and consistent views.
+- Analyse Real-Time/IoT Streaming, focusing on ordering, correctness, failure handling, and response measures.
+- Analyse Collaboration/Messaging, including fan-out, push delivery, tail latency, archiving, and tenancy.
+- Compare all ten application profiles.
+
+## Lecture 10: Fit II: Hybrids and Evolution
+- Understand how fit changes with workload, organisation, constraints, and measured behaviour.
+- Study hybrids and evolution paths through industry examples and the Strangler Fig pattern.
+- Learn the eight-step decision procedure from requirements elicitation through measurement and evolution.
+- Follow a worked project decision ADR and connect it to the architecture dossier.
+- Examine why “consistent core, asynchronous edges” recurs across application classes.
+
+## Lecture 11: Fit III: Measurement and Organisational Limits
+- Define architectural fitness functions as objective, executable integrity checks.
+- Distinguish dependency checks, performance/cost budgets, and chaos experiments.
+- Learn the four DORA metrics and the limits of causal interpretation.
+- Build a layered measurement cascade and a reference measurement contract.
+- Extend fit analysis to Conway’s Law, Team Topologies, and the limits of the theory.
+
+## Lecture 12: The AI Dimension I
+- Separate AI used in the development process from AI used as a runtime component.
+- Compare productivity experiments and understand how moderator variables reconcile their results.
+- Understand the verification bottleneck: generated output is cheap, while verification and integration remain binding constraints.
+- Learn foundations for safe runtime AI integration, including gateways, queues, ontology guards, and explicit contracts.
+- Treat the evaluation harness as an engineering artefact connected to fitness functions and guardrails.
+
+## Lecture 13: Threats, AI-Adjusted Fit, and Agent Orchestration
+- Analyse prompt injection, untrusted model output, excessive agency, and defence-in-depth for LLM systems.
+- Treat regulatory obligations such as the EU AI Act as hard constraints.
+- Determine how AI changes the C10 profile, capability matrix, and MLOps requirements.
+- Understand agent orchestration as an emergent eighth composition pattern and examine its economics.
+- Synthesise the method using scenarios, tactics, profiles, ADRs, and measurement contracts.
+
+## Lecture 14: Synthesis, Presentations, and Architecture Defence
+- Consolidate the semester’s five parts and the central architecture decision method.
+- Review the two AI axes, twelve dimensions, application classes, capability profiles, fit matrix, ADRs, and measurement contracts.
+- Prepare for the written examination using the learning objectives, framework map, and main tables.
+- Present and defend the project architecture, trade-offs, measurements, and role of AI.
+- Conduct peer reviews and complete the final deliverable.