Die Druckversion wird nicht mehr unterstützt und kann Darstellungsfehler aufweisen. Bitte aktualisiere deine Browser-Lesezeichen und verwende stattdessen die Standard-Druckfunktion des Browsers.

aiMOOC

Anwendungsentwicklung und Softwarequalität – Daten und Oberfläche sauber trennen

QR-Code

Anwendungsentwicklung und Softwarequalität – Daten und Oberfläche sauber trennen

Einleitung

Lernkurs für die Ausbildung zum Fachinformatiker bzw. zur Fachinformatikerin für Anwendungsentwicklung

Thema: Geschäftslogik und Benutzeroberfläche sauber voneinander trennen.

Dauer: ca. 90 Minuten, zuzüglich Projektaufgaben

Vorkenntnisse: Grundkenntnisse in Python, Variablen, Funktionen und Bedingungen.

Dein Lernziel: Du entwickelst eine kleine Anwendung, in der sich die Darstellung ändern lässt, ohne die fachlichen Regeln neu schreiben zu müssen.

Lerneinheit	Schwerpunkt	Praxis
1	Problem verstehen	Architektur erkennen
2	Verantwortlichkeiten trennen	Daten und Regeln modellieren
3	Geschäftslogik entwickeln	Python-Konsole
4	Oberfläche ergänzen	Lokale Tkinter-GUI
5	Softwarequalität prüfen	Automatisierte Unit-Tests
6	Wissen übertragen	Refactoring und Erweiterung

Dein Ausbildungsprojekt: Ein kleines, vollständig fiktives Werkstattlager.

Sicherheitsregel: Du arbeitest ausschließlich lokal mit erfundenen Bestandsdaten. Keine Netzwerkzugriffe, keine externen APIs, keine Zugangsdaten, keine Kundeninformationen und keine Verbindung zu betrieblichen Produktivsystemen. Die Python-Beispiele brauchen keinen Internetzugang.

Die eingebetteten Lernvideos sind freiwillige externe Lernmedien. Sie gehören nicht zur lokalen Testumgebung.

Lerneinheit 1 – Warum Daten und Oberfläche trennen?

Lernzeit: 10 Minuten

Stell Dir eine Anwendung vor, die Material aus einem Lager ausgibt.

Eine Auszubildende trägt die Menge in ein Formular ein. Das Programm prüft den Bestand und zeigt das Ergebnis an.

Was passiert, wenn die Lagerberechnung direkt im Button-Code steckt?

Eine neue Oberfläche erfordert möglicherweise, dass dieselbe Berechnung erneut programmiert wird. Das erhöht das Risiko widersprüchlicher Regeln.

Die Lösung ist eine klare Trennung der Verantwortlichkeiten.

Datei:Model-View-Controller Pattern.svg

Abbildung: Model-View-Controller als Architekturidee. Behnam Esfahbod, CC BY-SA 3.0. Wikimedia Commons.

Drei Verantwortlichkeiten

Bereich	Aufgabe	Beispiel
Datenmodell	Fachliche Daten halten	12 Schrauben vorhanden
Geschäftslogik	Fachliche Regeln umsetzen	Ausgabe nur bei genügend Bestand
Darstellung	Informationen anzeigen	Text, Tabelle oder Balken
Steuerung	Eingaben entgegennehmen und Aktionen auslösen	Button ruft Ausgabefunktion auf

Bei MVC werden Modell, Ansicht und Steuerung unterschieden. Die Geschäftslogik gehört in unserem Beispiel zum fachlichen Modell.

Merke: Die Oberfläche entscheidet nicht selbst, ob eine Ausgabe fachlich erlaubt ist.

Lernvideo: „Model-View-Controller-Pattern“, CodingProf, Vorlesung der Hochschule Ruhr West, Prof. Dr. Malte Weiß. Besonders relevant: 00:24–05:56.

Mini-Aufgabe – Wer ist zuständig?

Ordne folgende Aktionen den Verantwortlichkeiten zu:

Eingabe: Die Person klickt auf „Ausgeben“.
Validierung: Die angeforderte Menge überschreitet den Bestand.
Visualisierung: Ein Balken zeigt neun verbleibende Schrauben.

Kontrollidee: Ein Klick gehört zur Steuerung, die Mengenregel zur Geschäftslogik und der Balken zur Darstellung.

