Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-09-13T06:48:48Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}

{{BR}}
= IM6 - KI und Programmieren =

{{BR}}
= Einleitung =

Programmieren bedeutet, einem Computer klare Anweisungen zu geben. Dabei musst Du nicht sofort lange Textzeilen schreiben. In grafischen Programmierumgebungen wie [[Scratch (Programmiersprache)|Scratch]] kannst Du farbige Blöcke zusammensetzen. So erkennst Du leichter, in welcher Reihenfolge etwas passiert, wann sich Befehle wiederholen und unter welcher Bedingung ein Programm anders reagieren soll.

[[Datei:Scratch Beginner Scripts.png|500px|rahmenlos|center]]

In diesem aiMOOC lernst Du, wie [[Künstliche Intelligenz|Künstliche Intelligenz]], kurz '''KI''', beim Programmieren helfen kann. Eine KI kann zum Beispiel eine Codezeile erklären, eine Vermutung über einen Fehler prüfen oder zwei Lösungsideen vergleichen. Sie kann dabei nützliche Vorschläge machen, aber auch etwas missverstehen oder eine falsche Lösung vorschlagen. Deshalb gilt in diesem Kurs ein wichtiger Grundsatz:

'''KI kann Dir beim Denken helfen, aber sie ersetzt Dein eigenes Verständnis nicht.'''

Du sollst am Ende nicht nur sagen können, '''welcher''' Vorschlag funktioniert. Du sollst auch erklären können, '''warum''' er funktioniert.

{{BR}}
== Lernziele ==

Nach diesem aiMOOC kannst Du einfache Programme lesen, testen und verändern. Du kannst grafische Programmblöcke in Scratch sinnvoll anordnen und wichtige Begriffe wie [[Algorithmus]], [[Schleife]], [[Bedingung]], [[Variable]] und [[Debugging]] erklären. Außerdem lernst Du drei konkrete Möglichkeiten kennen, eine KI sinnvoll beim Programmieren einzusetzen:

# [[Code erklären|Codezeile erklären]]: Du lässt Dir eine einzelne Zeile oder einen Block verständlich erklären und prüfst die Erklärung am Programm.
# [[Fehlersuche|Fehlerhypothese prüfen]]: Du beschreibst einen Fehler und eine Vermutung dazu. Anschließend testest Du, ob die Vermutung stimmt.
# [[Problemlösen|Alternative Lösung vergleichen]]: Du vergleichst zwei Lösungswege und entscheidest anhand von Verständlichkeit, Aufwand und Ergebnis.

{{BR}}
= Programmieren mit grafischen Blöcken =

{{BR}}
== Was ist ein Programm? ==

Ein [[Computerprogramm|Programm]] ist eine Folge von Anweisungen, die ein Computer ausführt. Diese Anweisungen müssen eindeutig sein. Ein Computer errät normalerweise nicht, was Du gemeint hast. Wenn eine Figur zehn Schritte gehen soll, braucht das Programm genau den passenden Befehl. Soll sie diese Bewegung immer wieder ausführen, brauchst Du zusätzlich eine Wiederholung.

In Scratch werden solche Befehle als Blöcke dargestellt. Du setzt sie ähnlich wie Puzzleteile zusammen. Dadurch werden viele Schreibfehler vermieden. Trotzdem können Denkfehler entstehen. Ein Programm kann also syntaktisch zusammenpassen und trotzdem etwas anderes tun, als Du möchtest.

[[Datei:Scratchblocks.png|500px|rahmenlos|center]]

{{BR}}
== Wichtige Bausteine ==

{| class="wikitable"
! Baustein
! Bedeutung
! Einfaches Beispiel
|-
| '''Ereignis'''
| Startet einen Programmablauf.
| Wenn die grüne Flagge angeklickt wird, beginnt die Figur sich zu bewegen.
|-
| '''Anweisung'''
| Sagt dem Computer, was er tun soll.
| Gehe 10 Schritte.
|-
| '''Schleife'''
| Wiederholt eine oder mehrere Anweisungen.
| Wiederhole 10-mal: Gehe 10 Schritte.
|-
| '''Bedingung'''
| Prüft, ob etwas gilt, und entscheidet dann.
| Wenn der Rand berührt wird, pralle ab.
|-
| '''Variable'''
| Speichert einen veränderbaren Wert.
| Die Variable Punkte startet bei 0 und wird beim Treffer erhöht.
|}

{{BR}}
== Reihenfolge ist wichtig ==

Computer führen Befehle nach bestimmten Regeln aus. Schon eine kleine Änderung der Reihenfolge kann das Ergebnis verändern. Betrachte diese beiden Abläufe:

