Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-10-09T19:32:23Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}

{{BR}}
= Programmieren für technische Aufgaben – Quellcode verständlich dokumentieren =

'''Zielgruppe:''' Berufliche Ausbildung in IT und technischen Berufen

'''Niveau:''' Grundlagen mit Anwendungs- und Transferaufgaben

'''Dauer:''' 5 Lerneinheiten zu je etwa 10 Minuten, zusätzlich Übungs- und Projektzeit

'''Werkzeug:''' Python 3.10 oder neuer, lokal installiert

'''Leitfrage:''' Wie dokumentierst Du Programmcode so, dass andere seine Funktion, Beispiele und bekannten Grenzen verstehen?

{{BR}}
= Einleitung =

Guter [[Quelltext]] soll nicht nur funktionieren, sondern auch für andere verständlich sein. In diesem Kurs lernst Du, mit sprechenden Namen, sinnvollen [[Kommentar (Programmierung)|Kommentaren]], Docstrings, Beispielen und Tests die [[Softwaredokumentation]] zu verbessern.

Du arbeitest an einem '''vollständig fiktiven Temperaturprüfstand'''. Alle Daten sind Übungswerte. Es gibt keine Verbindung zu echten Sensoren, Netzwerken oder Produktionsanlagen.

'''Deine Lernziele:'''
# [[Lesbarkeit]]: Du kannst unübersichtlichen Code verständlich benennen und strukturieren.
# [[Softwaredokumentation]]: Du beschreibst Eingaben, Rückgaben, Regeln, Beispiele und bekannte Grenzen.
# [[Softwaretest]]: Du prüfst Normalfälle, Grenzwerte und ungültige Eingaben.
# [[Code-Review]]: Du erkennst Widersprüche zwischen Programmverhalten und Dokumentation.
# [[Softwarequalität]]: Du kannst begründen, weshalb eine Dokumentation hilfreich oder unzureichend ist.

{{BR}}
== Dein Lernweg ==

{| class="wikitable"
! Einheit
! Inhalt
! Ergebnis
|-
| 1
| Code lesen
| Verständliche Namen
|-
| 2
| Dokumentieren
| Aussagekräftiger Docstring
|-
| 3
| Grenzen verstehen
| Dokumentierte Testfälle
|-
| 4
| Lokal testen
| Ausführbares Kurslabor
|-
| 5
| Prüfen und verbessern
| Review und Übergabe
|}

{{BR}}
= Lerneinheit 1: Lesbaren Quellcode schreiben =

'''Merke:''' Namen sollen den Zweck verraten. Kommentare sollen vor allem wichtige Entscheidungen und nicht offensichtliche Zusammenhänge erklären.

[[Datei:Syntaxhighlighting.png|380px|rahmenlos|center]]

''Abbildung: Syntaxhervorhebung verbessert die Orientierung im Quelltext. Das Beispielbild verwendet HTML; das Prinzip gilt auch für Python.''

{{BR}}
== Vorher und nachher ==

'''Schwer verständlich:'''

<syntaxhighlight lang="python">
def f(x):
return 18 <= x <= 26
</syntaxhighlight>

'''Besser lesbar:'''

<syntaxhighlight lang="python">
def temperatur_im_bereich(temp_c):
"""Pruefe den fiktiven Bereich von 18 bis 26 Grad C."""
return 18 <= temp_c <= 26
</syntaxhighlight>

Die zweite Variante macht den Zweck besser erkennbar. Sie ist allerdings noch kein robustes Prüfprogramm: Ungültige Eingaben können Fehler auslösen oder unerwartete Ergebnisse liefern.

'''Mini-Aufgabe:''' Benenne die Funktion und ihre Eingabe um. Welche Information liefert der neue Name?