Lerneinheit 2 – Der konkrete Ausbildungsfall

Lernzeit: 10 Minuten

Projektauftrag: Werkstattlager

Ein Ausbildungsbetrieb möchte für eine Übung eine kleine Anwendung zur Materialausgabe entwickeln.

Es gibt drei erfundene Lagerartikel.

Artikel	Anfangsbestand	Visualisierung
Schrauben	12	████████████
Muttern	8	████████
Scheiben	15	███████████████

Fachliche Anforderungen:

Eine Materialausgabe benötigt einen bekannten Artikel.
Die Ausgabemenge muss eine positive ganze Zahl sein.
Die Ausgabemenge darf den verfügbaren Bestand nicht überschreiten.
Nach einer zulässigen Ausgabe wird der neue Bestand berechnet.
Bei ungültigen Eingaben bleibt der Bestand unverändert.

Bewusst nicht enthalten: Datenbank, Benutzerkonten, Netzwerkdienste oder dauerhafte Speicherung.

Datenfluss sichtbar machen

PERSON
   |
   v
Eingabe: Schrauben, 3
   |
   v
OBERFLÄCHE / STEUERUNG
   |
   v
GESCHÄFTSLOGIK
   |
   +-- Artikel bekannt?
   +-- Menge positiv?
   +-- Menge verfügbar?
   |
   v
NEUER BESTAND
   |
   v
DARSTELLUNG
   |
   v
Schrauben: █████████ (9)

Vorher – nachher:

Artikel	Vorher	Ausgabe	Nachher
Schrauben	12	3	9
Muttern	8	0	8
Scheiben	15	0	15

Die Geschäftslogik liefert ein neues Datenobjekt. Wie der Bestand angezeigt wird, bleibt der Oberfläche überlassen.

Schichten sind keine getrennten Computer

Datei:Overview of a three-tier application vectorVersion.svg

Abbildung: Beispiel einer Drei-Schichten-Anwendung. Bartledan, gemeinfrei. Wikimedia Commons.

Eine Schichtenarchitektur trennt logische Verantwortlichkeiten. Eine Drei-Tier-Architektur kann zusätzlich verschiedene technische Ausführungsumgebungen besitzen.

Wichtig: Unser Lernprojekt trennt Verantwortlichkeiten in Python-Dateien. Alle Komponenten laufen auf demselben lokalen Computer.

Lerneinheit 3 – Die Geschäftslogik programmieren

Lernzeit: 15 Minuten

Du benötigst Python 3.10 oder neuer. Für diese Übung reichen die mitgelieferten Standardbibliotheken.

Lege einen lokalen Ordner mit dem Namen werkstatt_demo an.

Die Dateien liegen später so nebeneinander:

werkstatt_demo/
    domain.py
    konsole.py
    oberflaeche.py
    test_domain.py

Datei 1: domain.py

Erstelle die Datei domain.py mit diesem vollständigen Inhalt:

STARTBESTAND = {
    "Schrauben": 12,
    "Muttern": 8,
    "Scheiben": 15,
}


def ausgabe(bestand: dict[str, int],
            artikel: str,
            menge: int) -> dict[str, int]:

    if artikel not in bestand:
        raise ValueError("Artikel unbekannt")

    if type(menge) is not int or menge <= 0:
        raise ValueError(
            "Menge muss positiv und ganzzahlig sein"
        )

    if menge > bestand[artikel]:
        raise ValueError("Nicht genug Bestand")

    ergebnis = bestand.copy()
    ergebnis[artikel] -= menge

    return ergebnis

Was ist daran wichtig?

Die Funktion kennt keine Buttons, Fenster oder Eingabefelder.
Fachliche Regeln werden zentral geprüft.
Die Funktion verändert das übergebene Wörterbuch nicht, sondern gibt eine Kopie mit dem neuen Bestand zurück.

Damit lässt sie sich unabhängig von einer grafischen Oberfläche testen.

Datei 2: konsole.py

Die erste lokale Oberfläche ist ein Terminal.

from domain import STARTBESTAND, ausgabe


def anzeigen(bestand):
    for artikel, anzahl in bestand.items():
        print(
            f"{artikel:12} "
            f"{'█' * anzahl} ({anzahl})"
        )


