Informatik · Klasse 13 · Software-Engineering und Abschlussprojekt · 2. Halbjahr

Software-Design und Architektur

Die Schülerinnen und Schüler entwerfen Softwarearchitekturen und wenden Designprinzipien an.

• KMK Bildungsstandards
• KMK: Sekundarstufe II - Modellieren und Implementieren
• KMK: Sekundarstufe II - Strukturieren und Vernetzen

Über dieses Thema

Software-Design und Architektur behandelt die grundlegenden Prinzipien für die Erstellung robuster, skalierbarer und wartbarer Software-Systeme. Schülerinnen und Schüler in der Oberstufe lernen, Architekturen zu entwerfen, indem sie Designprinzipien wie Modularität, lose Kopplung und hohe Kohäsion anwenden. Sie analysieren Muster wie Client-Server-Architekturen oder Microservices und bewerten deren Vor- und Nachteile hinsichtlich Skalierbarkeit, Performance und Wartbarkeit. Praktische Übungen fordern sie auf, für gegebene Probleme modulare Lösungen zu modellieren, etwa eine Webanwendung mit verteilten Komponenten.

Dieses Thema verknüpft sich eng mit den KMK-Standards zum Modellieren und Implementieren sowie Strukturieren und Vernetzen. Es fördert systemisches Denken, da Schüler lernen, Abhängigkeiten zwischen Modulen zu visualisieren und Trade-offs abzuwägen. Solche Fähigkeiten sind essenziell für reale Projekte im Software-Engineering und bereiten auf das Abschlussprojekt vor.

Aktives Lernen eignet sich hervorragend, weil abstrakte Konzepte durch kollaboratives Modellieren greifbar werden. Wenn Schüler Architekturen mit UML-Diagrammen skizzieren oder Prototypen bauen, entdecken sie Schwachstellen selbst und internalisieren Prinzipien nachhaltig. Gruppenarbeiten stärken zudem die Fähigkeit, Designs kritisch zu diskutieren und zu iterieren.

Leitfragen

1. Erklären Sie die Bedeutung von Softwarearchitektur für die Skalierbarkeit und Wartbarkeit.
2. Designen Sie eine modulare Softwarearchitektur für ein gegebenes Problem.
3. Analysieren Sie die Vor- und Nachteile verschiedener Architekturmuster (z.B. Client-Server, Microservices).

Lernziele

• Entwerfen Sie eine modulare Softwarearchitektur für ein gegebenes Problem unter Anwendung von Entwurfsmustern.
• Analysieren Sie die Vor- und Nachteile verschiedener Architekturmuster (z.B. Client-Server, Microservices) hinsichtlich Skalierbarkeit und Wartbarkeit.
• Bewerten Sie die Auswirkungen von Architekturentscheidungen auf die Leistung und die Entwicklungskosten einer Software.
• Erklären Sie die Prinzipien der losen Kopplung und hohen Kohäsion im Kontext komplexer Softwaresysteme.

Bevor es losgeht

Grundlagen der objektorientierten Programmierung

Warum: Verständnis von Klassen, Objekten und deren Beziehungen ist essenziell für das Design modularer Software.

Datenstrukturen und Algorithmen

Warum: Kenntnisse über verschiedene Datenstrukturen und Algorithmen helfen bei der Auswahl geeigneter Komponenten für eine Architektur.

Schlüsselvokabular

Softwarearchitektur	Die grundlegende Struktur eines Softwaresystems, die seine Komponenten, ihre Beziehungen zueinander und die Prinzipien, die seine Gestaltung und Entwicklung leiten, beschreibt.
Architekturmuster	Eine allgemeine, wiederverwendbare Lösung für ein häufig auftretendes Problem im Kontext der Softwarearchitektur, wie z.B. Client-Server oder Microservices.
Modularität	Das Designprinzip, ein System in unabhängige, austauschbare Module aufzuteilen, die jeweils eine spezifische Funktion erfüllen.
Kopplung	Ein Maß dafür, wie stark verschiedene Module oder Komponenten eines Softwaresystems voneinander abhängig sind.
Kohäsion	Ein Maß dafür, wie eng die Elemente innerhalb eines einzelnen Moduls oder einer Komponente miteinander verbunden sind und auf ein gemeinsames Ziel ausgerichtet sind.

Vorsicht vor diesen Fehlvorstellungen

Häufige Fehlvorstellung

Softwarearchitektur ist nur die Code-Struktur auf Dateiebene.

Was Sie stattdessen lehren sollten

Architektur beschreibt das Hochlevel-Design mit Modulen und Schnittstellen, nicht den detaillierten Code. Aktive Modellierungsübungen mit Diagrammen helfen Schülern, den Unterschied zu visualisieren und Abhängigkeiten früh zu erkennen.

Häufige Fehlvorstellung

Monolithische Architekturen sind immer einfacher und besser.

Was Sie stattdessen lehren sollten

Monolithe eignen sich für kleine Systeme, Microservices für Skalierbarkeit. Gruppenvergleiche von Mustern zeigen Trade-offs auf und fördern nuanciertes Denken durch Peer-Diskussionen.

Häufige Fehlvorstellung

Mehr Module bedeuten immer bessere Skalierbarkeit.

Was Sie stattdessen lehren sollten