{{#ev:youtube| https://www.youtube.com/watch?v=CeklBjD3gDg |500|center}}

''Video: How to Write Good Code Comments. Englischsprachige Vertiefung zum sinnvollen Kommentieren.''

{{BR}}
= Lerneinheit 2: Funktionen richtig dokumentieren =

In Python ist ein '''Docstring''' eine Dokumentationszeichenkette am Anfang einer Funktion, Klasse oder eines Moduls.

Eine hilfreiche Funktionsdokumentation beantwortet fünf Fragen:

{| class="wikitable"
! Frage
! Beispiel
|-
| Was macht die Funktion?
| Temperatur bewerten
|-
| Welche Eingabe erwartet sie?
| Temperatur in Grad Celsius
|-
| Was liefert sie zurück?
| OK, AUSSERHALB oder UNGUELTIG
|-
| Welches Beispiel gilt?
| 18,0 ergibt OK
|-
| Welche Grenzen hat sie?
| Keine Messunsicherheit oder Sensoranbindung
|}

'''Merksatz:''' Dokumentiere das Verhalten und die wichtigen Annahmen, statt lediglich Programmzeilen in Worten zu wiederholen.

{{#ev:youtube| https://www.youtube.com/watch?v=l3084gzo6Eo |500|center}}

''Video: Python Tutorial: Docstrings. Englischsprachiges Lernvideo.''

{{BR}}
== Kommentare oder Docstrings? ==

{| class="wikitable"
! Mittel
! Aufgabe
|-
| Sprechender Name
| Macht die Absicht direkt erkennbar
|-
| Kommentar
| Erklärt eine wichtige Entscheidung oder Ausnahme
|-
| Docstring
| Beschreibt den Vertrag einer Funktion
|-
| Testfall
| Prüft, ob das tatsächliche Verhalten zum Vertrag passt
|}

Nach [[PEP 8]] sollen Kommentare hilfreich und aktuell sein. [[PEP 257]] beschreibt verbreitete Konventionen für Python-Docstrings.

{{BR}}
= Lerneinheit 3: Ausbildungsfall Temperaturprüfstand =

'''Auftrag:''' In einer simulierten Ausbildungssituation soll eine Funktion fiktive Temperaturwerte klassifizieren.

Die Werte '''18,0 °C''' und '''26,0 °C''' sind eingeschlossen. Diese Grenzen sind ausschließlich für die Übung gewählt und keine technischen Norm- oder Sicherheitsgrenzen.

{{BR}}
== Die Entscheidungsregel ==

<pre>
FIKTIVER TEMPERATURBEREICH

Zu niedrig Freigegebener Übungsbereich Zu hoch

17,9 |18,0 ==================== 26,0| 26,1
| |
AUSSERHALB | OK | AUSSERHALB

Darstellung schematisch, nicht maßstabsgetreu.
</pre>

[[Datei:Flowchart de.svg|300px|rahmenlos|center]]

''Abbildung: Allgemeines Flussdiagramm. Nutze dieses Darstellungsmittel, um die eigene Prüflogik zu skizzieren.''

{{BR}}
== Visualisierte Beispieldaten ==

{| class="wikitable"
! Fiktiver Wert
! Erwarteter Status
! Begründung
|-
| 17,9 °C
| AUSSERHALB
| Unterhalb der Untergrenze
|-
| 18,0 °C
| OK
| Untergrenze ist eingeschlossen
|-
| 22,0 °C
| OK
| Innerhalb des Bereichs
|-
| 26,0 °C
| OK
| Obergrenze ist eingeschlossen
|-
| 26,1 °C
| AUSSERHALB
| Oberhalb der Obergrenze
|-
| Kein Wert
| UNGUELTIG
| Keine auswertbare Messung
|-
| NaN
| UNGUELTIG
| Keine endliche Zahl
|}

'''Frage:''' Warum reicht es nicht, nur den Wert 22,0 °C zu testen?

'''Feedback:''' Ein Normalfall zeigt nicht, ob Grenzwerte eingeschlossen sind oder ungültige Eingaben sicher behandelt werden.

{{BR}}
== Bekannte Grenzen des Ausbildungsfalls ==

# Die Werte stammen nicht aus echten Messungen.
# Die Funktion ist nicht für eine Sicherheitssteuerung vorgesehen.
# Messunsicherheit, Kalibrierung und [[Hysterese]] sind nicht berücksichtigt.
# Die Simulation steuert keine Aktoren oder technischen Anlagen.
# Die dokumentierten Beispielgrenzen sind nicht auf reale Anlagen übertragbar.

{{BR}}
= Lerneinheit 4: Lokales Python-Labor =

'''Sicherheitsregel:''' Arbeite nur auf Deinem eigenen oder ausdrücklich freigegebenen Ausbildungsrechner. Nutze ausschließlich fiktive Werte. Es werden weder Kundendaten noch Zugangsdaten benötigt.

'''Vorbereitung:''' Speichere den folgenden vollständigen Code als <code>kurs.py</code>.

<syntaxhighlight lang="python">
"""Kurslabor: Temperaturcheck an einem fiktiven Pruefstand.

Start: python3 -I -B kurs.py
Keine echten Messwerte, Dateien, Netze oder Anlagen.
"""

import math
import unittest

MIN_C = 18.0
MAX_C = 26.0

def temperatur_status(temp_c):
"""Bewerte einen fiktiven Temperaturwert in Grad Celsius.

Eingabe: int oder float, jedoch kein bool, NaN oder Unendlich.
Rueckgabe: OK fuer 18.0 bis 26.0 einschliesslich,
AUSSERHALB fuer andere endliche Zahlen, sonst UNGUELTIG.
Beispiel: temperatur_status(18.0) liefert OK.
Grenzen: keine Sensoranbindung, Kalibrierung oder Hysterese.
"""
if type(temp_c) not in (int, float):
return "UNGUELTIG"
if type(temp_c) is float and not math.isfinite(temp_c):
return "UNGUELTIG"

# Im fiktiven Auftrag sind beide Grenzwerte eingeschlossen.
if MIN_C <= temp_c <= MAX_C:
return "OK"
return "AUSSERHALB"

class TestTemperaturStatus(unittest.TestCase):
"""Teste die dokumentierte Regel mit fiktiven Werten."""

def test_normalfall(self):
self.assertEqual(temperatur_status(22), "OK")

def test_grenzen(self):
for wert in (18.0, 26.0):
with self.subTest(wert=wert):
self.assertEqual(temperatur_status(wert), "OK")

def test_ausserhalb(self):
for wert in (17.9, 26.1):
with self.subTest(wert=wert):
self.assertEqual(
temperatur_status(wert), "AUSSERHALB"
)

def test_ungueltig(self):
for wert in (None, True, "22", float("nan"),
float("inf")):
with self.subTest(wert=wert):
self.assertEqual(
temperatur_status(wert), "UNGUELTIG"
)

def labor():
"""Biete fiktive Konsolenwerte als lokale Uebung an."""
print("Fiktive Beispieldaten:")
for wert in (17.9, 18.0, 22.0, 26.0, 26.1, None):
print(f"{str(wert):>5} -> {temperatur_status(wert)}")

print("Nur lokale Testwerte eingeben; x beendet die Uebung.")
while True:
try:
text = input(
"Temperatur in Grad C (x=Ende): "
).strip()
except EOFError:
return

if text.lower() == "x":
return

try:
wert = float(text.replace(",", "."))
except ValueError:
print("UNGUELTIG")
else:
print(temperatur_status(wert))

if __name__ == "__main__":
ergebnis = unittest.TextTestRunner(verbosity=2).run(
unittest.defaultTestLoader.loadTestsFromTestCase(
TestTemperaturStatus
)
)
if not ergebnis.wasSuccessful():
raise SystemExit(1)
labor()
</syntaxhighlight>

{{BR}}
== Programm lokal starten ==

Öffne ein Terminal im Verzeichnis Deiner selbst erstellten Datei.

'''Linux oder macOS:'''

<pre>
python3 -I -B kurs.py
</pre>

'''Windows mit Python Launcher:'''

<pre>
py -I -B kurs.py
</pre>

Die Funktionstests laufen zuerst. Danach beginnt die interaktive Konsolenübung.

'''Erwartete Testausgabe:''' Vier Testmethoden, keine Fehler, Status OK. Die anschließende Eingabeübung bleibt lokal.

Die Option <code>-I</code> schränkt Python-Umgebungseinflüsse ein; <code>-B</code> unterdrückt die Erzeugung von Bytecode-Cachedateien. '''Diese Optionen sind keine vollständige Sicherheits-Sandbox.'''

{{BR}}
== Interaktives Experiment ==

Gib im lokalen Labor nacheinander folgende Testwerte ein:

{| class="wikitable"
! Eingabe
! Erwartete Antwort
|-
| 18
| OK
|-
| 26,1
| AUSSERHALB
|-
| abc
| UNGUELTIG
|-
| NaN
| UNGUELTIG
|-
| x
| Programm beenden
|}

'''Forscherauftrag:''' Verändere einen fiktiven Eingabewert. Vergleiche die tatsächliche Ausgabe mit Deiner Vorhersage.

'''Achtung:''' Eine Konsoleneingabe wie <code>22</code> wird in dieser Übung in eine Fließkommazahl umgewandelt. Ein direkt als Zeichenkette an die Funktion übergebenes <code>"22"</code> wird dagegen bewusst zurückgewiesen.

{{BR}}
== Optional: stärker abgeschottete Testumgebung ==

Nur für freigegebene Ausbildungssysteme mit bereits lokal vorhandener, vertrauenswürdig bereitgestellter Docker-Umgebung.

'''Voraussetzung:''' Das Image <code>python:3.12-alpine</code> ist schon lokal installiert. Der Befehl lädt ausdrücklich kein Image herunter.

Beispiel für eine Linux-/macOS-Shell:

<pre>
docker run --rm -it --pull=never \
--network=none --read-only \
--cap-drop=ALL \
--security-opt=no-new-privileges \
--pids-limit=64 --memory=256m \
-v "$PWD/kurs.py:/app/kurs.py:ro" \
python:3.12-alpine python -I -B /app/kurs.py
</pre>

Die Übung verwendet kein Netzwerk, bindet nur die lokale Kursdatei schreibgeschützt ein und entfernt den Container nach Beendigung.

'''Wichtig:''' Container-Isolation ersetzt keine Sicherheitsprüfung durch die Ausbildungsorganisation. Verwende keine fremden Docker-Images, Anlagenverbindungen, Host-Zugangsdaten oder produktiven Volumes.

{{BR}}
= Lerneinheit 5: Testen, Review und Übergabe =

[[Datei:Testing Pyramid.svg|450px|rahmenlos|center]]

''Abbildung: Testpyramide. Die Übung konzentriert sich auf Unit-Tests; sie ersetzt keine Integrations- oder Systemprüfung.''

Ein [[Unit-Test]] überprüft eine kleine Programmeinheit automatisiert. Die dokumentierten Regeln liefern die Grundlage für geeignete Testfälle.

{{#ev:youtube| https://www.youtube.com/watch?v=6tNS--WetLI |500|center}}

''Video: Python Tutorial: Unit Testing Your Code with the unittest Module. Englischsprachige Vertiefung.''

{{BR}}
== Fünf Fragen für ein Code-Review ==

{| class="wikitable"
! Prüffrage
! Qualitätsmerkmal
|-
| Versteht eine andere Person den Zweck?
| Klare Namen und Kurzbeschreibung
|-
| Sind Ein- und Ausgaben beschrieben?
| Nachvollziehbarer Funktionsvertrag
|-
| Stimmen Beispiele mit dem Code überein?
| Ausführbare Testfälle
|-
| Sind Einschränkungen sichtbar?
| Dokumentierte bekannte Grenzen
|-
| Ist die Testumgebung sicher?
| Fiktive Daten, keine externen Systeme
|}

[[Datei:Code Review photo-1.jpg|480px|rahmenlos|center]]

''Abbildung: Schulung zu Code-Reviews. Prüfe auch die Verständlichkeit für andere Personen.''

{{BR}}
== Dokumentation ist Teil der Wartung ==

[[Datei:Software Development Life cycle.png|380px|rahmenlos|center]]

''Abbildung: Allgemeiner Softwareentwicklungszyklus. Ändert sich das Verhalten, müssen auch Dokumentation und Tests überprüft werden.''

{{BR}}
== Gestufte Hilfen ==

Versuche jede Aufgabe zunächst selbst. Lies die nächste Hilfe erst, wenn Du sie benötigst.

{| class="wikitable"
! Hilfestufe
! Unterstützung
|-
| Hilfe 1 – Denkanstoß
| Frage Dich, was hineingeht, was herauskommt und wann ein Ergebnis gültig ist.
|-
| Hilfe 2 – Struktur
| Schreibe im Docstring Zweck, Eingabe, Rückgabe, Beispiel und Grenzen auf.
|-
| Hilfe 3 – Konkreter Ansatz
| Prüfe zuerst den Datentyp, danach endliche Zahlen und zuletzt die beiden eingeschlossenen Grenzwerte.
|}

{{BR}}
== Begründetes Feedback zu den Lernstufen ==

{| class="wikitable"
! Stufe
! Tragfähige Lösung
! Warum?
|-
| Basis
| Ein sprechender Funktionsname ersetzt eine unklare Abkürzung.
| Der Zweck wird ohne zusätzliche Erklärung erkennbar.
|-
| Anwendung
| Tests prüfen beide Grenzwerte und ungültige Werte.
| Die dokumentierte Regel wird an kritischen Stellen überprüft.
|-
| Transfer
| Eine neue Anforderung führt zur Anpassung von Code, Dokumentation, Beispielen und Tests.
| Nur so bleiben die verschiedenen Beschreibungen des Programmverhaltens konsistent.
|}

'''Negativbeispiel:''' Eine Kommentarzeile behauptet, 26,0 °C sei ungültig, während der Code OK zurückgibt. Das ist unzureichend, weil die Dokumentation eine falsche Erwartung erzeugt.

{{BR}}
= Interaktive Aufgaben =

{{BR}}
== Quiz: Teste Dein Wissen ==

{{MC}}

'''Welches Ziel hat gute Quellcodedokumentation?'''
(Das Verhalten und die Grenzen des Programms verständlich machen)
(!Möglichst viele Kommentare schreiben)
(!Alle Tests ersetzen)
(!Die Ausführung des Programms verlangsamen)

{{E}}
<br>

{{MC}}

'''Was ist in Python ein Docstring?'''
(Eine Dokumentationszeichenkette am Anfang einer Funktion oder Klasse)
(!Ein beliebiger Variablenname)
(!Eine automatisch ausgeführte Testdatei)
(!Ein Ersatz für Python selbst)

{{E}}
<br>

{{MC}}

'''Wann ist ein Kommentar besonders hilfreich?'''
(Wenn er eine nicht offensichtliche Entscheidung erklärt)
(!Wenn er jeden einzelnen Operator wiederholt)
(!Wenn er veraltete Regeln enthält)
(!Wenn er unverständliche Namen grundsätzlich beibehält)

{{E}}
<br>

{{MC}}

'''Was ergibt im Ausbildungsfall die Eingabe 18,0 Grad Celsius?'''
(OK)
(!AUSSERHALB)
(!UNGUELTIG)
(!Programmabbruch)

{{E}}
<br>

{{MC}}

'''Wie bewertet das Programm 26,1 Grad Celsius?'''
(AUSSERHALB)
(!OK)
(!UNGUELTIG)
(!Keine Ausgabe)

{{E}}
<br>

{{MC}}

'''Wie behandelt die Funktion den fehlenden Wert None?'''
(UNGUELTIG)
(!OK)
(!AUSSERHALB)
(!Als Null Grad Celsius)

{{E}}
<br>

{{MC}}

'''Warum wird math.isfinite bei Fließkommazahlen verwendet?'''
(Um NaN und unendliche Werte zu erkennen)
(!Um automatisch Sensoren zu kalibrieren)
(!Um Kommentare zu erzeugen)
(!Um Dateien im Internet abzurufen)

{{E}}
<br>

{{MC}}

'''Warum wird True im Kurs nicht als Messwert akzeptiert?'''
(Weil boolesche Werte keine zulässigen Temperaturmessungen sind)
(!Weil True immer unendlich ist)
(!Weil True größer als 26 ist)
(!Weil True grundsätzlich ein Syntaxfehler ist)

{{E}}
<br>

{{MC}}

'''Welche Aussage zur lokalen Python-Option I trifft zu?'''
(Sie isoliert Teile der Python-Umgebung ohne vollständige Betriebssystemabschottung)
(!Sie deaktiviert garantiert jede Netzwerkverbindung)
(!Sie ersetzt alle Tests)
(!Sie macht jede beliebige Datei ungefährlich)

{{E}}
<br>

{{MC}}

'''Was sollte nach einer Änderung der Temperaturgrenzen passieren?'''
(Code, Dokumentation, Beispiele und Tests gemeinsam überprüfen)
(!Nur den Dateinamen ändern)
(!Alle Docstrings löschen)
(!Nur die Bildgröße anpassen)

{{E}}
<br>

{{BR}}
== Memory ==

Finde die zusammengehörenden Begriffe.

<div class="memo-quiz">
{|
|-
| Docstring || Dokumentationszeichenkette einer Funktion
|-
| Grenzwerttest || Prüfung am Rand des erlaubten Bereichs
|-
| Unit-Test || Automatisierte Prüfung einer kleinen Programmeinheit
|-
| Sprechender Name || Bezeichnung mit erkennbarem Zweck
|-
| Bekannte Grenze || Dokumentierte Einschränkung der Lösung
|-
| Code-Review || Fachliche Prüfung durch eine andere Person
|}
{{E}}
<br>

{{BR}}
== Drag and Drop ==

Ordne die Dokumentationselemente ihren Aufgaben zu.

<div class="lueckentext-quiz">

{| class="wikitable"
! Ordne die richtigen Begriffe zu.
! Thema
|-
| '''Funktionsname'''
| Verständliche Benennung
|-
| '''Docstring'''
| Beschreibung der Schnittstelle
|-
| '''Grenzfall'''
| Prüfung eines Randwertes
|-
| '''Unit-Test'''
| Automatischer Ergebnisvergleich
|-
| '''Warnhinweis'''
| Erklärung einer bekannten Einschränkung
|}
{{E}}

<br>

{{BR}}
== Kreuzworträtsel ==

<div class="kreuzwort-quiz">
{|
|-
| Docstring || Wie heißt die Dokumentationszeichenkette am Anfang einer Python-Funktion?
|-
| Kommentar || Wie heißt eine erläuternde Anmerkung innerhalb des Quellcodes?
|-
| Grenzwert || Wie nennt man einen Randwert eines erlaubten Bereichs?
|-
| Testfall || Wie nennt man eine einzelne Prüfung mit Eingabe und erwartetem Ergebnis?
|-
| Lesbarkeit || Welche Eigenschaft beschreibt, wie gut Menschen Quelltext erfassen können?
|-
| Hysterese || Wie heißt eine Umschaltdifferenz, die häufiges Hin- und Herschalten vermeiden kann?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

'''Externe Ergänzung:''' LearningApps darf nur genutzt werden, wenn die Ausbildungsorganisation die Verwendung und Datenübertragung ausdrücklich freigegeben hat. Für alle Kernaufgaben genügt das lokale Kurslabor.

<iframe> https://learningapps.org/index.php?s=Programmieren+f%C3%BCr+technische+Aufgaben+Quellcode+verst%C3%A4ndlich+dokumentieren </iframe>

{{BR}}
== Lückentext ==

<quiz display=simple>
{'''Vervollständige den Text.'''<br>
|type="{}"}
Verständliche Variablennamen verbessern die { Lesbarkeit } eines Programms.

Eine Dokumentationszeichenkette am Anfang einer Python-Funktion heißt { Docstring }.

Ein Kommentar kann erläutern, { warum } eine Entscheidung getroffen wird.

Die fiktiven Temperaturen werden in Grad { Celsius } angegeben.

Die beiden Grenzwerte sind im Ausbildungsfall { eingeschlossen }.

Fehlende oder unzulässige Eingaben liefern den Status { UNGUELTIG }.

Mit einem { Grenzwerttest } prüfst Du eine Bereichsgrenze.

Die Python-Bibliothek { unittest } ermöglicht automatisierte Funktionstests.

Der Wert { NaN } ist keine endliche Zahl.

Die Beispieldaten müssen im Kurs ausschließlich { fiktiv } sein.

Nach Programmänderungen müssen auch die { Tests } überprüft werden.

Bekannte technische { Grenzen } gehören in die Dokumentation.
</quiz>

<br>

{{BR}}
= Offene Aufgaben =

'''Arbeitsweise:''' Bearbeite die Aufgaben mit fiktiven Daten. Leicht entspricht der Basisstufe, Standard der Anwendung und Schwer dem Transfer. Prüfe Deine Ergebnisse anhand der Feedbackkriterien.

{{BR}}
=== Leicht ===

# [[Quelltext|Code lesen]]: Unterstreiche in einem selbst erfundenen kurzen Programm unklare Bezeichner und erkläre ihre Bedeutung. '''Feedback:''' Gut gelöst, wenn eine andere Person die Funktion ohne Rückfrage erkennt.
# [[Programmierstil|Namen verbessern]]: Ersetze mindestens vier unklare Variablennamen durch sprechende Namen. '''Feedback:''' Gute Namen beschreiben einen Zweck statt nur einen Datentyp.
# [[Kommentar (Programmierung)|Kommentare prüfen]]: Formuliere zwei sinnvolle und zwei unnötige Kommentare. '''Feedback:''' Sinnvoll ist eine Erklärung besonders dann, wenn der Code die Entscheidung allein nicht verständlich macht.
# [[Softwaredokumentation|Docstring schreiben]]: Beschreibe Eingabe, Rückgabe, Beispiel und Grenze einer eigenen Mini-Funktion. '''Feedback:''' Vollständig ist die Lösung, wenn diese Angaben das tatsächliche Verhalten treffen.

{{BR}}
=== Standard ===

# [[Softwaretest|Testtabelle erstellen]]: Erstelle für den fiktiven Prüfstand sechs Testfälle samt erwarteter Ergebnisse. '''Feedback:''' Berücksichtige beide Grenzen, mindestens einen Normalfall und ungültige Eingaben, weil dort unterschiedliche Fehler entstehen können.
# [[Python (Programmiersprache)|Funktion erweitern]]: Ergänze im lokalen Kurslabor einen weiteren fiktiven Testwert und die zugehörige Prüfung. '''Feedback:''' Der neue Test soll eine klar begründete Regel nachweisen und wiederholbar sein.
# [[Code-Review|Partnerprüfung]]: Tausche Deinen selbst geschriebenen Code mit einer anderen lernenden Person und sammle drei konkrete Verbesserungsvorschläge. '''Feedback:''' Gute Kritik benennt Fundstelle, Wirkung und mögliche Änderung.
# [[Programmablaufplan|Ablauf visualisieren]]: Zeichne die Entscheidungen für gültige Eingabe, Bereichsprüfung und Rückgabe. '''Feedback:''' Jeder mögliche Rückgabestatus benötigt einen nachvollziehbaren Pfad.

{{BR}}
=== Schwer ===

# [[Refactoring|Regeländerung durchführen]]: Ändere ausschließlich im lokalen Übungsprojekt die fiktiven Grenzen auf 19 und 25 Grad Celsius. Aktualisiere Code, Docstring, Testfälle und Grafik. '''Feedback:''' Alle vier Darstellungen müssen widerspruchsfrei sein.
# [[Softwarequalität|Messunsicherheit analysieren]]: Entwickle einen schriftlichen Vorschlag, wie eine fiktive Messunsicherheit beschrieben werden könnte, ohne eine reale Steuerung zu programmieren. '''Feedback:''' Die Lösung ist tragfähig, wenn offene Annahmen und Entscheidungsbedarf deutlich werden.
# [[Softwaredokumentation|Übergabedokument erstellen]]: Erstelle eine einseitige Anleitung mit Zweck, Nutzung, Beispielen, Tests und bekannten Grenzen. '''Feedback:''' Eine neue Person soll die Übung ohne mündliche Nachhilfe nachvollziehen können.
# [[Softwarewartung|Dokumentationsaudit gestalten]]: Erfinde drei veraltete Aussagen in einer Dokumentation und zeige, wie Du sie durch lokale Tests überprüfen würdest. '''Feedback:''' Begründete Korrekturen verweisen auf beobachtbares Verhalten statt Vermutungen.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= Lernkontrolle =

Bearbeite die folgenden Aufgaben schriftlich oder mit selbst erstellten fiktiven Testdaten.

# [[Softwarewartung|Änderungsfolgen]]: Erkläre, weshalb das bloße Ändern der Grenzwerte im Code keine ausreichende Wartungsmaßnahme ist. Beschreibe die Auswirkungen auf Dokumentation und Tests.
# [[Softwaretest|Grenzfallanalyse]]: Vergleiche eine Teststrategie mit ausschließlich Normalwerten mit einer Strategie aus Normal-, Grenz- und ungültigen Fällen. Begründe, welche Fehler die zweite Strategie zusätzlich aufdecken kann.
# [[Softwarequalität|Widerspruch erkennen]]: Ein Docstring bezeichnet 26 Grad Celsius als ungültig, der Code liefert OK. Entwickle ein Verfahren, mit dem Du den Widerspruch lokal nachweisen und beheben kannst.
# [[Anforderungsanalyse|Unklare Spezifikation]]: Ein Ausbildungsauftrag nennt nur einen zulässigen Temperaturbereich, aber keine Regel für fehlende Werte. Formuliere zwei notwendige Rückfragen und begründe sie.
# [[Technische Dokumentation|Grenzen bewerten]]: Erkläre, weshalb ein bestandener Unit-Test keine Aussage über Kalibrierung, Messunsicherheit oder die Sicherheit einer echten Anlage beweist.
# [[Informationssicherheit|Sicher übertragen]]: Entwirf einen Ablauf, mit dem Du eine Programmierübung aus einem Ausbildungsbetrieb an eine andere lernende Person weitergeben kannst, ohne vertrauliche Daten oder produktive Zugänge preiszugeben.

<br>
<br>

{{BR}}
= Lernnachweis =

Für einen erfolgreichen Lernnachweis benötigst Du:

# '''Kommentierten Quellcode:''' Eine lokal lauffähige Python-Funktion mit verständlicher Benennung und zutreffendem Docstring.
# '''Funktionsvertrag:''' Angaben zu Zweck, Eingaben, Rückgaben, Beispielen und bekannten Grenzen.
# '''Testnachweis:''' Mindestens sechs fiktive Testfälle, darunter beide Grenzwerte und ungültige Eingaben.
# '''Testprotokoll:''' Erwartete und tatsächlich ermittelte Ergebnisse mit kurzer Begründung bei Abweichungen.
# '''Visualisierung:''' Eine eigene Tabelle oder ein Flussdiagramm zur dokumentierten Entscheidungsregel.
# '''Review:''' Mindestens drei nachvollziehbare Qualitätsprüfungen und eine begründete Verbesserung.
# '''Transferleistung:''' Eine dokumentierte Änderung der fiktiven Anforderung einschließlich angepasster Tests.
# '''Sicherheitsnachweis:''' Bestätigung, dass ausschließlich lokale oder ausdrücklich freigegebene Testumgebungen und fiktive Daten verwendet wurden.

'''Bewertungsvorschlag:''' Lesbarkeit 20 Prozent, Dokumentation 25 Prozent, Tests 25 Prozent, Transfer und Begründung 20 Prozent, sichere Durchführung 10 Prozent.

<br>
<br>

{{BR}}
= OERs zum Thema =

{{BR}}
== Fachlich überprüfte Quellen ==

# [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]: Offizielle Empfehlungen zu Lesbarkeit, Benennungen und Kommentaren.
# [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]: Konventionen für Dokumentationszeichenketten.
# [https://docs.python.org/de/3.12/library/unittest.html Python-Dokumentation – unittest]: Offizielle Erläuterung des Testframeworks.
# [https://docs.python.org/de/3.12/library/math.html Python-Dokumentation – math]: Beschreibung mathematischer Funktionen einschließlich isfinite.
# [[Softwaredokumentation]]: Überblick über Formen und Ziele der Softwaredokumentation.
# [[Programmierstil]]: Hintergrund zu lesbarem und wartbarem Programmcode.
# [[Kommentar (Programmierung)]]: Erläuterung von Kommentaren in Programmiersprachen.

'''Hinweis:''' Nicht jede frei abrufbare Fachquelle und nicht jedes YouTube-Video ist automatisch eine frei lizenzierte OER.

{{BR}}
== Geprüfte Medien und Nutzungsrechte ==

{| class="wikitable"
! Medium
! Urheberangabe
! Lizenz laut Wikimedia Commons
|-
| [https://commons.wikimedia.org/wiki/File:Syntaxhighlighting.png Syntaxhighlighting.png]
| Geany-Entwickler, Screenshot bereitgestellt von Kreuzschnabel
| GPL ab Version 2
|-
| [https://commons.wikimedia.org/wiki/File:Flowchart_de.svg Flowchart de.svg]
| Erik Streb
| CC BY-SA 3.0
|-
| [https://commons.wikimedia.org/wiki/File:Testing_Pyramid.svg Testing Pyramid.svg]
| Abbe98
| CC BY-SA 4.0
|-
| [https://commons.wikimedia.org/wiki/File:Code_Review_photo-1.jpg Code Review photo-1.jpg]
| Matthew (WMF)
| CC BY-SA 3.0
|-
| [https://commons.wikimedia.org/wiki/File:Software_Development_Life_cycle.png Software Development Life cycle.png]
| Tazlavi
| CC BY-SA 4.0
|}

Die Dateien sind unverändert eingebunden. Beachte bei einer Weiterverwendung die jeweilige Lizenz, die Namensnennung und gegebenenfalls die Weitergabe unter gleichen Bedingungen. Die verlinkten Commons-Dateibeschreibungen enthalten die maßgeblichen Lizenzdetails.

Die eingebetteten YouTube-Videos sind externe Angebote. Die Rechte verbleiben bei den jeweiligen Berechtigten. Eine frei verfügbare Wiedergabe bedeutet keine Erlaubnis zur beliebigen Kopie oder Bearbeitung.

'''Datenschutz:''' Externe Videos, LearningApps und Wikipedia-Einbettungen können beim Aufruf Verbindungen zu Drittanbietern auslösen. Verwende sie nur im Rahmen der Freigaben Deiner Ausbildungsorganisation. Keine Übungs- oder Kundendaten an solche Dienste übertragen.

{{BR}}
== Wikipedia-Einbettung ==

<iframe> https://de.m.wikipedia.org/wiki/Softwaredokumentation </iframe>

'''Alternative bei gesperrter Einbettung:''' [[Softwaredokumentation]] auf Wikipedia direkt aufrufen, sofern externe Webseiten freigegeben sind.

<br>

{{BR}}
= Verknüpfte Lernbereiche =

{| align=center
{{:D-Tab}}
'''[[Softwaredokumentation]]'''
# [[Quelltext]]
# [[Kommentar (Programmierung)]]
# [[Programmierstil]]
# [[Lesbarkeit]]
# [[Python (Programmiersprache)]]
# [[Softwaretest]]
# [[Unit-Test]]
# [[Code-Review]]
# [[Softwarequalität]]
# [[Refactoring]]
# [[Softwarewartung]]
# [[Informationssicherheit]]
|}

[[Kategorie:Informatik]]
[[Kategorie:Programmierung]]
[[Kategorie:Softwaretechnik]]
[[Kategorie:Python]]
[[Kategorie:Berufsausbildung]]
[[Kategorie:Technische Bildung]]

{{BR}}
= aiMOOC-Projekte =
[[Kategorie:AI_MOOC]] [[Kategorie:GPT aiMOOC]]
{{MT}}

Programmieren für technische Aufgaben – Quellcode verständlich dokumentieren - Versionsgeschichte

Glanz: aiMOOC über GPT aiMOOC Action erstellt