{| class="wikitable"
! Lösung A
! Lösung B
|-
| Setze Punkte auf 0 → erhöhe Punkte um 1 → zeige Punkte
| Erhöhe Punkte um 1 → setze Punkte auf 0 → zeige Punkte
|}

Bei Lösung A wird am Ende '''1''' angezeigt. Bei Lösung B wird der Wert nach dem Erhöhen wieder auf '''0''' gesetzt. Beide Abläufe enthalten dieselben Grundbefehle, aber die Reihenfolge ist verschieden.

Genau deshalb ist [[Algorithmisches Denken|algorithmisches Denken]] wichtig: Du überlegst nicht nur, welche Bausteine gebraucht werden, sondern auch, wann und in welcher Reihenfolge sie ausgeführt werden.

{{BR}}
== Ein laufendes Scratch-Programm beobachten ==

[[Datei:Scratch Screenshot, Running Script.png|500px|rahmenlos|center]]

Beim Testen beobachtest Du, was tatsächlich passiert. Das ist wichtiger als die Frage, was Du glaubst, programmiert zu haben. Gute Programmierende vergleichen deshalb immer:

'''Erwartung → tatsächliches Ergebnis → mögliche Ursache → Änderung → neuer Test'''

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

Das Video zeigt am Beispiel von Scratch, wie Ereignisse einen Programmablauf starten können. Achte besonders darauf, wodurch ein Skript beginnt und welche Blöcke danach ausgeführt werden.

{{BR}}
= KI als Hilfe beim Programmieren =

{{BR}}
== Was kann eine KI hier leisten? ==

Eine textbasierte KI kann Sprache und Programmcode verarbeiten und daraus Antworten erzeugen. Beim Lernen kann sie zum Beispiel Begriffe erklären, Code beschreiben, Fehlerideen nennen oder mehrere Lösungen gegenüberstellen. Die Antwort entsteht jedoch nicht dadurch, dass die KI Dein Programm wie ein Mensch vollständig „versteht“. Ein Vorschlag kann passend sein, teilweise passen oder falsch sein.

Deshalb arbeitest Du in diesem Kurs mit der Regel:

'''Fragen → Antwort prüfen → selbst testen → selbst erklären'''

Eine KI-Antwort ist also kein Endergebnis, sondern ein '''Vorschlag zur Prüfung'''.

{{BR}}
== Gute Fragen an eine KI ==

Eine hilfreiche Frage enthält möglichst viel von dem, was für die Aufgabe wichtig ist. Statt nur zu schreiben „Mein Code geht nicht“, ist zum Beispiel diese Beschreibung besser:

<blockquote>
Ich programmiere in Scratch. Beim Klick auf die grüne Flagge soll meine Figur zehnmal je 10 Schritte gehen. Sie bewegt sich aber nur einmal. Ich vermute, dass eine Wiederholung fehlt. Erkläre mir zuerst meine Vermutung und nenne danach einen passenden Scratch-Block. Gib mir außerdem einen Test, mit dem ich prüfen kann, ob die Lösung funktioniert.
</blockquote>

Eine solche Anfrage nennt die Programmierumgebung, das gewünschte Verhalten, das tatsächliche Verhalten und eine eigene Vermutung. Dadurch kannst Du die Antwort leichter beurteilen.

{{BR}}
== Was Du einer KI nicht geben solltest ==

Auch beim Programmieren gelten Regeln für [[Datenschutz]] und einen sicheren Umgang mit digitalen Werkzeugen. Gib keine Passwörter, privaten Adressen, Telefonnummern oder andere unnötige persönliche Daten in ein KI-System ein. Für eine Fehlersuche reichen meistens der relevante Programmabschnitt und eine Beschreibung des Problems.

{{BR}}
= Use-Case 1: Eine Codezeile erklären lassen =

Manchmal sieht eine Codezeile einfach aus, aber ihre Wirkung ist noch unklar. Dann kann eine KI beim Erklären helfen.

Betrachte diese einfache Zeile:

<syntaxhighlight lang="python">
punkte = punkte + 1
</syntaxhighlight>

Eine passende KI-Erklärung könnte lauten:

'''„Nimm den bisherigen Wert von punkte, addiere 1 und speichere das Ergebnis wieder unter dem Namen punkte.“'''

In Scratch entspricht diese Idee ungefähr dem Block:

'''ändere Punkte um 1'''

Wichtig ist, dass Du die Erklärung nicht nur liest. Teste sie mit Beispielen:

{| class="wikitable"
! Wert vorher
! ausgeführte Anweisung
! Wert nachher
|-
| 0
| Punkte um 1 erhöhen
| 1
|-
| 4
| Punkte um 1 erhöhen
| 5
|-
| 9
| Punkte um 1 erhöhen
| 10
|}

Wenn Du diese Veränderung selbst vorhersagen kannst, hast Du die Codezeile verstanden.

{{BR}}
== Eine Erklärung prüfen ==

Angenommen, eine KI behauptet:

'''„Die Zeile setzt die Punkte immer auf 1.“'''

Das klingt zunächst vielleicht plausibel, ist aber falsch. Mit dem Testwert 4 kannst Du zeigen, dass danach 5 entsteht. Ein einziges gutes Gegenbeispiel kann also reichen, um eine falsche Erklärung zu entdecken.

Das ist ein wichtiger Lernschritt: '''Du prüfst die KI mit Deinem Wissen und mit Tests.'''

{{BR}}
= Use-Case 2: Eine Fehlerhypothese prüfen =

[[Debugging]] bedeutet, Fehler systematisch zu suchen und zu beheben. Dabei ist es oft hilfreich, zuerst eine '''Fehlerhypothese''' zu bilden. Eine Hypothese ist eine begründete Vermutung.

Beispiel:

'''Ziel:''' Eine Figur soll sich dauerhaft bewegen und am Rand umdrehen.

'''Beobachtung:''' Die Figur bewegt sich nur ein einziges Mal.

'''Hypothese:''' Die Bewegungsanweisung liegt nicht in einer Dauerschleife.

Eine KI könnte dazu sagen:

'''„Die Hypothese passt zur Beobachtung. Prüfe, ob der Bewegungsblock innerhalb eines Wiederhole-fortlaufend-Blocks liegt.“'''

Das ist noch kein Beweis. Jetzt musst Du testen.

# Starte das Programm und beobachte die Figur.
# Setze die Bewegungsanweisung in eine Dauerschleife.
# Starte das Programm erneut.
# Prüfe, ob sich genau das Verhalten verändert hat, das zu Deiner Hypothese gehört.

Wenn sich die Figur jetzt dauerhaft bewegt, wird Deine Vermutung gestützt. Falls nicht, musst Du eine neue Ursache untersuchen.

[[Datei:Scratch 3.0 Screenshot, Gravity Script.png|500px|rahmenlos|center]]

Auch bei längeren Programmen hilft es, nicht alles gleichzeitig zu verändern. Ändere möglichst nur eine vermutete Ursache und teste anschließend erneut.

{{BR}}
== Fehlerbeispiel: Falsche Bedingung ==

Ein Spiel soll beendet werden, wenn die Variable '''Leben''' den Wert 0 erreicht.

Fehlerhafte Idee:

'''Wenn Leben größer als 0 ist, dann sage „Game Over“.'''

Was passiert? Das Spiel meldet „Game Over“, obwohl noch Leben vorhanden sind.

Eine sinnvolle Fehlerhypothese lautet:

'''Der Vergleich in der Bedingung ist falsch herum.'''

Eine KI kann nun gebeten werden, diese Hypothese zu prüfen. Du solltest anschließend aber selbst erklären können, warum eine Bedingung wie '''Leben = 0''' besser zum gewünschten Verhalten passt.

{{BR}}
== Fehlerbeispiel: Befehl am falschen Ort ==

Ein Punktezähler soll bei jedem eingesammelten Stern um 1 steigen. Der Block '''ändere Punkte um 1''' liegt aber außerhalb der Abfrage, ob der Stern berührt wird. Dadurch steigen die Punkte ständig.

Die Ursache ist hier nicht ein falscher Zahlenwert, sondern die '''Position des Befehls im Programmablauf'''.

Eine gute Frage an eine KI wäre:

<blockquote>
Mein Punktestand steigt ständig. Er soll nur steigen, wenn die Figur den Stern berührt. Ich vermute, dass der Block „ändere Punkte um 1“ an der falschen Stelle liegt. Welche Beobachtung würde diese Vermutung bestätigen?
</blockquote>

Die wichtigste Leistung bleibt Deine eigene: Du musst den Zusammenhang zwischen Bedingung und Punktezähler verstehen.

{{BR}}
= Use-Case 3: Alternative Lösungen vergleichen =

Für ein Programmierproblem gibt es oft mehrere funktionierende Lösungen. Eine KI kann helfen, Unterschiede sichtbar zu machen.

Aufgabe: Eine Figur soll 100 Schritte laufen.