def main():
    bestand = STARTBESTAND.copy()

    while True:
        anzeigen(bestand)

        artikel = input(
            "Artikel oder Ende: "
        ).strip()

        if artikel.lower() == "ende":
            break

        try:
            menge = int(input("Menge: "))
            bestand = ausgabe(
                bestand, artikel, menge
            )
        except ValueError as fehler:
            print("Fehler:", fehler)


if __name__ == "__main__":
    main()

Lokale Testumgebung A: Terminal

Starte im Projektordner:

python -m unittest discover -v
python konsole.py

Der erste Befehl funktioniert nach dem Anlegen der Testdatei in Lerneinheit 5. Auf Systemen mit getrenntem Python-3-Befehl verwendest Du python3.

Interaktiver Versuch:

Wähle Schrauben.
Gib 3 als Menge ein.
Beobachte den neuen Bestand.
Versuche anschließend 20.
Beende das Programm mit Ende.

Erwartete Anzeige nach der ersten Ausgabe:

Schrauben    █████████ (9)
Muttern      ████████ (8)
Scheiben     ███████████████ (15)

Die ungültige zweite Ausgabe wird abgelehnt. Der Bestand bleibt unverändert.

Begründetes Feedback: Das Programm prüft die fachliche Regel vor der Änderung. Eine Fehlermeldung ist korrekt; ein negativer Lagerbestand wäre ein fachlicher Fehler.

Lerneinheit 4 – Eine grafische Oberfläche ergänzen

Lernzeit: 15 Minuten

Die fachlichen Regeln bleiben unverändert. Statt der Terminaleingabe verwenden wir nun Tkinter, die Python-Schnittstelle zum Tk-GUI-Toolkit.

Datei:Python Tkinter example.png

Abbildung: Beispiel einer Tkinter-Oberfläche, nicht die konkrete Werkstatt-Anwendung. Engr.Rafi, CC BY-SA 3.0. Wikimedia Commons.

Lernvideo: „Python Tkinter Tutorial Deutsch“, Programmieren Starten. Für diese Einheit genügt der Abschnitt zu ttk-Widgets und Labels ab 47:13.

Datei 3: oberflaeche.py

Erstelle folgende vollständige Datei:

import tkinter as tk
from tkinter import messagebox, ttk

from domain import STARTBESTAND, ausgabe


def main():
    bestand = STARTBESTAND.copy()

    fenster = tk.Tk()
    fenster.title("Fiktives Werkstattlager")

    artikel = tk.StringVar(value="Schrauben")
    eingabe = tk.StringVar(value="1")
    anzeige = tk.StringVar()

    def aktualisieren():
        zeilen = [
            f"{name:12} {'█' * zahl} ({zahl})"
            for name, zahl in bestand.items()
        ]
        anzeige.set("\n".join(zeilen))

    def buchen():
        nonlocal bestand

        try:
            menge = int(eingabe.get())
        except ValueError:
            messagebox.showerror(
                "Eingabefehler",
                "Ganze Zahl eingeben"
            )
            return

        try:
            bestand = ausgabe(
                bestand, artikel.get(), menge
            )
        except ValueError as fehler:
            messagebox.showerror(
                "Buchung abgelehnt",
                str(fehler)
            )
            return

        aktualisieren()

    ttk.Label(
        fenster, text="Artikel"
    ).grid(row=0, column=0)

    ttk.Combobox(
        fenster,
        textvariable=artikel,
        values=list(STARTBESTAND),
        state="readonly"
    ).grid(row=0, column=1)

    ttk.Label(
        fenster, text="Menge"
    ).grid(row=1, column=0)

    ttk.Entry(
        fenster, textvariable=eingabe
    ).grid(row=1, column=1)

    ttk.Button(
        fenster,
        text="Ausgeben",
        command=buchen
    ).grid(row=2, column=1)

    ttk.Label(
        fenster,
        textvariable=anzeige,
        justify="left"
    ).grid(
        row=3,
        column=0,
        columnspan=2
    )

    aktualisieren()
    fenster.mainloop()


if __name__ == "__main__":
    main()

Lokale Testumgebung B: GUI

Prüfe zunächst, ob Tkinter verfügbar ist:

python -m tkinter

Falls ein Testfenster erscheint, schließe es und starte danach:

python oberflaeche.py