Zu viele Module erhöhen Komplexität. Design-Challenges zwingen Schüler, Balance zu finden, was durch Iteration in Gruppen aktiv korrigiert wird.

Ideen für aktives Lernen

Design-Challenge: Modulare App-Architektur

Teilen Sie ein reales Problem aus, z. B. eine E-Commerce-Plattform. Gruppen entwerfen in 20 Minuten eine modulare Architektur mit UML, wählen ein Muster und begründen Skalierbarkeit. Präsentieren Sie und lassen Sie peers abstimmen.

45 Min.·Kleingruppen

Vergleichsstationen: Architekturmuster

Richten Sie Stationen für Client-Server, Microservices und Monolith ein. Gruppen rotieren, analysieren Vor- und Nachteile an Beispielen und erstellen Vergleichstabellen. Schließen Sie mit Plenum-Diskussion ab.

50 Min.·Kleingruppen

Peer-Review: Architektur-Kritik

Jede Gruppe entwirft eine Architektur, tauscht mit einer anderen aus und gibt Feedback zu Modularität und Wartbarkeit. Iterieren Sie basierend auf Kritik und teilen Sie finale Versionen.

35 Min.·Partnerarbeit

Planspiel: Lasttest-Architektur

Nutzen Sie Tools wie Draw.io, um Architekturen zu bauen. Simulieren Sie Lastszenarien in Gruppen und passen Sie Designs an. Diskutieren Sie Anpassungen im Plenum.

40 Min.·Kleingruppen

Bezüge zur Lebenswelt

• Große E-Commerce-Plattformen wie Amazon nutzen Microservices-Architekturen, um die Skalierbarkeit während Spitzenlastzeiten wie dem Black Friday zu gewährleisten und unabhängige Teams die Entwicklung einzelner Dienste (z.B. Warenkorb, Zahlungsabwicklung) zu ermöglichen.
• Entwicklerteams bei Automobilherstellern wie Volkswagen entwerfen die Softwarearchitektur für Infotainmentsysteme, wobei sie auf modulare Designs setzen, um zukünftige Updates und die Integration neuer Funktionen (z.B. Navigation, Konnektivität) zu erleichtern.

Ideen zur Lernstandserhebung

Diskussionsfrage

Stellen Sie den Schülerinnen und Schülern folgende Frage: 'Stellen Sie sich vor, Sie entwerfen eine neue Social-Media-App. Welche Architektur (z.B. Monolith, Microservices) würden Sie wählen und warum? Nennen Sie mindestens zwei konkrete Vorteile Ihrer Wahl für die Skalierbarkeit und zwei Herausforderungen bei der Implementierung.'

Kurze Überprüfung

Zeigen Sie ein einfaches Klassendiagramm für eine kleine Anwendung (z.B. ein Online-Buchladen). Bitten Sie die Schüler, die Kopplung zwischen den Klassen zu identifizieren und zu bewerten. Fragen Sie: 'Wo sehen Sie hohe Kopplung und wie könnte man sie reduzieren, um die Wartbarkeit zu verbessern?'

Gegenseitige Bewertung

Teilen Sie die Klasse in Kleingruppen auf. Jede Gruppe entwirft eine einfache Architektur für ein gegebenes Problem (z.B. ein Buchungssystem für ein Kino) und erstellt eine grobe Skizze. Die Gruppen tauschen ihre Entwürfe aus und bewerten sich gegenseitig anhand der Kriterien Modularität und klare Abgrenzung der Verantwortlichkeiten. Jede Gruppe gibt konstruktives Feedback in 2-3 Sätzen.

Häufig gestellte Fragen

Was ist die Bedeutung von Softwarearchitektur für Skalierbarkeit?

Softwarearchitektur legt fest, wie Systeme erweitert werden können, ohne alles umzuschreiben. Modulare Designs erlauben unabhängiges Skalieren von Komponenten, z. B. bei Microservices. Schüler lernen dies durch Analyse realer Systeme und Design-Übungen, die Wachstumsszenarien simulieren. Wartbarkeit profitiert von klaren Schnittstellen, was Fehlerisolierung erleichtert.

Wie unterscheiden sich Client-Server und Microservices?

Client-Server trennt Präsentation und Logik zentral, eignet sich für einfache Anwendungen. Microservices zerlegen in unabhängige Dienste für hohe Skalierbarkeit, erhöhen aber Kommunikationsaufwand. Vergleichsstationen lassen Schüler Vor- und Nachteile erleben, z. B. bei Lasttests, und wählen passend zum Kontext.

Wie hilft aktives Lernen beim Verständnis von Softwarearchitektur?

Aktives Lernen macht abstrakte Prinzipien konkret: Schüler modellieren Architekturen in Gruppen, testen mit Prototypen und reviewen peers. Solche Hands-on-Aktivitäten enthüllen Schwächen sofort, fördern Iteration und Diskussion. Im Vergleich zu Frontalunterricht bleibt Wissen durch eigene Entdeckungen langlebiger und bereitet auf Projekte vor.

Welche Designprinzipien sind für modulare Architekturen entscheidend?

Lose Kopplung minimiert Abhängigkeiten, hohe Kohäsion gruppiert verwandte Funktionen. SOLID-Prinzipien ergänzen dies. In Challenges wenden Schüler sie an, evaluieren Designs und iterieren, was Prinzipien verankert und reale Anwendbarkeit zeigt.