'''Lösung A:''' Einmal „gehe 100 Schritte“.

'''Lösung B:''' Zehnmal „gehe 10 Schritte“.

Beide Lösungen können zum gleichen Endpunkt führen. Trotzdem sind sie nicht in jeder Situation gleich gut.

{| class="wikitable"
! Frage
! Lösung A
! Lösung B
|-
| Ist sie kurz?
| Ja
| Etwas länger
|-
| Zeigt sie eine Wiederholung?
| Nein
| Ja
|-
| Kann zwischen den Schritten leicht noch etwas anderes passieren?
| Weniger flexibel
| Flexibler
|-
| Ist sie gut zum Lernen von Schleifen?
| Weniger
| Ja
|}

Eine KI könnte Lösung A als „effizienter“ bezeichnen, weil sie weniger Blöcke braucht. Für eine Lernaufgabe über Schleifen kann Lösung B trotzdem sinnvoller sein. Die beste Lösung hängt also vom '''Ziel''' ab.

{{BR}}
== Vergleich statt blindes Übernehmen ==

Wenn eine KI zwei Lösungen vorschlägt, kannst Du immer drei Fragen stellen:

# Erreichen beide Lösungen wirklich dasselbe Ergebnis?
# Welche Lösung kann ich selbst besser erklären?
# Welche Lösung passt besser zu meiner Aufgabe?

Die kürzeste Lösung ist nicht automatisch die beste. Für Anfängerinnen und Anfänger kann eine etwas längere, aber gut sichtbare Lösung verständlicher sein.

{{BR}}
= KI-Codevorschläge richtig prüfen =

{{BR}}
== Beispiel 1: Ein sinnvoller Vorschlag ==

Aufgabe: Nach dem Berühren eines Sterns soll der Punktestand steigen.

Möglicher KI-Vorschlag in Scratch-Idee:

'''Wenn Stern berührt → ändere Punkte um 1'''

Dieser Vorschlag klingt passend. Prüfe trotzdem:

'''Wird der Punktestand nur einmal erhöht oder bei jedem Bildwechsel immer wieder, solange die Figuren sich berühren?'''

Vielleicht brauchst Du zusätzlich eine kurze Pause, einen Positionswechsel des Sterns oder eine andere Logik. Ein Vorschlag kann also grundsätzlich richtig und trotzdem noch unvollständig sein.

{{BR}}
== Beispiel 2: Ein unpassender Vorschlag ==

Aufgabe: Die Figur soll sich mit der Pfeiltaste nach rechts bewegen.

Unpassender KI-Vorschlag:

'''Wenn Leertaste gedrückt → gehe 10 Schritte'''

Der Code kann technisch funktionieren, erfüllt aber die Aufgabe nicht, weil die falsche Taste verwendet wird.

Das zeigt: '''Ein fehlerfreies Programm kann trotzdem die falsche Aufgabe lösen.'''

{{BR}}
== Beispiel 3: Ein Vorschlag mit Denkfehler ==

Aufgabe: Bei 10 Punkten soll die Figur „Gewonnen!“ sagen.

Fehlerhafter Vorschlag:

'''Wenn Punkte kleiner als 10 → sage „Gewonnen!“'''

Hier muss die Bedingung zum Ziel passen. Du kannst gezielt mit Testwerten prüfen:

{| class="wikitable"
! Punkte
! Soll „Gewonnen!“ erscheinen?
|-
| 3
| Nein
|-
| 9
| Nein
|-
| 10
| Ja
|-
| 12
| Je nach Spielregel möglicherweise bereits gewonnen
|}

Mit solchen [[Testfall|Testfällen]] prüfst Du nicht nur KI-Vorschläge, sondern generell Programme.

{{BR}}
= Eine einfache Debugging-Strategie =

Wenn etwas nicht funktioniert, hilft ein fester Ablauf.

# '''Ziel beschreiben''': Was soll passieren?
# '''Beobachten''': Was passiert tatsächlich?
# '''Hypothese bilden''': Welche Ursache könnte den Unterschied erklären?
# '''Eine Sache ändern''': Verändere nur den vermuteten Fehler.
# '''Testen''': Starte das Programm erneut.
# '''Ergebnis erklären''': Was zeigt der Test?
# '''Falls nötig neue Hypothese bilden''': Suche erst dann weiter.

Eine KI kann bei den Schritten 2 bis 5 Ideen liefern. Schritt 6 ist für Dein Lernen besonders wichtig: '''Du formulierst selbst, was Du herausgefunden hast.'''

{{BR}}
= KI-Antworten bewerten =