Auf einigen Linux-Systemen muss die Tk-Unterstützung separat installiert werden. Falls sie fehlt oder keine grafische Sitzung verfügbar ist, verwende die Konsolenversion.

Dein Testplan:

Eingabe	Erwartung	Begründung
Schrauben, Menge 2	Bestand 10	Zulässige Ausgabe
Schrauben, Menge 99	Fehlermeldung	Nicht genügend Bestand
Muttern, Menge 0	Fehlermeldung	Positive Menge erforderlich
Scheiben, Menge abc	Eingabefehler	Keine ganze Zahl

Architekturbeobachtung: In oberflaeche.py werden Eingaben gelesen, fachliche Funktionen aufgerufen und Ergebnisse dargestellt. Die Bestandsregel steht ausschließlich in domain.py.

Das Beispiel verwendet eine vereinfachte Trennung: Ansicht und Steuerung befinden sich noch in derselben GUI-Datei. Es handelt sich nicht um ein vollständiges MVC-Framework.

Wichtig: Die Bestände werden nur im Arbeitsspeicher gehalten. Beim erneuten Start beginnt jede Programmvariante wieder mit dem fiktiven Anfangsbestand.

Lerneinheit 5 – Softwarequalität durch isolierte Tests

Lernzeit: 15 Minuten

Ein Modultest überprüft einen kleinen Programmteil gezielt.

Unsere Geschäftslogik lässt sich testen, ohne ein Fenster zu öffnen.

Abbildung: Testpyramide mit Unit-, Integrations- und End-to-End-Tests. Abbe98, CC BY-SA 4.0. Wikimedia Commons.

Die Testpyramide ist ein hilfreiches Leitbild: Viele kleine, schnelle Tests werden durch gezielte Integrationstests und Tests der Gesamtanwendung ergänzt. Das konkrete Verhältnis hängt vom Projekt ab.

Datei 4: test_domain.py

import unittest

from domain import STARTBESTAND, ausgabe


class TestAusgabe(unittest.TestCase):

    def setUp(self):
        self.daten = STARTBESTAND.copy()

    def test_normale_ausgabe(self):
        neu = ausgabe(
            self.daten, "Schrauben", 3
        )
        self.assertEqual(neu["Schrauben"], 9)

    def test_grenzwert(self):
        neu = ausgabe(
            self.daten, "Muttern", 8
        )
        self.assertEqual(neu["Muttern"], 0)

    def test_ueberbestand(self):
        with self.assertRaisesRegex(
            ValueError, "Nicht genug"
        ):
            ausgabe(self.daten, "Muttern", 9)

    def test_null(self):
        with self.assertRaises(ValueError):
            ausgabe(self.daten, "Schrauben", 0)

    def test_unbekannter_artikel(self):
        with self.assertRaises(ValueError):
            ausgabe(self.daten, "Motor", 1)

    def test_original_unveraendert(self):
        ausgabe(
            self.daten, "Schrauben", 2
        )
        self.assertEqual(
            self.daten["Schrauben"], 12
        )


if __name__ == "__main__":
    unittest.main()

Lokale Testumgebung C: Automatisierte Tests

Starte im Projektordner:

python -m unittest discover -v

Erwartet werden sechs erfolgreiche Tests:

Ran 6 tests

OK

Jeder Test erhält im setUp eigene fiktive Ausgangsdaten.

Keine Datenbank, keine Netzverbindung und keine echte Buchung werden benötigt.

Lernvideo: „Unit Testing mit Python Crashkurs“. Das Video behandelt unittest und pytest. Für unseren Kurs benötigst Du ausschließlich das Standardmodul unittest.

Testdaten grafisch vergleichen

Testfall	Eingabe	Erwartung
Normalfall	Schrauben, 3	9 Schrauben
Grenzwert	Muttern, 8	0 Muttern
Überschreitung	Muttern, 9	Fehler
Ungültige Menge	Schrauben, 0	Fehler
Unbekannter Artikel	Motor, 1	Fehler
Unveränderlichkeit	Schrauben, 2	Original bleibt 12

Reflexion: Warum ist ein automatisierter Test der Geschäftslogik schneller und meist stabiler als ein Test, der jedes Mal das Fenster bedienen muss?

Lerneinheit 6 – Architektur verbessern und übertragen

Lernzeit: 15 Minuten

