Professionelles Debugging und KI-gestützte Fehleranalyse - aiMOOC
Professionelles Debugging und KI-gestützte Fehleranalyse - aiMOOC
Einleitung
Professionelles Debugging ist die Fähigkeit, Fehler nicht zufällig, sondern systematisch zu finden, zu erklären, zu beheben und gegen Rückfälle abzusichern. In moderner Softwareentwicklung reicht es nicht, nur eine Fehlermeldung zu kopieren und schnell etwas zu ändern. Du musst ein Fehlerbild beobachten, eine nachvollziehbare Hypothese bilden, geeignete Werkzeuge einsetzen, den Code verstehen, die Änderung testen und dokumentieren. Durch KI kommen neue Möglichkeiten hinzu: Large Language Models können Fehlermeldungen erklären, mögliche Ursachen sammeln, Testfälle vorschlagen, Logs strukturieren, Codevarianten vergleichen und Dich beim Formulieren von Prompts unterstützen.
Das Thema verbindet drei Bereiche: Erstens geht es um klassisches, professionelles Debugging mit Debuggern, Logdateien, Stacktraces, Testfällen und Code Reviews. Zweitens lernst Du, wie KI-gestützte Fehleranalyse sinnvoll eingesetzt wird, ohne Kontrolle, Datenschutz und Softwarequalität aufzugeben. Drittens ordnest Du aktuelle Arbeitsweisen wie Vibe-Coding und Agentic-Coding ein. Beim Vibe-Coding beschreibst Du Deine Absicht in natürlicher Sprache und lässt eine KI viel Code erzeugen. Beim Agentic-Coding arbeitet ein KI-Agent mit Werkzeugen, kann Dateien lesen, Änderungen planen, Tests ausführen und iterativ auf Fehler reagieren. In beiden Fällen bleibt der Mensch verantwortlich: Du prüfst, verstehst, testest und entscheidest.
{{#ev:youtube| https://www.youtube.com/watch?v=ReId8CToUSg |500|center}}
Die bekannte Methode des Rubber-Duck-Debuggings zeigt einen Kern professioneller Fehleranalyse: Wer ein Problem so präzise erklären kann, dass auch ein Gegenüber ohne Kontext den Ablauf versteht, findet oft selbst die Ursache. KI kann hier wie eine sehr schnelle Gesprächspartnerin wirken. Sie ersetzt aber nicht das eigene Denken, sondern fordert bessere Fehlerbeschreibungen, klare Beispiele und überprüfbare Annahmen.
Lernziele
Nach diesem aiMOOC kannst Du erklären, was professionelles Debugging von bloßem Ausprobieren unterscheidet. Du kannst Fehler reproduzieren, eingrenzen, Hypothesen formulieren, geeignete Werkzeuge auswählen und einen Bugfix mit Tests absichern. Du kannst KI als Hilfsmittel für Fehleranalyse, Prompt Engineering, Code Review und Testentwurf nutzen. Außerdem kannst Du Chancen und Risiken von Vibe-Coding und Agentic-Coding beurteilen und einen verantwortungsvollen Arbeitsprozess für Schule, Ausbildung, Studium oder Beruf entwickeln.
Was bedeutet Debugging?
Debugging bezeichnet in der Informatik den Vorgang, Fehler oder unerwartetes Verhalten in einem Computerprogramm zu diagnostizieren und zu beheben. Ein Bug ist nicht immer eine einzelne falsche Zeile. Oft entsteht ein Fehler durch das Zusammenspiel von Anforderung, Architektur, Datenmodell, Benutzereingabe, Schnittstelle, Nebenläufigkeit, Abhängigkeit oder Konfiguration. Professionelles Debugging fragt deshalb nicht nur: Welche Zeile ist falsch? Es fragt: Was hätte passieren sollen, was ist tatsächlich passiert, unter welchen Bedingungen tritt es auf und welche Erklärung passt zu allen Beobachtungen?
Ein wichtiger Unterschied besteht zwischen Symptom, Ursache und Lösung. Das Symptom ist das sichtbare Problem, etwa ein Absturz, eine falsche Ausgabe oder eine langsame Antwortzeit. Die Ursache ist der technische oder fachliche Grund, zum Beispiel eine falsche Annahme, ein Grenzfall, eine fehlerhafte Datenbankabfrage oder ein unvollständiger Test. Die Lösung ist die gezielte Änderung, die die Ursache beseitigt, ohne neue Fehler einzubauen. Wer nur Symptome bekämpft, riskiert Regressionen und schwer wartbaren Code.
Professioneller Debugging-Prozess
Ein professioneller Debugging-Prozess ist iterativ. Du gehst nicht blind von einer Vermutung zur nächsten, sondern arbeitest mit überprüfbaren Schritten. Besonders hilfreich ist ein Ablauf aus Beobachten, Reproduzieren, Eingrenzen, Erklären, Ändern und Absichern.
- Fehlerbeschreibung: Beschreibe erwartetes Verhalten, tatsächliches Verhalten, Umgebung, Eingaben, Versionen und Fehlermeldungen.
- Reproduzierbarkeit: Erstelle einen Weg, mit dem der Fehler zuverlässig ausgelöst werden kann.
- Minimales Beispiel: Reduziere das Problem auf einen möglichst kleinen Fall, der den Fehler noch zeigt.
- Hypothese: Formuliere eine prüfbare Vermutung zur Ursache.
- Instrumentierung: Sammle Daten mit Logging, Tracing, Debugger, Profiler oder Tests.
- Bugfix: Ändere nur so viel wie nötig und begründe die Änderung.
- Regressionstest: Sichere ab, dass derselbe Fehler nicht erneut auftritt.
- Code Review: Lasse Logik, Lesbarkeit, Sicherheit und Nebenwirkungen prüfen.
Ein Debugger unterstützt Dich dabei, ein Programm kontrolliert auszuführen. Mit Haltepunkten kannst Du die Ausführung an einer Stelle stoppen. Mit Einzelschritten untersuchst Du, welche Anweisung als Nächstes ausgeführt wird. Mit Beobachtungen von Variablen, Aufrufstapel und Speicher erkennst Du, wie sich der Zustand des Programms verändert. Das Ziel ist nicht, wahllos im Programm herumzuklicken, sondern gezielt Daten zu einer Hypothese zu sammeln.
Werkzeuge der Fehleranalyse
Professionelle Softwareentwicklung nutzt mehrere Werkzeuge, weil verschiedene Fehlerarten unterschiedliche Spuren hinterlassen. Ein Debugger eignet sich besonders für lokale Kontrollfluss- und Zustandsfehler. Logging hilft, Ereignisse über längere Zeit sichtbar zu machen. Tracing zeigt, wie Anfragen durch verteilte Systeme laufen. Profiling findet Leistungsprobleme. Statische Codeanalyse erkennt bestimmte Muster, bevor der Code ausgeführt wird. Unit-Tests, Integrationstests und End-to-End-Tests machen Verhalten überprüfbar.
In Webentwicklung und Frontend-Arbeit sind Entwicklerwerkzeuge im Browser besonders wichtig. Dort kannst Du Netzwerkaufrufe, Konsolenausgaben, JavaScript-Fehler, DOM-Strukturen, Speicherverbrauch und Performance untersuchen. In Backend-Systemen spielen zusätzlich Logdateien, Metriken, Datenbank-Abfragen, Container-Logs und Monitoring eine große Rolle. In Cloud-Umgebungen wird die Fähigkeit wichtig, zwischen Codefehler, Konfigurationsfehler, Berechtigungsproblem, Netzwerkeffekt und externer Abhängigkeit zu unterscheiden.
KI-gestützte Fehleranalyse
KI-gestützte Fehleranalyse bedeutet, dass Du ein Sprachmodell oder einen Agenten nutzt, um schneller zu verstehen, was ein Fehler bedeuten könnte. Eine KI kann Fehlermeldungen übersetzen, Stacktraces zusammenfassen, wahrscheinliche Ursachen priorisieren, Testfälle erzeugen, Dokumentation durchsuchen, Refactoring-Vorschläge machen oder alternative Erklärungen liefern. Die Qualität hängt stark vom Kontext ab. Je präziser Du erwartetes Verhalten, tatsächliches Verhalten, Umgebung, relevante Codeausschnitte, Logs, bisherige Versuche und Einschränkungen beschreibst, desto hilfreicher wird die Antwort.
KI ist kein Orakel. Ein Modell kann plausible, aber falsche Erklärungen liefern, veraltete Bibliotheken empfehlen, Sicherheitsrisiken übersehen oder Code erzeugen, der nur für den gezeigten Beispielweg funktioniert. Darum gilt: KI-Vorschläge müssen durch Tests, Code Review, Dokumentation, Ausführung und fachliches Verständnis überprüft werden. Besonders wichtig ist der Schutz vertraulicher Daten. Du solltest keine API-Schlüssel, Passwörter, personenbezogenen Daten, internen Zugangsdaten oder unveröffentlichten Geschäftsgeheimnisse in ungeprüfte KI-Systeme kopieren.
Debugging-Prompts professionell formulieren
Ein guter Prompt für Debugging ist wie ein guter Fehlerbericht. Er ist konkret, reproduzierbar und überprüfbar. Statt nur zu schreiben Mein Code geht nicht, beschreibst Du das Ziel, die Umgebung, den relevanten Code, die Fehlermeldung und Deine bisherigen Beobachtungen. Du kannst die KI gezielt bitten, keine endgültige Lösung zu behaupten, sondern Hypothesen mit Prüfwegen zu nennen. So wird aus einer schnellen Antwort ein strukturierter Analyseprozess.
Ein professioneller Debugging-Prompt kann folgende Bestandteile enthalten:
- Rolle: Bitte die KI, als erfahrene Entwicklerin, Testerin oder Sicherheitsprüferin zu agieren.
- Kontext: Beschreibe Sprache, Framework, Version, Betriebssystem, Architektur und relevante Abhängigkeiten.
- Soll-Ist-Vergleich: Erkläre erwartetes Verhalten und beobachtetes Verhalten.
- Reproduktion: Gib genaue Schritte, Eingaben und Daten an.
- Fehlermeldung: Füge Stacktrace, Logauszug oder Konsolenausgabe ein, wenn sie keine sensiblen Daten enthalten.
- Einschränkung: Nenne, was nicht verändert werden darf, etwa öffentliche Schnittstellen oder Datenbankschema.
- Ausgabeformat: Bitte um Hypothesen, Prüfplan, minimale Änderung und passende Tests.
Vibe-Coding: Chancen und Grenzen
Vibe-Coding beschreibt eine Arbeitsweise, bei der Du Software stark über natürliche Sprache steuerst. Du formulierst Absicht, gewünschte Funktion, Stil oder Verhalten, und eine KI erzeugt große Teile des Codes. Das kann beim schnellen Prototyping, beim Erkunden unbekannter Bibliotheken oder beim Erstellen kleiner Werkzeuge sehr produktiv sein. Vibe-Coding verschiebt die Arbeit vom manuellen Schreiben einzelner Zeilen hin zu Anforderungsbeschreibung, Kontextsteuerung, Prüfung und Iteration.
Das Risiko liegt darin, dass der erzeugte Code schneller wächst, als er verstanden wird. Wenn Du Änderungen nur akzeptierst, weil sie im Moment funktionieren, können unklare Architektur, Sicherheitslücken, doppelte Logik, fehlende Tests und schwer wartbare Abhängigkeiten entstehen. Professionelles Vibe-Coding braucht deshalb klare Grenzen: kleine Schritte, Versionskontrolle, Tests, Review, verständliche Commit-Nachrichten und bewusste Entscheidungen über Architektur und Softwarequalität. Die entscheidende Frage lautet nicht: Kann die KI Code erzeugen? Die entscheidende Frage lautet: Kannst Du nachweisen, dass der Code korrekt, sicher, wartbar und zur Aufgabe passend ist?
Agentic-Coding: KI-Agenten im Entwicklungsprozess
Agentic-Coding geht über einfache Codevorschläge hinaus. Ein KI-Agent erhält ein Ziel, plant Teilschritte, liest Dateien, verändert Code, führt Tests oder Befehle aus, analysiert Fehlerausgaben und versucht iterativ, die Aufgabe zu erfüllen. Dadurch ähnelt der Prozess stärker einer Zusammenarbeit mit einem automatisierten Teammitglied. Agentic-Coding kann bei wiederholbaren Aufgaben helfen, etwa beim Aktualisieren einer API-Nutzung, beim Schreiben fehlender Tests, beim Refactoring kleiner Module oder beim Erstellen eines ersten Lösungsvorschlags für ein Issue.
Gerade weil Agenten mehr Handlungsspielraum haben, braucht diese Arbeitsweise klare Governance. Du solltest den Arbeitsbereich begrenzen, Änderungen in separaten Branches ausführen, automatische Tests verlangen, riskante Befehle blockieren, sensible Dateien ausschließen und jeden Diff prüfen. Ein guter Agentic-Coding-Prozess endet nicht mit Die KI ist fertig, sondern mit einem nachvollziehbaren Pull Request, einer Testübersicht, einem Review und einer menschlichen Freigabe. KI kann Ausführung beschleunigen, aber Verantwortung bleibt bei Menschen und Organisationen.
Qualitäts- und Sicherheitsprinzipien
Bei KI-unterstützter Programmierung ist Softwarequalität kein Zusatz, sondern Voraussetzung. Besonders wichtig sind Testbarkeit, Wartbarkeit, Sicherheit, Datenschutz, Lizenz-Bewusstsein und Nachvollziehbarkeit. Jede KI-generierte Änderung sollte so behandelt werden wie Code eines unbekannten Teammitglieds: lesen, verstehen, testen und prüfen. Das gilt besonders für Authentifizierung, Autorisierung, Kryptografie, Zahlungsprozesse, personenbezogene Daten, Produktionsdatenbanken und sicherheitskritische Infrastruktur.
Ein verantwortungsvoller Workflow kann so aussehen: Du startest mit einem Issue, definierst Akzeptanzkriterien, arbeitest in einem Branch, lässt KI nur auf notwendige Dateien zugreifen, forderst Tests ein, prüfst Abhängigkeiten, untersuchst Sicherheitsfolgen und dokumentierst die Entscheidung. Bei unklaren Änderungen solltest Du die KI nicht nach einer bloßen Korrektur fragen, sondern nach einem Diagnoseplan: Welche Ursachen sind möglich? Welche Beobachtung spricht wofür? Welcher Test entscheidet zwischen den Hypothesen? So bleibt Debugging wissenschaftsnah: Du arbeitest mit Beobachtung, Hypothese, Experiment und Auswertung.
Beispiel: Von der Fehlermeldung zum abgesicherten Fix
Angenommen, eine Webanwendung zeigt nach dem Speichern eines Formulars manchmal eine Fehlermeldung. Unprofessionell wäre es, sofort irgendeinen Codeabschnitt zu ändern. Professionell beschreibst Du zuerst den Kontext: Browser, Rolle der Nutzerin, Eingabedaten, Uhrzeit, Version und konkrete Fehlermeldung. Dann prüfst Du, ob der Fehler reproduzierbar ist. Du untersuchst Netzwerkaufrufe, Backend-Logs und Datenbankantworten. Du formulierst Hypothesen, zum Beispiel: Ein Pflichtfeld wird im Frontend anders validiert als im Backend, eine API liefert bei leeren Werten ein anderes Format oder ein Token läuft während des Speicherns ab.
Eine KI kann Dir helfen, die Logs zu gruppieren, mögliche Ursachen zu sammeln oder Testfälle für Grenzwerte vorzuschlagen. Sie darf aber nicht ungeprüft den Produktionscode verändern. Du entscheidest, welche Hypothese plausibel ist, schreibst einen Test, der den Fehler zeigt, änderst den Code minimal, führst die Tests aus, ergänzt bei Bedarf Dokumentation und lässt den Patch prüfen. Erst wenn der Fehler reproduzierbar behoben und gegen Rückfälle abgesichert ist, ist das Debugging professionell abgeschlossen.
Interaktive Aufgaben
Quiz: Teste Dein Wissen
Was ist das Ziel von professionellem Debugging? (Systematisches Diagnostizieren, Beheben und Absichern von Fehlern) (!Schnelles Ausprobieren beliebiger Codeänderungen) (!Das Entfernen aller Kommentare aus dem Code) (!Das Ersetzen aller Tests durch KI-Antworten)
Was beschreibt ein minimales reproduzierbares Beispiel? (Einen kleinen Fall, der den Fehler zuverlässig zeigt) (!Eine besonders lange Dokumentation ohne Code) (!Eine zufällige Vermutung ohne Ausführung) (!Eine Designidee ohne Bezug zum Fehler)
Warum ist eine Hypothese beim Debugging wichtig? (Sie macht eine Ursache prüfbar) (!Sie ersetzt alle Tests) (!Sie verhindert das Lesen von Logs) (!Sie garantiert automatisch die richtige Lösung)
Welches Werkzeug hält ein Programm gezielt an einer bestimmten Stelle an? (Ein Haltepunkt) (!Ein Kommentar) (!Ein Farbschema) (!Ein Dateiname)
Wobei kann KI in der Fehleranalyse sinnvoll helfen? (Beim Sammeln von Hypothesen, Erklären von Fehlermeldungen und Entwerfen von Tests) (!Beim sicheren Erraten geheimer Passwörter) (!Beim Überspringen von Code Review) (!Beim Veröffentlichen ungeprüfter Produktionsdaten)
Was kennzeichnet Vibe-Coding am besten? (Die Beschreibung einer Absicht in natürlicher Sprache, aus der KI Code erzeugt) (!Das ausschließliche Programmieren ohne Computer) (!Das manuelle Sortieren von Logdateien nach Farbe) (!Das Abschalten aller Entwicklungswerkzeuge)
Was unterscheidet Agentic-Coding von einfacher Codevervollständigung? (Ein Agent kann planen, Dateien bearbeiten, Tests ausführen und iterieren) (!Ein Agent schreibt nur einzelne Buchstaben vor) (!Ein Agent verhindert jede Form von Automatisierung) (!Ein Agent funktioniert nur ohne Aufgabenbeschreibung)
Was solltest Du mit KI-generiertem Code tun, bevor er übernommen wird? (Verstehen, testen und im Review prüfen) (!Blind akzeptieren) (!Sofort in Produktion einspielen) (!Alle Fehlermeldungen ignorieren)
Welche Information gehört nicht in einen ungeprüften KI-Prompt? (API-Schlüssel und Zugangsdaten) (!Eine anonymisierte Fehlermeldung) (!Ein kleines Testbeispiel) (!Eine Beschreibung des erwarteten Verhaltens)
Warum sind Regressionstests nach einem Bugfix wichtig? (Sie helfen zu verhindern, dass derselbe Fehler wiederkehrt) (!Sie löschen automatisch alle alten Dateien) (!Sie ersetzen die Versionsverwaltung) (!Sie machen Fachanforderungen unnötig)
Memory
| Bug | Fehler im Programmverhalten |
| Symptom | Sichtbares Problem |
| Hypothese | Prüfbare Erklärung |
| Breakpoint | Gezielte Unterbrechung |
| Logfile | Protokoll von Ereignissen |
| Regressionstest | Schutz vor Rückfällen |
| Prompt | Auftrag an die KI |
| Agent | KI-System mit Werkzeugnutzung |
Drag and Drop
| Ordne die richtigen Begriffe zu. | Thema |
|---|---|
| Fehlerbild | Beobachtung des unerwarteten Verhaltens |
| Reproduktion | Wiederholbares Auslösen des Fehlers |
| Hypothese | Vermutung über die Ursache |
| Instrumentierung | Sammeln von Logs Traces und Messwerten |
| Fix | Gezielte Änderung im Code |
| Absicherung | Test gegen Rückfall |
Kreuzworträtsel
| Debugger | Werkzeug zur kontrollierten Programmuntersuchung |
| Logdatei | Datei mit aufgezeichneten Ereignissen |
| Hypothese | Prüfbare Vermutung zur Fehlerursache |
| Testfall | Konkrete Eingabe mit erwartetem Ergebnis |
| Review | Menschliche Prüfung von Codeänderungen |
| Kontext | Informationen, die eine KI für eine Aufgabe braucht |
LearningApps
Lückentext
Offene Aufgaben
Leicht
- Fehlerbeschreibung: Suche eine einfache Fehlermeldung aus einer Programmierübung und schreibe eine saubere Beschreibung mit Soll-Verhalten, Ist-Verhalten, Umgebung und Reproduktionsschritten.
- Rubber Duck Debugging: Erkläre einem Gegenstand oder einer Mitschülerin Schritt für Schritt, was Dein Code tun soll, und notiere, an welcher Stelle Deine Erklärung unsicher wird.
- Prompt Engineering: Formuliere zwei unterschiedliche Prompts zu derselben Fehlermeldung und vergleiche, welcher Prompt die hilfreichere Antwort erzeugt.
- Logdatei: Erfinde fünf Logeinträge für ein kleines Programm und markiere, welche Einträge für die Fehlersuche nützlich wären.
Standard
- Minimales Beispiel: Reduziere einen fehlerhaften Codeabschnitt so weit, dass der Fehler noch auftritt, aber alle unnötigen Teile entfernt sind.
- Testfall: Schreibe einen Test, der einen bekannten Fehler sichtbar macht, und erkläre, warum dieser Test vor dem Fix fehlschlagen sollte.
- KI-gestützte Fehleranalyse: Gib einer KI eine anonymisierte Fehlermeldung und fordere drei Hypothesen mit Prüfplan an; bewerte anschließend, welche Hypothese am besten überprüfbar ist.
- Code Review: Prüfe einen KI-generierten Lösungsvorschlag auf Lesbarkeit, Nebenwirkungen, fehlende Tests und Sicherheitsrisiken.
Schwer
- Agentic-Coding: Entwirf einen sicheren Workflow, in dem ein KI-Agent nur in einem begrenzten Branch arbeiten darf, Tests ausführt und einen prüfbaren Pull Request erstellt.
- Fehleranalysebericht: Schreibe einen professionellen Bericht zu einem Bug mit Symptom, Ursache, Untersuchungsmethode, Fix, Testabsicherung und offener Restunsicherheit.
- Sicherheitsanalyse: Untersuche ein Beispiel, bei dem KI-generierter Code Eingaben nicht validiert, und entwickle Gegenmaßnahmen gegen Missbrauch.
- Teamprozess: Entwickle Regeln für ein Entwicklungsteam, das Vibe-Coding nutzen möchte, ohne Wartbarkeit, Datenschutz und Verantwortlichkeit zu verlieren.
| <inputbox>
type=create break=no preload=CHAT GPT TEXT HIER EINFÜGEN default= width=30 placeholder= Dein MOOC Titel buttonlabel=MOOC erstellen </inputbox> |
|
|
Lernkontrolle
- Transferaufgabe Debugging-Prozess: Du erhältst eine unklare Fehlermeldung aus einer Webanwendung. Entwickle einen vollständigen Untersuchungsplan, der Reproduktion, Hypothesen, Werkzeuge, Tests und Dokumentation verbindet.
- Vergleich Vibe-Coding und Agentic-Coding: Vergleiche beide Arbeitsweisen anhand eines konkreten Softwareprojekts und begründe, für welche Projektphase welche Arbeitsweise geeignet oder riskant wäre.
- Bewertung KI-generierter Lösungen: Analysiere einen KI-Vorschlag, der zwar den Fehler behebt, aber doppelte Logik einführt. Erkläre, wie Du Qualität, Wartbarkeit und Testbarkeit verbessern würdest.
- Datenschutz und Sicherheit: Entwickle Regeln für den Umgang mit Logs, Kundendaten, Zugangsdaten und internem Code bei der Nutzung von KI-Systemen im Debugging.
- Fehlerkultur: Erkläre, warum eine gute Fehlerkultur in Teams professionelles Debugging fördert, und zeige an einem Beispiel, wie Schuldzuweisung die Fehleranalyse verschlechtert.
Lernnachweis
Für den Lernnachweis erstellst Du ein kleines Portfolio. Es enthält einen anonymisierten Fehlerbericht, ein minimales reproduzierbares Beispiel, mindestens einen Testfall, eine dokumentierte KI-Anfrage mit Reflexion, einen geprüften Lösungsvorschlag und eine kurze Bewertung der Risiken. Wichtig ist nicht, dass jeder Fehler sofort perfekt gelöst wird, sondern dass Dein Vorgehen nachvollziehbar, überprüfbar und verantwortungsvoll ist.
OERs zum Thema
Links
aiMOOC-Projekte
Schulfach+
|
|
aiMOOCs
aiMOOC Projekte
|
|
THE MONKEY DANCE
{{#ev:youtube | https://youtu.be/rFhZlg38Zf8?si=9KdMNZYRkRD81YTo%7C 500 | center}}
|
{{#ev:youtube | https://youtu.be/Ob7etf9QuBo?si=t_NBA71bWg3Rq3LI%7C 500 | center}}
|
|
| <inputbox>
type=create break=no preload=MOOCit Vorlage default= width=30 placeholder= Dein MOOC Titel buttonlabel=MOOC erstellen </inputbox> |