Eine gute Antwort ist nicht nur freundlich oder lang. Fürs Programmieren sollte sie überprüfbar sein.

{| class="wikitable"
! Prüffrage
! Warum ist sie wichtig?
|-
| Passt die Antwort zu meiner Programmiersprache oder Programmierumgebung?
| Ein Python-Vorschlag hilft nicht direkt, wenn Du nur Scratch-Blöcke einsetzen sollst.
|-
| Passt die Antwort genau zu meinem Ziel?
| Technisch funktionierender Code kann trotzdem die falsche Aufgabe lösen.
|-
| Kann ich den Vorschlag testen?
| Ein Test zeigt, ob die Wirkung tatsächlich eintritt.
|-
| Kann ich erklären, warum der Vorschlag funktioniert?
| Erst dann wird aus Übernehmen echtes Verstehen.
|-
| Gibt es eine einfachere Lösung?
| Eine verständliche Lösung ist beim Lernen oft besser als unnötig komplizierter Code.
|}

{{BR}}
= KI verstehen: Sie ist kein allwissender Programmierprofi =

Eine generative KI erzeugt Antworten auf Grundlage gelernter Muster. Sie kann hilfreiche Erklärungen und Codeideen liefern. Sie garantiert aber nicht, dass jede Aussage korrekt ist. Besonders bei unklaren Aufgaben kann sie Annahmen treffen, die Du gar nicht gemeint hast.

Darum ist es sinnvoll, einer KI Grenzen zu setzen:

<blockquote>
Erkläre nur den markierten Programmteil. Verwende Begriffe für Klasse 6. Nenne zuerst meine Vermutung, dann einen Test. Gib nicht sofort die vollständige Lösung.
</blockquote>

So wird die KI eher zum Lernhelfer als zum Lösungsautomaten.

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

Das Video der Sendung mit der Maus erklärt kindgerecht, was Künstliche Intelligenz ist. Überlege beim Anschauen: Welche Aufgaben kann eine KI bearbeiten, und warum ist eine erzeugte Antwort trotzdem etwas, das Du prüfen solltest?

{{BR}}
= Mini-Projekt: Der Sternesammler =

Du programmierst ein kleines Scratch-Spiel. Eine Figur bewegt sich über die Bühne und sammelt Sterne. Jeder berührte Stern erhöht den Punktestand.

Das Grundmodell lautet:

# Beim Start wird '''Punkte''' auf 0 gesetzt.
# Die Figur kann mit Tasten gesteuert werden.
# Wenn die Figur einen Stern berührt, steigt '''Punkte''' um 1.
# Der Stern erscheint danach an einer neuen Position.
# Bei 10 Punkten erscheint eine Gewinnmeldung.

Baue zuerst selbst eine einfache Version. Nutze eine KI erst dann für eine gezielte Frage, zum Beispiel:

'''„Meine Punkte steigen manchmal mehrfach, obwohl ich einen Stern nur einmal berühre. Nenne zwei mögliche Ursachen, aber gib mir noch keine fertige Lösung.“'''

Prüfe anschließend jede Ursache einzeln.

{{BR}}
== Drei KI-Rollen im Mini-Projekt ==

{| class="wikitable"
! KI-Rolle
! Beispiel
! Deine Aufgabe
|-
| '''Erklärhilfe'''
| „Was bedeutet der Block ändere Punkte um 1?“
| Erkläre danach mit eigenen Worten und teste mit zwei Startwerten.
|-
| '''Fehlerhilfe'''
| „Ich vermute, dass der Berührungsblock zu oft ausgeführt wird. Wie kann ich das prüfen?“
| Formuliere einen Test und beobachte das Ergebnis.
|-
| '''Vergleichshilfe'''
| „Vergleiche: Stern verstecken und neu platzieren oder kurz warten.“
| Entscheide, welche Lösung zu Deinem Spiel besser passt, und begründe.
|}

{{BR}}
= Merksätze =

'''Ein Programm ist eine genaue Folge von Anweisungen.'''

'''Ein Test vergleicht Erwartung und tatsächliches Verhalten.'''

'''Ein Fehler ist eine Gelegenheit, den Programmablauf besser zu verstehen.'''

'''Eine KI-Antwort ist ein Vorschlag, kein Beweis.'''

'''Wenn Du eine Lösung nicht erklären kannst, solltest Du sie noch nicht einfach übernehmen.'''

{{BR}}
= Interaktive Aufgaben =

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

{{MC}}