Du hast jetzt zwei Oberflächen, die dieselbe fachliche Funktion verwenden:

          domain.py
         BESTANDSREGEL
          /       \
         /         \
        v           v
   konsole.py   oberflaeche.py
   Textansicht   Fensteransicht

Trotz verschiedener Darstellungen gilt dieselbe Mengenregel.

Das ist ein wesentlicher Vorteil einer geringen Kopplung zwischen Darstellung und Geschäftslogik.

Veränderungsauftrag

Der Ausbildungsbetrieb möchte eine neue Regel:

Nach einer Materialausgabe müssen mindestens zwei Stück des Artikels im Lager verbleiben.

Welche Datei sollte geändert werden?

Antwort: Die fachliche Regel gehört in domain.py. Beide Oberflächen sollen dieselbe neue Regel verwenden können.

Eine mögliche Änderung der Prüfung lautet:

if menge > bestand[artikel] - 2:
    raise ValueError(
        "Mindestbestand von 2 beachten"
    )

Achtung: Diese Regel ersetzt die bisherige Bestandsgrenzenprüfung. Sie ist eine neue fachliche Anforderung und darf nicht unbemerkt in den ursprünglichen Testlauf übernommen werden.

Nach der Änderung müssen die bisherigen Tests fachlich neu bewertet werden. Insbesondere ist eine vollständige Ausgabe von acht Muttern dann nicht mehr erlaubt.

Feedback: Eine geänderte Anforderung darf Tests verändern, aber nicht die Grundidee der Trennung zerstören. Aktualisiere Tests entsprechend den neuen fachlichen Regeln, statt Fehler lediglich zu unterdrücken.

Weiterführender Architekturvergleich

Fehler beim Erstellen des Vorschaubildes:

Abbildung: Model-View-Presenter als verwandtes, aber anderes Architekturkonzept. Daniel.Cardenas, CC BY 3.0. Wikimedia Commons.

MVP, MVVM und MVC sind unterschiedliche Wege, Darstellungslogik und Fachlogik zu strukturieren.

Entscheidend ist nicht der Name des Musters, sondern die nachvollziehbare Verteilung von Verantwortlichkeiten.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was gehört zur Geschäftslogik des Werkstattlagers? (Prüfen des verfügbaren Lagerbestands) (!Festlegen der Fensterfarbe) (!Positionieren eines Buttons) (!Zeichnen eines Textfeldes)

Welche Aufgabe übernimmt die Darstellung? (Anzeigen des aktuellen Bestands als Balken) (!Festlegen der erlaubten Ausgabemenge) (!Entscheiden über den Mindestbestand) (!Berechnen des zulässigen Lagerabgangs)

Welche Aufgabe übernimmt die Steuerung im GUI-Beispiel? (Entgegennehmen des Buttonereignisses und Aufrufen der Fachfunktion) (!Festlegen der Lagerregeln) (!Ersetzen aller Fachtests) (!Speichern echter Kundendaten)

Welchen Vorteil hat die getrennte Geschäftslogik? (Sie lässt sich ohne grafische Oberfläche testen) (!Sie verhindert grundsätzlich alle Programmfehler) (!Sie benötigt zwingend einen Webserver) (!Sie ersetzt die Prüfung fachlicher Anforderungen)

Wie viele Schrauben liegen im fiktiven Anfangsbestand? (12) (!8) (!15) (!20)

Wie viele Schrauben verbleiben nach einer Ausgabe von drei Stück? (9) (!12) (!15) (!3)

Wie reagiert die Fachfunktion auf die Ausgabemenge null? (Sie löst einen ValueError aus) (!Sie bucht automatisch ein Stück) (!Sie löscht den gesamten Bestand) (!Sie beendet den Computer)

Was prüft ein Unit-Test in unserem Beispiel? (Das Verhalten der Ausgabefunktion) (!Die Geschwindigkeit einer Internetverbindung) (!Die Zugangsdaten eines Benutzers) (!Die Sicherheit eines fremden Servers)

Warum verwendet die Fachfunktion eine Kopie des Wörterbuchs? (Damit die übergebenen Ausgangsdaten unverändert bleiben) (!Damit das Fenster automatisch größer wird) (!Damit eine Datenbank angelegt wird) (!Damit keine Tests mehr erforderlich sind)

