diff --git a/.vscode/mcp.json b/.vscode/mcp.json new file mode 100644 index 0000000..16305b7 --- /dev/null +++ b/.vscode/mcp.json @@ -0,0 +1,9 @@ +{ + "servers": { + "datalake-fhgr": { + "url": "https://datalake-fhgr-mcp.aeol.in", + "type": "http" + } + }, + "inputs": [] +} \ No newline at end of file diff --git a/Folien/AISE502_Vorlesung_3_Folien.pdf b/Folien/AISE502_Vorlesung_3_Folien.pdf index b9d151c..bcdd7c3 100644 Binary files a/Folien/AISE502_Vorlesung_3_Folien.pdf and b/Folien/AISE502_Vorlesung_3_Folien.pdf differ diff --git a/Folien/AISE502_Vorlesung_3_Folien.tex b/Folien/AISE502_Vorlesung_3_Folien.tex index 3647ef5..de2c192 100644 --- a/Folien/AISE502_Vorlesung_3_Folien.tex +++ b/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 % ============================================ diff --git a/Folien/Zusammenfassung_Vorlesungen_1-14.md b/Folien/Zusammenfassung_Vorlesungen_1-14.md new file mode 100644 index 0000000..cb16e93 --- /dev/null +++ b/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.