'''Wofür eignet sich KI beim Programmieren in diesem Kurs besonders?'''
(Zum Erklären Prüfen und Vergleichen)
(!Zum blinden Übernehmen jeder Lösung)
(!Zum Ersetzen aller eigenen Tests)
(!Zum Vermeiden von Verständnis)

{{E}}
<br>

{{MC}}

'''Was ist eine Schleife in einem Programm?'''
(Eine Wiederholung von Anweisungen)
(!Ein gespeichertes Bild)
(!Eine Fehlermeldung)
(!Eine Internetverbindung)

{{E}}
<br>

{{MC}}

'''Was solltest Du nach einem KI-Codevorschlag tun?'''
(Den Vorschlag testen und erklären)
(!Den Vorschlag sofort abgeben)
(!Alle eigenen Ideen löschen)
(!Den Code nie mehr verändern)

{{E}}
<br>

{{MC}}

'''Was ist eine Fehlerhypothese?'''
(Eine begründete Vermutung über eine Fehlerursache)
(!Eine sichere richtige Lösung)
(!Ein Name für eine Spielfigur)
(!Ein zufälliger Programmblock)

{{E}}
<br>

{{MC}}

'''Warum sind Testfälle nützlich?'''
(Sie prüfen wie sich ein Programm bei bestimmten Werten verhält)
(!Sie ersetzen das Programmieren vollständig)
(!Sie machen Variablen überflüssig)
(!Sie verhindern jede Art von Fehler automatisch)

{{E}}
<br>

{{MC}}

'''Was bewirkt die Idee Punkte gleich Punkte plus 1?'''
(Der bisherige Punktestand wird um eins erhöht)
(!Der Punktestand wird immer auf null gesetzt)
(!Der Punktestand wird gelöscht)
(!Die Figur bewegt sich einen Schritt)

{{E}}
<br>

{{MC}}

'''Was bedeutet Debugging?'''
(Fehler systematisch suchen und beheben)
(!Bilder in ein Spiel laden)
(!Ein Passwort speichern)
(!Eine Figur zeichnen)

{{E}}
<br>

{{MC}}

'''Wann ist eine alternative Lösung besonders sinnvoll?'''
(Wenn Du verschiedene Wege vergleichen und begründen möchtest)
(!Wenn Du nie testen willst)
(!Wenn nur die längste Lösung erlaubt ist)
(!Wenn kein Ziel vorhanden ist)

{{E}}
<br>

{{MC}}

'''Was ist bei einer Bedingung wichtig?'''
(Sie muss zum gewünschten Verhalten passen)
(!Sie muss immer wahr sein)
(!Sie darf keine Variable verwenden)
(!Sie muss immer am Programmende stehen)

{{E}}
<br>

{{MC}}

'''Welche Aussage über KI-Antworten ist richtig?'''
(Sie können hilfreich sein müssen aber geprüft werden)
(!Sie sind immer vollständig richtig)
(!Sie ersetzen eigenes Denken)
(!Sie brauchen keine Tests)

{{E}}
<br>

{{BR}}
== Memory ==

<div class="memo-quiz">
{|
|-
| Schleife || Wiederholt Anweisungen
|-
| Bedingung || Entscheidet abhängig von einer Prüfung
|-
| Variable || Speichert einen veränderbaren Wert
|-
| Debugging || Systematische Fehlersuche
|-
| KI-Hinweis || Vorschlag der überprüft werden muss
|-
| Testfall || Geplanter Versuch mit erwartetem Ergebnis
|}
{{E}}
<br>

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

<div class="lueckentext-quiz">

{| class="wikitable"
! Ordne die richtigen Begriffe zu.
! Thema
|-
| '''Codezeile erklären'''
| Bedeutung eines einzelnen Befehls verständlich machen
|-
| '''Fehlerhypothese prüfen'''
| Eine vermutete Ursache mit einem Test untersuchen
|-
| '''Alternative vergleichen'''
| Zwei Lösungswege nach passenden Kriterien gegenüberstellen
|-
| '''Testen'''
| Erwartetes und tatsächliches Verhalten vergleichen
|-
| '''Selbst begründen'''
| Mit eigenen Worten erklären warum eine Lösung passt

|}
{{E}}

<br>
...
<br />

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