Was ist bei einem Wechsel von Konsole zu GUI idealerweise wiederverwendbar? (Die fachliche Ausgabefunktion) (!Der gesamte Eingabecode der Konsole) (!Jede grafische Schaltfläche) (!Die komplette Fensterdarstellung)

Memory

Ordne die passenden Begriffe und Bedeutungen einander zu.

Domänenlogik	Fachliche Bestandsregel
Ansicht	Sichtbare Balkendarstellung
Controller	Verarbeitung einer Benutzeraktion
Schnittstelle	Vereinbarter Funktionsaufruf
Unit-Test	Isolierte Komponentenprüfung
Testfall	Eingabe mit erwartetem Ergebnis
Testdaten	Erfundenes Werkstattinventar
Refactoring	Strukturverbesserung ohne beabsichtigte Verhaltensänderung

Drag and Drop

Ordne jeden Aufgabenbereich der passenden Verantwortung zu.

Ordne die richtigen Begriffe zu.	Verantwortlichkeit
Bestandsgrenze prüfen	Geschäftslogik
Balken darstellen	Ansicht
Buttonereignis verarbeiten	Steuerung
Fehlerfall automatisch prüfen	Modultest
Erfundene Artikel bereitstellen	Testdaten

Kreuzworträtsel

Modell	Welche Komponente repräsentiert fachliche Daten?
Ansicht	Welche Komponente ist für die Darstellung zuständig?
Controller	Welche Komponente verarbeitet Benutzeraktionen und vermittelt an die Fachlogik?
Validierung	Wie nennt man das Überprüfen einer Eingabe anhand festgelegter Regeln?
Modultest	Wie heißt ein Test für einen einzelnen abgrenzbaren Programmteil?
Kopplung	Welcher Begriff beschreibt die Abhängigkeit zwischen Softwarekomponenten?

LearningApps

Suche nach ergänzenden Zuordnungsaufgaben. Der folgende Rahmen ist eine Themensuche und kein geprüftes Einzelmodul.

Lückentext

Die Trennung fachlicher Regeln und der Benutzeroberfläche ist ein wichtiges Prinzip der

.

Das fachliche Datenmodell wird häufig als

bezeichnet.

Die sichtbare Darstellung heißt im MVC-Konzept

.

Die Verarbeitung von Benutzeraktionen kann ein

übernehmen.

Die fachliche Prüfung der Materialausgabe gehört zur

.

Der ursprüngliche Schraubenbestand beträgt

Stück.

Nach der Ausgabe von drei Schrauben verbleiben

Stück.

Eine ungültige Materialausgabe führt in unserem Python-Beispiel zu einem

.

Für die isolierte Prüfung einzelner Funktionen eignen sich

.

Das Testmodul der Python-Standardbibliothek heißt

.

Die grafische Oberfläche wurde mit

entwickelt.

Eine Verringerung unnötiger Abhängigkeiten verbessert die Änderbarkeit durch geringere

.

Die lokalen Beispieldaten werden ausschließlich im

gehalten.

Offene Aufgaben

Bearbeite die Aufgaben möglichst mit einer zweiten Person und begründe Deine Entscheidungen. Verwende ausschließlich die lokalen Dateien des Lernprojekts und fiktive Daten.

Leicht – Basisaufgaben

B1 – Architektur skizzieren: Zeichne drei Bereiche für Datenmodell, Geschäftslogik und Oberfläche. Ergänze Pfeile für einen Buchungsvorgang.
B2 – Ergebnis vorhersagen: Berechne, wie viele Schrauben nach der Ausgabe von fünf Stück aus dem Anfangsbestand verbleiben.
B3 – Bestände visualisieren: Erstelle ein Balkendiagramm für die drei Anfangsbestände mit Papier, Tabellenkalkulation oder einer lokalen Anwendung.
B4 – Verantwortung erkennen: Finde in den Python-Beispielen je zwei Stellen für fachliche Regeln und Darstellung.

Standard – Anwendungsaufgaben

A1 – Modell starten: Erstelle die Datei domain.py und prüfe die Funktion mit selbst erfundenen Artikeln.
A2 – Tests erweitern: Ergänze einen Unit-Test für eine negative Ausgabemenge und begründe das erwartete Ergebnis.
A3 – Konsolenprogramm bedienen: Teste gültige und ungültige Eingaben und dokumentiere mindestens vier beobachtete Reaktionen.
A4 – GUI prüfen: Teste die grafische Oberfläche mit Tastatur und Maus. Dokumentiere eine Verbesserung für die Verständlichkeit der Eingaben.

Schwer – Transferaufgaben

T1 – Fehlerhaftes Design verbessern: Entwirf eine Variante, bei der die Bestandsregel zunächst im Button-Code liegt, und beschreibe die Nachteile gegenüber der getrennten Version.
T2 – Funktion erweitern: Entwickle eine neue Funktion für Materialrückgaben. Die Oberfläche soll die neue Funktion verwenden, ohne selbst die Bestandsberechnung auszuführen.
T3 – Oberfläche austauschen: Entwirf eine dritte Darstellung der Bestände und erkläre, welche vorhandenen Funktionen unverändert wiederverwendet werden können.
T4 – Qualität bewerten: Entwickle einen Testplan mit Grenzwerten, fachlichen Fehlerfällen und Kriterien für eine barrierearme Bedienung.

Gestufte Hilfen

Suche möglichst zuerst selbst nach einer Lösung. Nutze die Hilfestufen nur bei Bedarf.

Aufgabe	Stufe 1: Denkimpuls	Stufe 2: Konkreter Hinweis	Stufe 3: Lösungsansatz
B2	Was ist der Anfangsbestand?	Ziehe die Ausgabemenge von 12 ab.	12 minus 5 ergibt 7 Schrauben.
A2	Welcher Wert verletzt die Mengenregel?	Verwende assertRaises mit ValueError.	Prüfe beispielsweise ausgabe mit Schrauben und minus 1 als Menge.
T2	Was unterscheidet eine Rückgabe von einer Ausgabe?	Eine zulässige Rückgabe erhöht den Bestand.	Ergänze eine reine Fachfunktion mit positiver Ganzzahlprüfung und Rückgabe eines neuen Wörterbuchs.

Begründetes Feedback

Niveau	Erfolgsmerkmal	Feedback und Begründung
Basis	Die richtige Verantwortung wurde erkannt.	Gut begründet ist eine Zuordnung erst, wenn Du zwischen einer fachlichen Entscheidung und ihrer Darstellung unterscheiden kannst.
Basis	Der errechnete Bestand stimmt.	Das Ergebnis ist sieben, weil nur ausgegebene Stückzahlen vom Anfangsbestand abgezogen werden.
Anwendung	Ein Test lehnt negative Mengen ab.	Der Test ist sinnvoll, weil negative Ausgaben der festgelegten Geschäftsregel widersprechen.
Anwendung	Die GUI meldet Fehler verständlich.	Eine verständliche Meldung hilft, falsche Eingaben zu korrigieren, ohne den Bestand unbeabsichtigt zu ändern.
Transfer	Die Rückgabe ist unabhängig von der Oberfläche implementiert.	Das ist eine gute Architekturentscheidung, weil mehrere Darstellungen dieselben Regeln nutzen können.
Transfer	Tests werden nach Regeländerungen fachlich überprüft.	Eine neue Anforderung verändert erwartete Ergebnisse. Tests müssen das spezifizierte Verhalten prüfen und dürfen nicht nur grün gemacht werden.

Selbstbewertung:

Kompetenz	Noch unsicher	Mit Hilfe	Selbstständig
Fachlogik von Darstellung unterscheiden	☐	☐	☐
Eine Python-Funktion entwickeln	☐	☐	☐
Konsolen- und GUI-Oberfläche bedienen	☐	☐	☐
Automatisierte Tests durchführen	☐	☐	☐
Eine neue fachliche Anforderung umsetzen	☐	☐	☐

Lernkontrolle

Die folgenden Aufgaben prüfen Zusammenhänge und das Übertragen des Gelernten.