<div class="kreuzwort-quiz">
{|
|-
| Scratch || Welche visuelle Programmiersprache nutzt farbige Blöcke und eignet sich gut für den Einstieg?
|-
| Schleife || Wie heißt ein Programmelement das Anweisungen wiederholt?
|-
| Variable || Wie heißt ein Speicherplatz für einen veränderbaren Wert?
|-
| Bedingung || Wie heißt eine Prüfung von der eine Entscheidung im Programm abhängt?
|-
| Debugging || Wie nennt man das systematische Suchen und Beheben von Programmfehlern?
|-
| Algorithmus || Wie heißt eine eindeutige Folge von Schritten zur Lösung einer Aufgabe?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=IM6+-+KI+und+Programmieren </iframe>

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

<quiz display=simple>
{'''Vervollständige den Text.'''<br>
|type="{}"}
Beim Programmieren formuliert man genaue { Anweisungen } für einen Computer.
In Scratch werden viele Befehle als grafische { Blöcke } dargestellt.
Eine { Schleife } führt Anweisungen mehrfach aus.
Eine { Bedingung } entscheidet abhängig von einer Prüfung über den weiteren Ablauf.
Eine { Variable } kann einen veränderbaren Wert wie einen Punktestand speichern.
Beim { Debugging } werden Fehler systematisch gesucht und untersucht.
Eine Vermutung über die Ursache eines Fehlers heißt { Fehlerhypothese }.
Ein KI-Vorschlag sollte immer durch einen passenden { Test } überprüft werden.
Beim Vergleichen mehrerer Lösungen ist nicht nur Kürze sondern auch { Verständlichkeit } wichtig.
KI kann beim Erklären und Prüfen helfen ersetzt aber nicht das eigene { Verständnis }.
</quiz>

<br>

{{BR}}
= Offene Aufgaben =

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

# [[Code erklären]]: Wähle einen einfachen Scratch-Block aus und schreibe zuerst selbst eine Erklärung in einem Satz. Lass Dir danach von einer KI eine Erklärung für Klasse 6 geben. Markiere, was beide Erklärungen gemeinsam haben.
# [[Testfall entwickeln]]: Erstelle für die Anweisung „ändere Punkte um 1“ drei Testfälle mit unterschiedlichen Startwerten. Sage jeweils vorher, welches Ergebnis Du erwartest, und prüfe es anschließend.
# [[Fehler finden]]: Baue absichtlich ein Scratch-Skript, bei dem sich eine Figur nur einmal statt dauerhaft bewegt. Tausche das Projekt mit einer Partnerin oder einem Partner und finde den Fehler.
# [[KI-Frage verbessern]]: Formuliere aus der ungenauen Frage „Mein Code geht nicht“ eine genaue Frage mit Ziel, Beobachtung und Vermutung.

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

# [[Fehlerhypothese]]: Programmiere einen Punktezähler mit einem absichtlichen Fehler. Formuliere zwei mögliche Fehlerhypothesen und entwickle für jede Hypothese einen eigenen Test.
# [[Lösungsvergleich]]: Löse dieselbe Bewegungsaufgabe einmal mit einem großen Bewegungsschritt und einmal mit einer Schleife aus mehreren kleinen Schritten. Vergleiche beide Lösungen nach Verständlichkeit, Länge und Erweiterbarkeit.
# [[KI als Tutor]]: Bitte eine KI, Dir einen Scratch-Block nur mit einer Frage zu erklären, statt sofort die Lösung zu nennen. Bewerte, ob die Rückfrage Dir beim eigenen Denken geholfen hat.
# [[Debugging-Protokoll]]: Dokumentiere eine echte Fehlersuche in fünf Spalten: Ziel, Beobachtung, Hypothese, Änderung, Ergebnis. Ergänze, an welcher Stelle eine KI hilfreich war und an welcher Stelle Du selbst entscheiden musstest.

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

# [[Sternesammler]]: Entwickle das Mini-Spiel aus dem Lerntext vollständig. Baue mindestens eine Variable, eine Bedingung und eine Schleife ein. Lass Dir von einer KI nur für einen selbst gewählten Problemteil helfen und dokumentiere die Prüfung des Vorschlags.
# [[KI-Codekritik]]: Lass Dir zwei unterschiedliche Lösungsvorschläge für dieselbe einfache Scratch-Aufgabe geben. Teste beide und verfasse eine begründete Empfehlung, welche Lösung für Anfängerinnen und Anfänger verständlicher ist.
# [[Fehlerwerkstatt]]: Erstelle drei kleine fehlerhafte Programme mit unterschiedlichen Fehlerarten: falsche Reihenfolge, falsche Bedingung und fehlende Wiederholung. Formuliere zu jedem Programm eine passende Fehlerhypothese und einen Test.
# [[Erklärvideo]]: Produziere ein kurzes Lernvideo mit Bildschirmaufnahme, in dem Du zeigst, wie Du einen Fehler selbst eingrenzt, eine KI gezielt befragst, den Vorschlag testest und am Ende mit eigenen Worten erklärst.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= Lernkontrolle =

# [[Programmablauf analysieren]]: Eine Figur soll beim Start fünfmal je 20 Schritte gehen. Sie bewegt sich nur einmal. Beschreibe mindestens zwei mögliche Ursachen, ordne sie nach Wahrscheinlichkeit und entwickle für die erste Ursache einen Test.
# [[KI-Antwort bewerten]]: Eine KI empfiehlt bei einem Punktestand-Problem, die Variable bei jedem Schleifendurchlauf auf 0 zu setzen. Erkläre, wann das sinnvoll sein könnte und warum es während des Spiels meistens den Punktezähler zerstören würde.
# [[Alternative Lösungen beurteilen]]: Vergleiche „gehe 100 Schritte“ mit „wiederhole 10-mal gehe 10 Schritte“. Entscheide für eine Lernaufgabe über Schleifen und für ein möglichst kurzes Programm jeweils neu, welche Lösung besser passt.
# [[Transfer auf ein neues Spiel]]: In einem Labyrinth-Spiel soll eine Figur beim Berühren einer Wand zum Start zurückkehren. Formuliere eine Bedingung, beschreibe einen passenden Testfall und nenne eine mögliche Fehlerhypothese, falls die Rückkehr nicht funktioniert.
# [[Gute KI-Nutzung begründen]]: Erkläre anhand eines eigenen Beispiels den Unterschied zwischen „Lass die KI mein Problem lösen“ und „Nutze die KI, um meine Vermutung zu prüfen“. Zeige, warum die zweite Vorgehensweise mehr eigenes Verständnis fördern kann.
# [[Teststrategie entwickeln]]: Ein Programm besitzt drei mögliche Fehlerstellen. Plane eine Testreihenfolge, bei der Du immer nur eine Sache veränderst. Begründe, warum diese Vorgehensweise zuverlässiger ist als viele Änderungen gleichzeitig.

<br>
<br>

{{BR}}
= Lernnachweis =

Für einen Lernnachweis zu '''IM6 - KI und Programmieren''' ist wichtig, dass Du nicht nur ein funktionierendes Endprodukt zeigst, sondern auch Deinen Denk- und Prüfprozess sichtbar machst.

# [[Grundbegriffe]]: Du kannst Algorithmus, Schleife, Bedingung, Variable, Testfall und Debugging mit eigenen Worten erklären.
# [[Programmverständnis]]: Du kannst vorhersagen, was ein einfacher Programmablauf tun wird, und Deine Vorhersage durch einen Test überprüfen.
# [[Fehlersuche]]: Du kannst aus einer Beobachtung eine begründete Fehlerhypothese bilden und gezielt testen.
# [[KI-Nutzung]]: Du kannst eine KI zum Erklären, Prüfen einer Hypothese oder Vergleichen von Alternativen einsetzen, ohne ihre Antwort ungeprüft zu übernehmen.
# [[Begründung]]: Du kannst erklären, warum eine Lösung funktioniert und warum Du sie einer anderen Lösung vorziehst.
# [[Dokumentation]]: Du kannst zeigen, welche Änderung Du vorgenommen hast und welche Beobachtung danach Deine Entscheidung bestätigt oder widerlegt hat.

<br>
<br>

{{BR}}
= OERs zum Thema =

<iframe> https://de.m.wikipedia.org/wiki/Scratch_(Programmiersprache) </iframe>

<iframe> https://de.m.wikipedia.org/wiki/K%C3%BCnstliche_Intelligenz </iframe>

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

<br>

{{BR}}
= Verknüpfte Lernbereiche =

{| align=center
{{:D-Tab}}
'''[[IM6 - KI und Programmieren]]'''
# [[Programmierung]]
# [[Scratch (Programmiersprache)]]
# [[Algorithmus]]
# [[Schleife]]
# [[Bedingung]]
# [[Variable]]
# [[Debugging]]
# [[Künstliche Intelligenz]]
# [[Testen]]
# [[Problemlösen]]
|}

[[Kategorie:Informatik]]
[[Kategorie:Künstliche Intelligenz]]
[[Kategorie:Programmierung]]
[[Kategorie:Scratch]]
[[Kategorie:Medienbildung]]
[[Kategorie:Digitale Bildung]]
[[Kategorie:Klasse 5-6]]
[[Kategorie:Klasse 6]]

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

IM6 - KI und Programmieren - Versionsgeschichte

Glanz: aiMOOC über GPT aiMOOC Action erstellt