Softwaredesign: Ein Kollege programmiert die Bestandsberechnung direkt in drei verschiedene Buttons. Erkläre zwei konkrete Wartungsprobleme und schlage eine Alternative vor.
Softwaretest: Die Benutzeroberfläche zeigt einen falschen Bestand. Entwickle eine Vorgehensweise, um zwischen einem Fehler in der Geschäftslogik und einem Darstellungsfehler zu unterscheiden.
Schnittstellengestaltung: Ein zweiter Ausbildungsbetrieb möchte statt der Konsole eine mobile Oberfläche verwenden. Welche Bestandteile der Architektur sollten wiederverwendbar sein? Begründe Deine Entscheidung.
Validierung: Entwirf Testfälle für eine neue Regel, nach der mindestens zwei Stück eines Artikels verbleiben müssen. Berücksichtige erlaubte und verbotene Grenzwerte.
Refactoring: Vergleiche das ursprüngliche und das getrennte Design anhand von Testbarkeit, Wartbarkeit und Fehleranfälligkeit.
Barrierefreiheit: Entwirf Verbesserungen für die GUI, die Menschen mit eingeschränktem Sehvermögen oder ohne Maus die Bedienung erleichtern. Erkläre den Einfluss auf die Softwarequalität.

Bewertungsschwerpunkte: Fachlich richtige Begründung, nachvollziehbarer Lösungsweg, passende Tests, sauberer Datenfluss und reflektierte Architekturentscheidungen.

Lernnachweis

Für einen vollständigen Lernnachweis dokumentierst Du:

Eine beschriftete Architekturzeichnung mit Datenfluss und Verantwortlichkeiten.
Eine funktionsfähige lokale Implementierung der Fachlogik.
Mindestens eine ausführbare Konsolen- oder GUI-Oberfläche.
Erfolgreiche automatisierte Tests sowie mindestens einen selbst ergänzten Testfall.
Eine Testtabelle mit Eingaben, erwarteten Ergebnissen und tatsächlichen Beobachtungen.
Eine nachvollziehbar begründete Erweiterung oder Architekturverbesserung.
Eine kurze Reflexion über Vorteile und Grenzen der Trennung von Geschäftslogik und Darstellung.
Eine Bestätigung, dass ausschließlich fiktive, lokale Testdaten verwendet wurden.

Abgabeformat: Quellcodedateien, Architekturzeichnung, Testprotokoll und eine kurze schriftliche Erläuterung.

Wichtig: Keine echten Kundendaten, Zugangsdaten, Produktivverbindungen oder nicht freigegebenen betrieblichen Dateien als Nachweis einreichen.

OERs zum Thema

Wikipedia: Model View Controller

Fachquellen und Dokumentation

Martin Fowler: Presentation Domain Data Layering – Trennung von Präsentation, Fachlogik und Datenzugriff.
Python-Dokumentation: tkinter – Offizielle Beschreibung der grafischen Python-Schnittstelle.
Python-Dokumentation: unittest – Offizielle Dokumentation des Testframeworks.
W3C: Labeling Controls – Fachliche Hinweise zur zugänglichen Beschriftung von Eingabefeldern.
Wikipedia: Schichtenarchitektur – Grundlagen logischer Softwareschichten.
Wikipedia: Softwaretest – Einordnung verschiedener Softwaretestarten.

Medienrechte und Hinweise

Die eingebundenen Wikimedia-Commons-Dateien wurden anhand ihrer Dateibeschreibungsseiten ausgewählt. Die jeweiligen Urheber, Quellen und Lizenzen sind unmittelbar an den Abbildungen angegeben.

Bildlizenzen:

MVC-Pattern: Behnam Esfahbod, CC BY-SA 3.0.
Drei-Schichten-Anwendung: Bartledan, Public Domain.
Tkinter-Beispiel: Engr.Rafi, CC BY-SA 3.0.
Testing Pyramid: Abbe98, CC BY-SA 4.0.
Model View Presenter: Daniel.Cardenas, CC BY 3.0.

YouTube-Videos: Die Videos sind externe Lernangebote. Ihre Einbettung bedeutet nicht, dass sie frei lizenziert sind. Für eine Weiterveröffentlichung oder Bearbeitung müssen die jeweiligen Nutzungsrechte gesondert geprüft werden. Ein Download oder Reupload ist für diesen Kurs nicht erforderlich.

Quellcode: Die kleinen Python-Lernbeispiele wurden eigens für den fiktiven Ausbildungsfall formuliert. Sie benötigen weder externe Datenquellen noch Bibliotheken von Drittanbietern.

Datenschutz: Externe Medien und LearningApps können beim Aufruf Verbindungen zum jeweiligen Anbieter herstellen. Die Nutzung dieser Angebote ist freiwillig und für das lokale Programmierprojekt nicht notwendig.