| 1. Grundlagen |
|
|
|
| 1. Algorithmusbegriff |
Algorithmus, Algorithmusbegriff |
|
|
| 1. Ein Suchproblem |
|
|
|
| 2. Anforderungen an ein Lösungsverfahren |
|
|
|
| 3. Fachkonzept - Algorithmus |
|
|
|
| 4. Darstellung von Algorithmen |
|
|
|
| 5. Bausteine von Algorithmen |
|
|
|
| 6. Algorithmen im Alltag |
|
|
|
| 7. Übungen |
|
|
|
| 2. Bedeutung - früher und heute |
|
|
|
| 1. Fallstudie - Ägyptische Multiplikation |
Algorithmus, historisch |
Python |
|
| 1. Rechnen mit Hieroglyphen |
|
|
|
| 2. Ein Multiplikationsverfahren |
|
|
|
| 3. Ein Multiplikationsalgorithmus |
|
|
|
| 4. Implementierung des Multiplikationsalgorithmus |
|
|
|
| 5. Bedeutung des Multiplikationsalgorithmus |
|
|
|
| 2. Fallstudie - PageRank |
Algorithmus, Suche, Gesellschaft |
Python |
|
| 1. Das Ranking-Problem |
|
|
|
| 2. Verlinkung von Webseiten als Lösungsansatz |
|
|
|
| 3. Das Zufallssurfermodell |
|
|
|
| 4. Modellerweiterung |
|
|
|
| 5. Ein Ranking-Algorithmus |
|
|
|
| 6. Bedeutung des Ranking-Algorithmus |
|
|
|
| 3. Fallstudie - Turnierplanung |
Algorithmus, Gesellschaft |
Python |
|
| 1. Turnierplanung als Problem |
|
|
|
| 2. Ein Verfahren zur Turnierplanung |
|
|
|
| 3. Algorithmen zur Turnierplanung |
|
|
|
| 4. Automatisierung geistiger Tätigkeiten |
|
|
|
| 3. Korrektheit und Aufwand |
|
|
|
| 1. Korrektheit von Algorithmen |
Algorithmus, Korrektheit |
Python |
|
| 1. Das Wechselwegnahmeverfahren |
|
|
|
| 2. Eine Verhaltensbeschreibung |
|
|
|
| 3. Korrektheit als Problem |
|
|
|
| 4. Korrektheit testen |
|
|
|
| 5. Korrektheit mit Python testen |
|
|
|
| 6. Korrektheit verifizieren |
|
|
|
| 7. Fachkonzept - Korrektheit |
|
|
|
| 8. Übungen |
|
|
|
| 2. Effizienz von Algorithmen |
Algorithmus, Effizienz |
Python |
|
| 1. Algorithmen zur ggT-Berechnung |
|
|
|
| 2. Laufzeit messen |
|
|
|
| 3. Aktionen zählen |
|
|
|
| 4. Fachkonzept - Effizienz |
|
|
|
| 5. Übungen |
|
|
|
| 2. Rekursive Algorithmen |
Algorithmus, Rekursion |
|
|
| 1. Problemlösen durch Problemreduktion |
|
|
|
| 1. Einstieg - Die Türme von Hanoi |
|
|
|
| 2. Erkundung - Lösung für drei Scheiben |
|
|
|
| 3. Erkundung - Strategien für mehr als drei Scheiben |
|
|
|
| 4. Fachkonzept - Rekursive Problemreduktion |
|
|
|
| 5. Exkurs - Implementierung in Python |
|
|
|
| 2. Fallstudie - Selbstähnliche Figuren |
Algorithmus, Rekursion, Grafik, Selbstähnlichkeit |
Python |
|
| 1. Einstieg - Eine selbstähnliche Figur |
|
|
|
| 2. Exkurs - Turtle-Grafik |
|
|
|
| 3. Übungen |
|
|
|
| 1. Hinweise - Quadratbaum |
|
|
|
| 3. Fallstudie - Rekursive Verarbeitung von Listen |
Algorithmus, Rekursion, Liste |
Python |
|
| 1. Einstieg - Geschachtelte Listen |
|
|
|
| 2. Fachkonzept - Liste als rekursive Datenstruktur |
|
|
|
| 3. Übungen |
|
|
|
| 4. Anwendung - Verarbeitung geometrischer Objekte |
|
|
|
| 4. Rekursive Verarbeitung natürlicher Zahlen |
Algorithmus, Rekursion |
Python |
|
| 1. Einstieg - Wege im Galton-Brett |
|
|
|
| 2. Fachkonzept - Natürliche Zahlen als rekursive Datenstruktur |
|
|
|
| 3. Übungen |
|
|
|
| 4. Anwendung - Operationen auf natürlichen Zahlen |
|
|
|
| 5. Rekursion und Berechnungsaufwand |
Algorithmus, Rekursion, Aufwand |
Python |
|
| 1. Exkurs - Rekursive Berechnungen mit hohem Aufwand |
|
|
|
| 2. Exkurs - Grenzen der rekursiven Verarbeitung |
|
|
|
| 6. Rekursion und Iteration |
Algorithmus, Rekursion, Iteration |
Python |
|
| 1. Exkurs - Umwandlung rekursiver Algorithmen in iterative Algorithmen |
|
|
|
| 2. Exkurs - Umwandlung iterativer Algorithmen in rekursive Algorithmen |
|
|
|
| 3. Standardalgorithmen |
|
|
|
| 1. Suchen |
Algorithmus, Siche, linear, binär |
Python |
|
| 1. Ein Suchproblem |
|
|
|
| 2. Entwicklung von Suchalgorithmen |
|
|
|
| 3. Lineare Suche |
|
|
|
| 4. Binäre Suche |
|
|
|
| 5. Aufwandsanalyse |
|
|
|
| 6. Anwendung der Suchalgorithmen |
|
|
|
| 2. Sortieren |
Algorithmus, Sortieren |
Python |
|
| 1. Das Sortierproblem |
|
|
|
| 2. Entwicklung von Sortieralgorithmen |
|
|
|
| 3. Sortierverfahren |
|
|
|
| 1. Sortieren durch Auswählen / Selectionsort |
|
|
|
| 2. Sortieren durch Einfügen / Insertionsort |
|
|
|
| 3. Sortieren durch Aufsteigen / Bubblesort |
|
|
|
| 4. Sortieren durch Zerlegen / Quicksort |
|
|
|
| 5. Anwendung der Sortieralgorithmen |
|
|
|
| 4. Laufzeitverhaltens |
|
|
|
| 5. Aufwandsanalyse |
|
|
|
| 3. Stapel |
Algorithmus, Stapel |
Python |
|
| 1. Einstieg - Auswertung von Rechentermen |
|
|
|
| 2. Konzept - Stapel |
|
|
|
| 3. Exkurs - Implementierung einer Stapel-Klasse |
|
|
|
| 4. Anwendung - Auswertung von Rechentermen |
|
|
|
| 4. Schlangen |
Algorithmus, Schlange, Warteschlange |
Python |
|
| 1. Einstieg - Warteschlangen |
|
|
|
| 2. Konzept - Schlange |
|
|
|
| 3. Exkurs - Implementierung von Schlangen in Python |
|
|
|
| 4. Übungen |
|
|
|
| 5. Graphen und ihre Verarbeitung |
Algorithmus, Graph |
Python |
|
| 1. Vernetzte Strukturen |
|
|
|
| 1. Einstieg - Routenplanung |
|
|
|
| 2. Fachkonzept - Graph |
|
|
|
| 3. Exkurs - Graphen in Anwendungssituationen |
|
|
|
| 4. Glossar - Begriffe rund um Graphen |
|
|
|
| 5. Exkurs - Soziale Netzwerke im Internet |
|
|
|
| 6. Übungen |
|
|
|
| 2. Implementierung von Graphen |
Algorithmus, Graph, objektorientiert |
Python |
|
| 1. Repräsentation von Graphen |
|
|
|
| 1. Repräsentation mit einer Nachbarschaftstabelle |
|
|
|
| 2. Implementierung einer Nachbarschaftstabelle |
|
|
|
| 3. Repräsentation mit Nachbarschaftslisten |
|
|
|
| 4. Implementierung von Nachbarschaftslisten |
|
|
|
| 2. Eine Klasse zur Verwaltung von Graphen |
|
|
|
| 3. Eine erweiterte Klasse zur Verwaltung von Graphen |
|
|
|
| 3. Kürzeste Wege in Graphen |
Algorithmus, Graph, Moore, kürzester Weg, Dijkstra, Routenplaner |
Python |
|
| 1. Das Problem |
|
|
|
| 2. Der Algorithmus von Moore |
|
|
|
| 3. Der Algorithmus von Dijkstra |
|
|
|
| 4. Implementierung der Algorithmen |
|
|
|
| 5. Routenplaner |
|
|
|
| 4. Rundreisen in Graphen |
Algorithmus, Graph, Moore, Handlungsreisender, traveling salesman |
Python |
|
| 1. Das Problem |
|
|
|
| 2. Ein einfacher Lösungsalgorithmus |
|
|
|
| 3. Implementierung des Lösungsalgorithmus |
|
|
|
| 4. Anwendbarkeit des Algorithmus |
|
|
|
| 5. Näherungsverfahren |
|
|
|
| 6. Implementierung der Näherungsverfahren |
|
|
|
| 6. Binäre Suchbäume |
Algorithmus, Suche, Baum, binär |
Python |
|
| 1. Ein Objekt in einer Datenmenge suchen |
|
|
|
| 1. Finde einen eigenen Algortihmus |
|
|
|
| 2. Der naive Suchalgorithmus |
|
|
|
| 3. Der binäre Suchalgorithmus |
|
|
|
| 4. Ein verallgemeinerter Vergleich |
|
|
|
| 2. Exkurs: Datenstrukturen |
|
|
|
| 1. Was ist eine Datenstruktur? |
|
|
|
| 2. Arrays |
|
|
|
| 3. Einfach verkettete Listen |
|
|
|
| 4. Doppelt verkettete Listen |
|
|
|
| 5. Was hat das mit unserer Suche zu tun? |
|
|
|
| 3. Binärbäume |
|
|
|
| 1. Die Datenstruktur Binärbaum |
|
|
|
| 2. Klassendiagramm des Binärbaums |
|
|
|
| 3. Eine mögliche Implementation |
|
|
|
| 4. Andere Algorithmen auf Binärbäumen |
|
|
|
| 1. Einen Knoten in einen Binärbaum einfügen |
|
|
|
| 2. Einen Knoten aus einem Binärbaum löschen |
|
|
|
| 3. Einen Binärbaum traversieren - Tiefensuche |
|
|
|
| 5. Exkurs: Brauchen wir den Schlüssel? |
|
|
|
| 4. Vertiefungen |
|
|
|
| 1. Allgemeine Bäume |
|
|
|
| 2. Die Speicherabbildungsfunktion |
|
|
|
| 3. AVL- und Splay trees |
|
|
|
| 4. B-Bäume |
|
|
|
| 4. Komplexität von Algorithmen und Problemen |
Algorithmus, Komplexität |
|
|
| 1. Fallstudie - Sortieren / Präzisierung von Berechnungskomplexität |
Algorithmus, Komplexität, Aufwand, Sortieren |
Python |
|
| 1. Sortieralgorithmen |
|
|
|
| 1. Sortieren durch Auswählen / Selectionsort |
|
|
|
| 2. Sortieren durch Einfügen / Insertionsort |
|
|
|
| 3. Sortieren durch Aufsteigen / Bubblesort |
|
|
|
| 4. Sortieren durch Zerlegen / Quicksort |
|
|
|
| 2. Laufzeitverhalten |
|
|
|
| 1. Laufzeitmessungen |
|
|
|
| 2. Systematische Bestimmung des Laufzeitverhaltens |
|
|
|
| 3. Zusammenfassung |
|
|
|
| 3. Aufwandsanalyse |
Algorithmus, Komplexität, Sortieren, Problemgröße, Kostenfunktion |
Python |
|
| 1. Beschreibung der Problemgröße |
|
|
|
| 2. Modellierung der Kosten |
|
|
|
| 3. Kostenanalyse für Sortieralgorithmen |
|
|
|
| 4. Asymptotisches Wachstumsverhalten |
Algorithmus, Komplexität, Aufwand, Wachstumsverhalten |
Python |
|
| 1. Vergleich von Kostenfunktionen |
|
|
|
| 2. Asymptotisches Wachstumsverhalten als Vergleichskriterium |
|
|
|
| 3. Einordnung in Komplexitätsklassen |
Algorithmus, Komplexität, Komplexitätsklasse |
Python |
|
| 5. Die Komplexität des Sortierproblems |
|
|
|
| 1. Zeitkomplexität von Problemen |
|
|
|
| 2. Beschreibung von Sortiervorgängen mit Entscheidungsbäumen |
|
|
|
| 3. Die Zeitkomplexität des Sortierproblems |
|
|
|
| 2. Fallstudie - Das Affenpuzzle / Praktische Anwendbarkeit von Algorithmen |
Algorithmus, Komplexität, Affenpuzzle, Anwendbarkeit, praktische Grenze |
Python |
|
| 1. Das Affenpuzzle |
|
|
|
| 2. Komplexitätsaussagen |
|
|
|
| 3. Fallstudie - Primfaktorzerlegung / Praktische Anwendbarkeit von Algorithmen |
Algorithmus, Komplexität, Primzahl, Anwendbarkeit, praktische Grenze |
Python |
|
| 1. Primzahlen und das Faktorisierungsproblem |
|
|
|
| 2. Ein einfaches Faktorisierungsverfahren |
|
|
|
| 3. Laufzeitmessungen |
|
|
|
| 4. Aufwandsabschätzungen |
|
|
|
| 5. Komplexitätsbetrachtungen |
|
|
|
| 4. Fallstudie - Rundreiseprobleme / Schwer lösbare Probleme |
Algorithmus, Komplexität, Rundreise, Anwendbarkeit, praktische Grenze |
Python |
|
| 1. Rundreiseprobleme |
|
|
|
| 2. Rundreisealgorithmen |
|
|
|
| 3. Komplexitätsbetrachtungen |
|
|
|
| 4. Die Klassen P und NP |
|
|
|
| 5. NP-vollständige Probleme |
|
|
|
| 5. Fallstudie - Das Rucksackproblem / Lösen schwieriger Probleme mit Näherungsverfahren |
Algorithmus, Komplexität, Rucksackproblem, Anwendbarkeit, praktische Grenze, Näherungsverfahren |
Python |
|
| 1. Das Rucksackproblem |
|
|
|
| 2. Ein einfacher Lösungsalgorithmus |
|
|
|
| 3. Komplexitätsbetrachtungen |
|
|
|
| 4. Lösung mit einem genetischen Algorithmus |
|
|
|
| 5. Implementierung des genetischen Algorithmus |
|
|
|
| 5. Berechenbarkeit |
Algorithmus, Berechenbarkeit |
|
|
| 1. Das Halteproblem |
Algorithmus, Berechenbarkeit, Halteproblem |
Python |
|
| 1. Endlosschleifen |
|
|
|
| 2. Das Halteproblem |
|
|
|
| 3. Automatisierte Programmanalyse |
|
|
|
| 4. Ein seltsames Halteanalyseprogramm |
|
|
|
| 5. Lösbarkeit des Halteproblems |
|
|
|
| 6. Zusammenfassung - Lösbarkeit des Halteproblems |
|
|
|
| 2. Lösbarkeit von Problemen |
|
|
|
| 1. Das Neun-Punkte-Problem |
|
|
|
| 2. Lösungen zum Neun-Punkte-Problem |
|
|
|
| 3. Lösbarkeit des Neun-Punkte-Problems |
|
|
|
| 4. Algorithmische Lösbarkeit von Problemen |
|
|
|
| 3. Turingmaschine als Berechnungsmodell |
Algorithmus, Berechenbarkeit, Turingmaschine |
|
|
| 1. Auf den Spuren von Alan Turing |
|
|
|
| 2. Ein Marienkäfer als Turingmaschine |
|
|
|
| 3. Präzisierung der Turingmaschine |
|
|
|
| 4. Turingmaschinen-Berechenbarkeit |
|
|
|
| 5. Eine universelle Turingmaschine |
|
|
|
| 6. Turingmaschine als Berechnungsmodell |
|
|
|
| 4. Weitere Berechnungsmodelle |
Algorithmus, Berechnungsmodell |
|
|
| 1. Registermaschine als Berechnungsmodell |
|
|
|
| 2. While-Programmiersprache als Berechnungsmodell |
|
|
|
| 3. Church-Turing-These |
|
|
|
| 5. Grenzen der Berechenbarkeit |
Algorithmus, Berechenbarkeit, prinzipielle Grenze, Turingmaschine, fleißiger Biber |
|
|
| 1. Aufzählung aller Turingmaschinen |
|
|
|
| 2. Existenz nicht berechenbarer Funktionen |
|
|
|
| 3. Das Halteproblem |
|
|
|
| 4. Fleißige Biber |
|
|
|
| 5. Ein Blick in die Geschichte |
|
|
|
| 1. Algorithmisches Problemlösen mit Kara |
|
|
|
| 1. Kara und ihre/seine Welt |
Anweisung, Sequenz, Kara, Programmierung |
PythonKara |
|
| 1. Erkundung – Steuerung von Kara |
|
|
|
| 2. Strukturierung – Anweisungen |
|
|
|
| 3. Fachkonzept – Anweisung |
|
|
|
| 4. Fachkonzept – Anweisungssequenz |
|
|
|
| 5. Übungen |
|
|
|
| 6. Überprüfung |
|
|
|
| 2. Fallunterscheidungen |
Fallunterscheidung, Bedingung, Kontrollstruktur, Programmierung |
PythonKara |
|
| 1. Erkundung – Kara trifft Entscheidungen |
|
|
|
| 2. Strukturierung – Bedingungen |
|
|
|
| 3. Fachkonzept – Bedingung |
|
|
|
| 4. Strukturierung – Fallunterscheidungen |
|
|
|
| 5. Fachkonzept – Fallunterscheidung |
|
|
|
| 6. Übungen |
|
|
|
| 7. Überprüfung |
|
|
|
| 3. Wiederholungen |
Wiederholung, Kontrollstruktur, Programmierung |
PythonKara |
|
| 1. Erkundung – Kara führt Aktionen wiederholt aus |
|
|
|
| 2. Strukturierung – Wiederholte Vorgänge |
|
|
|
| 3. Fachkonzept – Wiederholung |
|
|
|
| 4. Übungen |
|
|
|
| 5. Überprüfung |
|
|
|
| 4. Algorithmen |
Struktogramm, Algorithmus, Programm, Anweisung, Fallunterscheidung, Wiederholung, Kontrollstruktur, Programmierung |
PythonKara |
|
| 1. Erkundung – Ein schwierigeres Problem lösen |
|
|
|
| 2. Strukturierung – Ein schwierigeres Problem lösen |
|
|
|
| 3. Fachkonzept – Problem/Algorithmus/Programm |
|
|
|
| 4. Fachkonzept – Bausteine von Algorithmen |
|
|
|
| 5. Exkurs – Algorithmisches Problemlösen |
|
|
|
| 6. Strukturierung – Fehler |
|
|
|
| 7. Fachkonzept – Fehler |
|
|
|
| 8. Übungen |
|
|
|
| 9. Überprüfung |
|
|
|
| 5. Logische Operatoren |
Operator, logisch, Wahrheitswert, AND, OR, NOT, Programmierung |
PythonKara |
|
| 1. Erkundung – Logische Operatoren |
|
|
|
| 2. Strukturierung – Logische Operatoren |
|
|
|
| 3. Fachkonzept – Logische Operatoren |
|
|
|
| 4. Übungen |
|
|
|
| 5. Exkurs – Bool'sche Algebra |
|
|
|
| 1. Orientierung |
|
|
|
| 1. Problemstellung |
|
|
|
| 2. Bedingungen vergleichen |
|
|
|
| 3. Tabellen |
|
|
|
| 4. Terme |
|
|
|
| 5. Rechengesetze |
|
|
|
| 6. Das hast du hier gelernt |
|
|
|
| 6. Unterprogramme |
Unterprogramm, Funktion, Modularisierung, Programmierung |
PythonKara |
|
| 1. Erkundung – Kara lernt neue Befehle |
|
|
|
| 2. Strukturierung – Unterprogramme |
|
|
|
| 3. Fachkonzept – Unterprogramm |
|
|
|
| 4. Übungen |
|
|
|
| 7. Problemzerlegung |
teile und herrsche, Zerlegung, Modularisierung, Unterprogramm, Funktion, Programmierung |
PythonKara |
|
| 1. Erkundung – Neujahrsvorsätze |
|
|
|
| 2. Strukturierung – Problemzerlegung |
|
|
|
| 3. Fachkonzept – Problemzerlegung |
|
|
|
| 4. Übungen |
|
|
|
| 8. Algorithmen mit Variablen |
Variable, Algorithmus, Zuweisung, Schleife, Wiederholung, Programmierung |
PythonKara |
|
| 1. Erkundung – Kara lernt zählen |
|
|
|
| 2. Strukturierung – Variablen |
|
|
|
| 3. Fachkonzept – Variablen |
|
|
|
| 4. Exkurs – Zählschleife |
|
|
|
| 5. Exkurs – Datentypen |
|
|
|
| 6. Übungen |
|
|
|
| 7. Vertiefung |
|
|
|
| 1. Vertiefung |
|
|
|
| 1. Parameter |
|
|
|
| 2. Rückgabe |
|
|
|
| 3. Taschenrechner |
|
|
|
| 4. Spirale |
|
|
|
| 5. Dreiecke |
|
|
|
| 6. Das hast du hier gelernt |
|
|
|
| 2. Algorithmisches Problemlösen mit Scratch |
|
|
|
| 1. Die Scratch-Welt |
Scratch, Objekt, Programmierung |
Scratch |
|
| 1. Einstieg - Wie im Theater |
|
|
|
| 2. Fachkonzepte - Objekte und ihre Steuerung |
|
|
|
| 3. Übungen |
|
|
|
| 2. Fallunterscheidungen |
Scratch, Fallunterscheidung, Bedingung, Kontrollstruktur, Programmierung |
Scratch |
|
| 1. Einstieg - Fallunterscheidungen |
|
|
|
| 2. Fachkonzept - Fallunterscheidung |
|
|
|
| 3. Exkurs - Bedingungen |
|
|
|
| 4. Übungen |
|
|
|
| 3. Wiederholungen |
Scratch, Wiederholung, Bedingung, Kontrollstruktur, Programmierung |
Scratch |
|
| 1. Einstieg - Wiederholungen |
|
|
|
| 2. Fachkonzept - Wiederholung mit fester Anzahl |
|
|
|
| 3. Fachkonzept - Bedingte Wiederholung |
|
|
|
| 4. Fachkonzept - Endlosschleife |
|
|
|
| 5. Übungen |
|
|
|
| 4. Algorithmen |
Scratch, Algorithmus, Programm, Kontrollstruktur, Programmierung |
Scratch |
|
| 1. Einstieg - Blindekuh |
|
|
|
| 2. Fachkonzept - Problem/Algorithmus/Programm |
|
|
|
| 3. Fachkonzept - Kontrollstrukturen |
|
|
|
| 4. Übungen |
|
|
|
| 5. Teile und herrsche |
Scratch, Zerlegung, Modularisierung, Programmierung |
Scratch |
|
| 1. Einstieg - Problemzerlegung |
|
|
|
| 2. Einstieg - Arbeitsteilung |
|
|
|
| 3. Fachkonzept - teile und herrsche |
|
|
|
| 4. Übungen |
|
|
|
| 6. Variablen |
Scratch, Variable, Programmierung |
Scratch |
|
| 1. Einstieg - Uhr |
|
|
|
| 2. Fachkonzept - Variable |
|
|
|
| 3. Übungen |
|
|
|
| 7. Zuweisungen |
Scratch, Zuweisung, Datentyp, Term, Programmierung |
Scratch |
|
| 1. Einstieg - Fußball |
|
|
|
| 2. Fachkonzept - Zuweisung |
|
|
|
| 3. Exkurs - Datentypen |
|
|
|
| 4. Exkurs - Terme |
|
|
|
| 5. Übungen |
|
|
|
| 8. Eingabe-Verarbeitung-Ausgabe |
Scratch, EVA-Prinzip, Programmierung |
Scratch |
|
| 1. Einstieg - Eingaben verarbeiten |
|
|
|
| 2. Fachkonzept - EVA-Struktur |
|
|
|
| 3. Übungen |
|
|
|
| 9. Unterprogramme |
Scratch, Unterprogramm, Modularisierung, Programmierung |
Scratch |
|
| 1. Einstieg - Eigene Blöcke in Scratch |
|
|
|
| 2. Fachkonzept - Unterprogramm |
|
|
|
| 3. Übungen |
|
|
|
| 10. Rekursion |
Scratch, Rekursion, Selbstähnliche Figur, Programmierung |
Scratch |
|
| 1. Einstieg - Eine selbstähnliche Figur |
|
|
|
| 2. Fachkonzept - Rekursive Problemreduktion |
|
|
|
| 3. Übungen |
|
|
|
| 11. Miniprojekte |
Scratch, Programmierung |
Scratch |
|
| 1. Miniprojekt - Irrfahrt |
|
|
|
| 3. Imperative Programmierung mit Python |
Programmierung, imperativ |
Python |
|
| 1. Miniprojekte |
|
|
|
| 1. Datenverwaltung mit Variablen |
|
|
|
| 1. Miniprojekt - Populationsentwicklung |
Programmierung, Variable, Zuweisung |
Python |
|
| 1. Modellierung einer Mäusepopulation |
|
|
|
| 2. Automatisierung der Berechnungen |
|
|
|
| 3. Variablen und Zuweisungen |
|
|
|
| 4. Benutzerfreundliche Programme |
|
|
|
| 5. EVA-Programme |
|
|
|
| 6. Fehler in Programmen |
|
|
|
| 7. Wiederholte Berechnungen |
|
|
|
| 8. Weiterentwicklung des Programms |
|
|
|
| 9. Eine komplexere Anwendung |
|
|
|
| 2. Miniprojekt - Zimmergestaltung |
Programmierung, Variable, Zuweisung, Datentyp |
Python |
|
| 1. Die Fläche der Wände |
|
|
|
| 2. Variablen und Zuweisungen |
|
|
|
| 3. Eingabe der Zimmerdaten |
|
|
|
| 4. Programme |
|
|
|
| 5. Ein Tapetenrechner |
|
|
|
| 6. Datentypen |
|
|
|
| 7. Eine Möbel-Einkaufsliste |
|
|
|
| 3. Miniprojekt - Promillerechner |
Programmierung, Programm, EVA-Prinzip |
Python |
|
| 1. Berechnung der Blutalkoholkonzentration |
|
|
|
| 2. Ein Programm zur Berechnung |
|
|
|
| 3. Ein Programm mit Benutzereingaben |
|
|
|
| 4. Fachkonzept - EVA-Struktur von Programmen |
|
|
|
| 5. Ein- und Ausgaben |
|
|
|
| 6. Fachkonzept - Datentyp |
|
|
|
| 2. Ablaufmodellierung mit Kontrollstrukturen |
|
|
|
| 1. Miniprojekt - Zufallsexperimente |
Programmierung, Zufall, Fallunterscheidung, Wiederholung |
Python |
|
| 1. Zufallszahlen erzeugen |
|
|
|
| 2. Eine Münze werfen |
|
|
|
| 3. Einen Würfel werfen |
|
|
|
| 4. Fachkonzept - Fallunterscheidung |
|
|
|
| 5. Wiederholt würfeln |
|
|
|
| 6. Fachkonzept - Wiederholung |
|
|
|
| 7. Exkurs - Kontrollstrukturen |
|
|
|
| 8. Übungen - Kontrollstrukturen |
|
|
|
| 2. Miniprojekt - Pasch beim Würfeln |
Prgrammierung, Wahrheitswert, logische Verknüpfung |
Python |
|
| 1. Bedingungen für ein Pasch |
|
|
|
| 2. Exkurs - Logische Verknüpfungen |
|
|
|
| 3. Fachkonzept - Datentyp Wahrheitswerte |
|
|
|
| 4. Logische Variablen und logische Terme |
|
|
|
| 3. Miniprojekt - Das Glücksspiel Craps |
Programmierung, Zufall, Kontrollstruktur |
Python |
|
| 1. Durchführung des Spiels |
|
|
|
| 2. Ablaufmodellierung |
|
|
|
| 3. Implementierung |
|
|
|
| 4. Automatisierte Durchführung des Spiels |
|
|
|
| 4. Miniprojekt - Das Ziegenproblem |
Programmierung, Zufall, Kontrollstruktur |
Python |
|
| 1. Durchführung des Spiels |
|
|
|
| 2. Ablaufmodellierung |
|
|
|
| 3. Implementierung |
|
|
|
| 4. Automatisierte Durchführung des Spiels |
|
|
|
| 5. Miniprojekt - Verarbeitung von Zeichenketten |
Programmierung, Zeichenkette, Verschlüsselung |
Python |
|
| 1. Verschlüsselung von Nachrichten |
|
|
|
| 2. Die Idee |
|
|
|
| 3. Der Algorithmus |
|
|
|
| 4. Eine Implementierung |
|
|
|
| 3. Modularisierung mit Funktionen |
|
|
|
| 1. Miniprojekt - Datenlupe |
Programmierung, Funktion, Binärdarstellung |
Python |
|
| 1. Binärdarstellung von Daten |
|
|
|
| 2. Experimente mit Python |
|
|
|
| 3. Verwendung von Funktionen |
|
|
|
| 4. Schachtelung von Funktionen |
|
|
|
| 5. Definition von Funktionen |
|
|
|
| 6. Übungen |
|
|
|
| 7. Weitere Anwendungen |
|
|
|
| 2. Miniprojekt - Pixelrechner |
Programmierung, Funktion, Pixelgrafik |
Python |
|
| 1. Pixelrechner |
|
|
|
| 2. Pixelangaben |
|
|
|
| 3. Pixelberechnungen |
|
|
|
| 4. Berechnungen mit einer Funktion |
|
|
|
| 5. Verwendung von Hilfsfunktionen |
|
|
|
| 6. Schachtelung von Funktionen |
|
|
|
| 7. Rückgabe von mehreren Daten |
|
|
|
| 8. Auflösung einer Kamera |
|
|
|
| 9. Auflösung eines Bildschirms |
|
|
|
| 3. Miniprojekt - Baumhaus |
Programmierung, Funktion |
Python |
|
| 1. Baumhaus |
|
|
|
| 2. Konkrete Materialberechnungen |
|
|
|
| 3. Funktion als Verarbeitungseinheit |
|
|
|
| 4. Verwendung von Hilfsfunktionen |
|
|
|
| 5. Weitere Berechnungsprobleme |
|
|
|
| 4. Miniprojekt - Verschlüsselung |
Programmierung, Funktion, Verschlüsselung, historisch |
Python |
|
| 1. Das Verschiebeverfahren |
|
|
|
| 2. Funktionen zur Implementierung |
|
|
|
| 3. Das Vigenère-Verfahren |
|
|
|
| 4. Monoalphabetische Verfahren |
|
|
|
| 5. Vernetzung |
|
|
|
| 5. Miniprojekt - Primzahlen |
Programmierung, Funktion, Primzahl |
Python |
|
| 1. Primzahlen |
|
|
|
| 2. Ein Primzahltestalgorithmus |
|
|
|
| 3. Implementierung des Primzahltestalgorithmus |
|
|
|
| 4. Ein Baustein für Primzahltests |
|
|
|
| 5. Der Primzahlsatz |
|
|
|
| 6. Goldbachs Vermutung |
|
|
|
| 7. Primfaktorzerlegung |
|
|
|
| 4. Datenverwaltung mit Datenstrukturen |
|
|
|
| 1. Miniprojekt - Aktienkurse |
Programmierung, Liste |
Python |
|
| 1. Aktienindex |
|
|
|
| 2. Verwaltung von Kurswerten |
|
|
|
| 3. Zugriff auf Kurswerte |
|
|
|
| 4. Alle Kurswerte durchlaufen |
|
|
|
| 5. Minimale und maximale Kurswerte |
|
|
|
| 6. Kurswerte hinzufuegen und löschen |
|
|
|
| 7. Eine neue Liste aufbauen |
|
|
|
| 8. Komplexere Daten verarbeiten |
|
|
|
| 9. Kurswertelisten automatisiert erstellen |
|
|
|
| 10. Ideen zum Weiterarbeiten |
|
|
|
| 2. Miniprojekt - Lottosimulation |
Programmierung, Liste |
Python |
|
| 1. Lottozahlen mit Listen verwalten |
|
|
|
| 2. Lottozahlen der Reihe nach durchlaufen |
|
|
|
| 3. Eine Lottoziehung simulieren |
|
|
|
| 4. Gewinnchancen beim Lottospiel |
|
|
|
| 3. Miniprojekt - Schulfreunde |
Programmierung, Liste |
Python |
|
| 1. E-Mail-Adressen mit einer Liste verwalten |
|
|
|
| 2. Eine Adressliste dynamisch verändern |
|
|
|
| 3. Eine Adressliste sichern |
|
|
|
| 4. Bausteine zur Verarbeitung |
|
|
|
| 5. Komplexe Adressen |
|
|
|
| 4. Miniprojekt - Verarbeitung von Grafiken |
Programmierung, Datenstruktur, Liste, Tupel, Grafik |
Python |
|
| 1. Verwaltung der Grafikdaten |
|
|
|
| 2. Probleme beim Invertieren |
|
|
|
| 3. Bilddaten invertieren |
|
|
|
| 4. Die Grafik invertieren |
|
|
|
| 5. Umwandlung in Quelltexte |
|
|
|
| 6. Laden und speichern |
|
|
|
| 7. Ideen zum Weiterarbeiten |
|
|
|
| 5. Miniprojekt - Spiel des Lebens |
Programmierung, Datenstruktur, Liste |
Python |
|
| 1. Eine Spielwelt verwalten |
|
|
|
| 2. Das Spiel simulieren |
|
|
|
| 3. Exkurs - Verwaltung und Verarbeitung zweidimensionaler Dateneinheiten |
|
|
|
| 2. Fachkonzepte |
|
|
|
| 1. Variablen |
Programmierung, Variable, Zuweisung |
Python |
|
| 1. Beispiel - Preisberechnungen |
|
|
|
| 2. Strukturierung - Variablen |
|
|
|
| 3. Fachkonzept - Variable |
|
|
|
| 4. Fachkonzept - Zuweisung |
|
|
|
| 5. Übungen |
|
|
|
| 6. Exkurs - Ein Blick hinter die Kulissen von Python |
|
|
|
| 2. Datentypen |
Programmierung, Datentyp |
Python |
|
| 1. Beispiel - Temperaturumrechnung |
|
|
|
| 2. Fachkonzept - Datentyp |
|
|
|
| 3. Exkurs - Zahlen in Python |
|
|
|
| 4. Exkurs - Zeichenketten in Python |
|
|
|
| 5. Exkurs - Wahrheitswerte in Python |
|
|
|
| 6. Exkurs - Typumwandlungen |
|
|
|
| 7. Übungen |
|
|
|
| 3. Programme |
Programmierung, Programm, EVA-Prinzip |
Python |
|
| 1. Beispiel - Wegberechnungen |
|
|
|
| 2. Fachkonzept - Programm |
|
|
|
| 3. Fachkonzept - EVA-Prinzip |
|
|
|
| 4. Exkurs - Eingabe/Ausgabe in Python |
|
|
|
| 5. Übungen |
|
|
|
| 4. Fehler in Programmen |
Programmierung, Syntaxfehler, Laufzeitfehler, logischer Fehler |
Python |
|
| 1. Exkurs - Syntaxfehler |
|
|
|
| 2. Exkurs - Laufzeitfehler |
|
|
|
| 3. Exkurs - Logische Fehler |
|
|
|
| 5. Fallunterscheidungen |
Programmierung, Fallunterscheidung |
Python |
|
| 1. Beispiel - Minimax |
|
|
|
| 2. Beispiel - Promillerechner |
|
|
|
| 3. Exkurs - Mehrfachfallunterscheidungen in Python |
|
|
|
| 4. Fachkonzept - Fallunterscheidung |
|
|
|
| 5. Übungen |
|
|
|
| 6. Wiederholungen |
Programmierung, Wiederholung |
Python |
|
| 1. Beispiel - Berechnungen zum Begrüßungsproblem |
|
|
|
| 2. Beispiel - Wertverlustrechner |
|
|
|
| 3. Fachkonzept - Wiederholungen |
|
|
|
| 4. Exkurs - Zählschleifen |
|
|
|
| 5. Übungen |
|
|
|
| 7. Bedingungen |
Programmierung, Bedingung, Wahrheitswert, logische Verknüpfung |
Python |
|
| 1. Beispiel - Schaltjahre |
|
|
|
| 2. Fachkonzept - Logische Verknüpfungen |
|
|
|
| 3. Fachkonzept - Bedingungen |
|
|
|
| 4. Übungen |
|
|
|
| 8. Ablaufmodellierung |
Programmierung, Kontrollstruktur |
Python |
|
| 1. Beispiel - Zahlenraten |
|
|
|
| 2. Fachkonzept - Kontrollstrukturen |
|
|
|
| 3. Übungen |
|
|
|
| 9. Fehlersuche |
Programmierung, Fehlersuche, Debugger |
Python |
|
| 1. Beispiel - Simulation einer Ampel |
|
|
|
| 2. Exkurs - Strategien zur Fehlersuche |
|
|
|
| 10. Zeichenketten |
Programmierung, Zeichenkette |
Python |
|
| 1. Beispiel - Palindrome |
|
|
|
| 2. Fachkonzept - Zeichenkette |
|
|
|
| 3. Übungen |
|
|
|
| 11. Funktionen |
Programmierung, Funktion |
Python |
|
| 1. Beispiel - Caesar-Verschlüsselung |
|
|
|
| 2. Fachkonzept - Funktion |
|
|
|
| 3. Exkurs - Datenverarbeitung mit Funktionen |
|
|
|
| 4. Übungen |
|
|
|
| 12. Modularisierung |
Programmierung, Funktion, Schnittstelle, Modultest |
Python |
|
| 1. Beispiel - Tage zählen |
|
|
|
| 2. Fachkonzept - Modularisierung |
|
|
|
| 3. Fachkonzept - Schnittstelle |
|
|
|
| 4. Exkurs - Modultests in Python |
|
|
|
| 5. Übungen |
|
|
|
| 13. Namensräume |
Programmierung, Variable, lokal, global, Namensraum |
Python |
|
| 1. Beispiel - Experimente mit Variablen |
|
|
|
| 2. Fachkonzept - Namensräume |
|
|
|
| 3. Exkurs - lokale/globale Variablen in Python |
|
|
|
| 4. Exkurs - Parameterübergabe in Python |
|
|
|
| 5. Übungen |
|
|
|
| 14. Listen |
Programmierung, Datenstruktur, Liste |
Python |
|
| 1. Beispiel - Newsletter |
|
|
|
| 2. Fachkonzept - Liste |
|
|
|
| 3. Exkurs - Verwaltung von Listen |
|
|
|
| 4. Übungen |
|
|
|
| 15. Datenstrukturen |
Programmierung, Datenstruktur, Liste Tupel |
Python |
|
| 1. Beispiel - Terminkalender |
|
|
|
| 2. Exkurs - Listen und Tupel in Python |
|
|
|
| 3. Fachkonzept - Datenstrukturen |
|
|
|
| 4. Übungen |
|
|
|
| 16. Rekursion |
Programmierung, Rekursion |
Python |
|
| 1. Beispiel - Begrüßungsproblem |
|
|
|
| 2. Fachkonzept - Rekursive Funktionsdefinition |
|
|
|
| 3. Übungen |
|
|
|
| 3. Entwicklungsumgebungen für Python |
|
|
|
| 1. IDLE |
|
|
|
| 2. Thonny |
|
|
|
| 3. Browser-Version auf inf-schule |
|
|
|
| 4. Python-Tutor |
|
|
|
| 4. Algorithmisches Problemlösen mit Spacebug |
|
|
|
| 1. Die ESS Argo im Weltraum |
|
|
|
| 1. Einstieg - Steuerung der Argo |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept |
|
|
|
| 4. Lerncheck |
|
|
|
| 2. Fallunterscheidungen |
|
|
|
| 1. Erkundung |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept |
|
|
|
| 4. Lerncheck |
|
|
|
| 3. Wiederholungen |
|
|
|
| 1. Erkundung |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept |
|
|
|
| 4. Lerncheck |
|
|
|
| 4. Algorithmen |
|
|
|
| 1. Erkundung |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept |
|
|
|
| 4. Lerncheck |
|
|
|
| 5. Funktionen I |
|
|
|
| 1. Erkundung |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept |
|
|
|
| 4. Lerncheck |
|
|
|
| 1. Objektorientierte Programmierung mit Java |
|
|
|
| 1. Aufbau von Klassen |
Programmierung, Klasse, Objekt, Kapselung, Modellierung |
Java |
|
| 1. Hasen als Objekte |
Programmierung, Klasse, Objekt, Klassendiagramm, Objektdiagramm, Vererbung |
Java |
|
| 1. Objekte in Aktion |
|
|
|
| 2. Fachkonzept - Objekt |
|
|
|
| 3. Fachkonzept - Klasse |
|
|
|
| 4. Übungen |
|
|
|
| 2. Teddy |
Programmierung, Klasse, Objekt, OOP, Klassendiagramm, Objektdiagramm, Konstruktor |
Java |
|
| 1. Das Spiel |
|
|
|
| 2. Fachkonzept - OOM |
|
|
|
| 3. Fachkonzept - OOP |
|
|
|
| 4. Übungen |
|
|
|
| 5. Übungsprojekt - Autobewertung |
|
|
|
| 3. Snap |
Programmierung, Klasse, Objekt, Kapselung, Geheimnisprinzip |
Java |
|
| 1. Timer im Codepad nutzen |
|
|
|
| 2. Fachkonzept - Kapselung |
|
|
|
| 3. Übungen |
|
|
|
| 2. Objektorientierte Implementierung |
|
|
|
| 1. Superbrain |
Programmierung, Klasse, Objekt, lokale Variable, Fallunterscheidung, Bedingung |
Java |
|
| 1. Basisversion |
|
|
|
| 2. Fachkonzept - lokale Variablen |
|
|
|
| 3. Fachkonzept - Fallunterscheidung |
|
|
|
| 4. Fachkonzept - Bedingungen |
|
|
|
| 5. Übungen |
|
|
|
| 2. Schweine im Weltall |
Programmierung, Klasse, Objekt, Vererbung, Klassenmethode |
Java |
|
| 1. Implementierung des Grundgerüsts |
|
|
|
| 2. Fachkonzept - Vererbung |
|
|
|
| 3. Fachkonzept - Klassenmethoden |
|
|
|
| 4. Übungen |
|
|
|
| 3. Frog |
Programmierung, Klasse, Objekt, Klassendokumentation, Datentyp, Wiederholung, primitiver Datentyp |
Java |
|
| 1. Spielidee |
|
|
|
| 2. Implementierung |
|
|
|
| 3. Fachkonzept - Klassendokumentation |
|
|
|
| 4. Fachkonzept - Klassen und primitive Datentypen |
|
|
|
| 5. Fachkonzept - Wiederholungen |
|
|
|
| 6. Übungen |
|
|
|
| 4. Space Invaders |
Programmierung, Klasse, Objekt, Softwareentwicklung |
Java |
|
| 1. Spielbeschreibung |
|
|
|
| 2. Entwicklung des Spiels |
|
|
|
| 3. Fachkonzept - Softwareentwicklungsphasen |
|
|
|
| 3. Beziehungen zwischen Objekten |
Programmierung, Modellierung |
|
|
| 1. Go Home |
Programmierung, Klasse, Objekt, Referenz, Beziehung, Modellierung |
Java |
|
| 1. Go Home als Brettspiel |
|
|
|
| 2. Simulation im Codepad |
|
|
|
| 3. Fachkonzept - Referenzen |
|
|
|
| 4. Go Home als Programm |
|
|
|
| 5. Fachkonzept - Beziehungen |
|
|
|
| 6. Übungen |
|
|
|
| 2. Keep Or Throw |
Programmierung, Klasse, Objekt, Test, Generische Klasse, Innere Klasse, Stapel, Datenstruktur, Modellierung |
Java |
|
| 1. Spielidee |
|
|
|
| 2. Stapel |
|
|
|
| 3. Exkurs - Unit-Tests |
|
|
|
| 4. Exkurs - Generische und innere Klassen |
|
|
|
| 5. Fachkonzept - Stapel als Datenstruktur |
|
|
|
| 6. Spielelogik |
|
|
|
| 7. Übungen |
|
|
|
| 3. Platz da! |
Programmierung, Klasse, Objekt, Warteschlange, Datenstruktur, Modellierung |
Java |
|
| 1. Spielregeln |
|
|
|
| 2. Warteschlange |
|
|
|
| 3. Spielelogik |
|
|
|
| 4. Fachkonzept - Datenstruktur Warteschlange |
|
|
|
| 5. Übungen |
|
|
|
| 4. Adventure |
Programmierung, Klasse, Objekt, Softwareentwicklung, iterativ, Modellierung |
Java |
|
| 1. Projektbeschreibung |
|
|
|
| 2. Fachkonzept - Iterative Softwareentwicklung |
|
|
|
| 4. Für Experten |
|
|
|
| 1. Arrays |
Programmierung, Klasse, Objekt, Array, Feld |
Java |
|
| 1. No Risk No Money |
|
|
|
| 2. Know How |
|
|
|
| 3. Übungen |
|
|
|
| 4. Umsetzung |
|
|
|
| 2. Listen |
Programmierung, Klasse, Objekt, Liste, LinkedList, Generische Klasse |
Java |
|
| 1. Wort-Scrabble |
|
|
|
| 2. Know How |
|
|
|
| 3. Übungen |
|
|
|
| 4. Umsetzung |
|
|
|
| 5. Exkurs - Sammlungsklassen |
|
|
|
| 3. Fortgeschrittene Vererbungskonzepte |
Programmierung, Klasse, Objekt, Vererbung, abstrakte Klasse, Interface, Typumwandlung |
Java |
|
| 1. Tierjagd mit Vererbung |
|
|
|
| 2. Fachkonzept - Vererbung |
|
|
|
| 3. Tierjagd mit abstrakten Klassen |
|
|
|
| 4. Fachkonzept - Abstrakte Klassen |
|
|
|
| 5. Tierjagd mit Interface |
|
|
|
| 6. Fachkonzept - Interface |
|
|
|
| 7. Fachkonzept - Typumwandlung |
|
|
|
| 8. Übungen |
|
|
|
| 5. Tipps und Tools |
|
|
|
| 1. Klassendiagramm interaktiv |
|
|
|
| 2. BlueJ optimal nutzen |
|
|
|
| 3. Java-Schnipsel |
|
|
|
| 4. Greenfoot-Schnipsel |
|
|
|
| 2. Objektorientierte Programmierung mit Python |
Programmierung, objektorientiert, OOP |
Python |
|
| 1. Simulation von Ampelsystemen |
Programmierung, objektorientiert, OOP |
Python |
Miniprojekt |
| 1. Objekte und Klassen |
Programmierung, objektorientiert, OOP, Objekt, Klasse |
Python |
|
| 1. Softwareobjekte zur Simulation von Ampeln |
|
|
|
| 2. Strukturierung |
|
|
|
| 3. Fachkonzept - Objekt |
|
|
|
| 4. Fachkonzept - Klasse |
|
|
|
| 5. Exkurs - Implementierung in Python |
|
|
|
| 6. Übungen |
|
|
|
| 2. Modularisierung |
Programmierung, objektorientiert, OOP, Modularisierung, Datenkapselung, Schnittstelle |
Python |
|
| 1. Das Bausteinprinzip |
|
|
|
| 2. Zugriff auf die Attribute |
|
|
|
| 3. Fachkonzept - Datenkapselung |
|
|
|
| 4. Exkurs - Datenkapselung in Python |
|
|
|
| 5. Verwendung einer Klasse |
|
|
|
| 6. Fachkonzept - Schnittstelle |
|
|
|
| 7. Exkurs - Modularisierung in Python |
|
|
|
| 8. Übungen |
|
|
|
| 9. Anwendung - Eine Ampel mit GUI |
|
|
|
| 3. Beziehungen zwischen Objekten |
Programmierung, objektorientiert, OOP, Beziehung, Interaktion, Referenz |
Python |
|
| 1. Verwaltung von Objekten |
|
|
|
| 2. Fachkonzept - Zeiger / Referenz |
|
|
|
| 3. Exkurs - Objekte in Python |
|
|
|
| 4. Steuerung von Ampeln |
|
|
|
| 1. Version 0 |
|
|
|
| 2. Version 1 |
|
|
|
| 3. Version 2 |
|
|
|
| 4. Version 3 |
|
|
|
| 5. Fachkonzept - Beziehung |
Programmierung, objektorientiert, OOP, Kennt-Beziehung, Hat-Beziehung |
Python |
|
| 6. Fachkonzept - Interaktion zwischen Objekten |
|
|
|
| 7. Übungen |
|
|
|
| 4. Vererbung |
Programmierung, objektorientiert, OOP, Vererbung |
Python |
|
| 1. Gemeinsamkeiten bei Ampeln |
|
|
|
| 2. Eine allgemeine Ampel-Klasse |
|
|
|
| 3. Fachkonzept - Vererbung |
|
|
|
| 4. Exkurs - Implementierung in Python |
|
|
|
| 5. Übungen |
|
|
|
| 5. Miniwelt und Datenmodell |
Programmierung, objektorientiert, OOP, Datenmodell, UML |
Python |
UML |
| 1. Eine Miniwelt mit Ampeln |
|
|
|
| 2. Entwicklung eines Datenmodells |
|
|
|
| 1. Objekte identifizieren |
|
|
|
| 2. Objekte und ihre Beziehungen konzipieren |
|
|
|
| 3. Die Klasse Ampel |
|
|
|
| 4. Die Klasse Zaehler |
|
|
|
| 5. Die Klasse Schaltplanverwalter |
|
|
|
| 6. Die Klasse Ampelmanager |
|
|
|
| 7. Implementierung des Datenmodells |
|
|
|
| 3. Fachkonzept - Datenmodell |
|
|
|
| 4. Exkurs - UML |
|
|
|
| 5. Übungen |
|
|
|
| 6. Datenmodell und grafische Benutzeroberfläche |
Programmierung, objektorientiert, OOP, Datenmodell, GUI |
Python |
|
| 1. Software-Systeme mit Benutzeroberfläche |
|
|
|
| 1. Datenmodell-GUI-Architektur |
|
|
|
| 2. Model-View-Control-Architektur |
|
|
|
| 3. Befrager-Architektur / Beobachter-Architektur |
|
|
|
| 2. Fachkonzept - Trennung zwischen Datenmodell und GUI |
|
|
|
| 3. Übungen |
|
|
|
| 2. Spiele am Computer |
Programmierung, objektorientiert, OOP |
Python |
Miniprojekt |
| 1. Objekte und Klassen |
Programmierung, objektorientiert, OOP, Objekt, Klasse |
Python |
|
| 1. Das Spiel 17 und 4 |
|
|
|
| 2. Objekte als Softwarebausteine |
|
|
|
| 1. Simulation eines Kartenstapels |
|
|
|
| 2. Fachkonzept - Objekt |
|
|
|
| 3. Übungen |
|
|
|
| 3. Klassen als Baupläne für Objekte |
|
|
|
| 1. Simulation eines Kartenhaufens |
|
|
|
| 2. Fachkonzept - Klasse |
|
|
|
| 3. Exkurs - Implementierung in Python |
|
|
|
| 4. Übungen |
|
|
|
| 4. Datenkapselung bei Objekten |
Programmierung, objektorientiert, OOP, Datenkapselung |
Python |
|
| 1. Zugriff auf die Attribute |
|
|
|
| 2. Fachkonzept - Datenkapselung |
|
|
|
| 3. Exkurs - Datenkapselung in Python |
|
|
|
| 4. Übungen |
|
|
|
| 5. Modularisierung mit Klassen |
Programmierung, objektorientiert, OOP, Modularisierung |
Python |
|
| 1. Entwicklung von Software nach dem Bausteinprinzip |
|
|
|
| 2. Fachkonzept - Modularisierung |
|
|
|
| 3. Fachkonzept - Schnittstelle |
|
|
|
| 4. Exkurs - Modulimport in Python |
|
|
|
| 5. Übungen |
|
|
|
| 6. Vererbung bei Klassen |
Programmierung, objektorientiert, OOP, Vererbung |
Python |
|
| 1. Kartenstapel als spezieller Stapel |
|
|
|
| 2. Fachkonzept - Vererbung |
|
|
|
| 3. Exkurs - Implementierung in Python |
|
|
|
| 2. Beziehungen zwischen Objekten |
Programmierung, objektorientiert, OOP, Beziehung, Interaktion, Referenz |
Python |
|
| 1. Das Spiel Elf-hoch |
|
|
|
| 2. Referenzen auf Objekte |
|
|
|
| 1. Würfelobjekte erzeugen und verwalten |
|
|
|
| 2. Fachkonzept - Zeiger / Referenz |
|
|
|
| 3. Exkurs - Objekte in Python |
|
|
|
| 3. Verbindung von Objekten mit Referenzen |
|
|
|
| 1. Aktivierung von Würfelobjekten |
|
|
|
| 2. Fachkonzept - Beziehung / Assoziation |
|
|
|
| 3. Übungen |
|
|
|
| 4. Interaktion zwischen Objekten |
|
|
|
| 1. Elf-hoch - Ein Rollenspiel mit Objekten |
|
|
|
| 2. Elf-hoch - Modellierung |
|
|
|
| 3. Elf-hoch - Implementierung |
|
|
|
| 4. Fachkonzept - Interaktion zwischen Objekten |
|
|
|
| 5. Kennt-Beziehung / Hat-Beziehung |
Programmierung, objektorientiert, OOP, Kennt-Beziehung, Hat-Beziehung |
Python |
|
| 1. Verwaltung der Spielmarken |
|
|
|
| 2. Fachkonzept - Kennt-Beziehung / Hat-Beziehung |
|
|
|
| 3. Übungen |
|
|
|
| 6. Beziehungspartner |
|
|
|
| 1. Spielmanager und Spieler kennen sich gegenseitig |
|
|
|
| 2. Spielmanager kennt viele Spieler |
|
|
|
| 3. Fachkonzept - Richtung und Multiplizität bei Beziehungen |
|
|
|
| 4. Übungen |
|
|
|
| 7. Übungen |
|
|
|
| 3. Datenmodell und Benutzeroberfläche |
Programmierung, objektorientiert, OOP, Datenmodell, GUI |
Python |
|
| 1. Nim-Spiele |
|
|
|
| 1. Spielregeln |
|
|
|
| 2. Gewinnstrategie |
|
|
|
| 2. Objektorientierte Datenmodelle |
|
|
|
| 1. Experimente mit einem implementierten Datenmodell |
|
|
|
| 3. Objektorientierte Benutzeroberflächen |
|
|
|
| 1. Eine textbasierte Benutzeroberfläche |
|
|
|
| 2. Eine grafische Benutzeroberfläche |
|
|
|
| 3. Verwaltung von Bankkonten |
Programmierung, objektorientiert, OOP |
Python |
Miniprojekt |
| 1. Objekte und Klassen |
Programmierung, objektorientiert, OOP, Objekt, Klasse |
Python |
|
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Fachkonzept - Objekt |
|
|
|
| 3. Fachkonzept - Klasse |
|
|
|
| 4. Exkurs - Implementierung in Python |
|
|
|
| 5. Übungen |
|
|
|
| 2. Modularisierung |
Programmierung, objektorientiert, OOP, Modularisierung, Schnittstelle |
Python |
|
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Fachkonzept - Modularisierung |
|
|
|
| 3. Exkurs - Modularisierung in Python |
|
|
|
| 4. Fachkonzept - Schnittstelle |
|
|
|
| 5. Übungen |
|
|
|
| 3. Datenkapselung |
Programmierung, objektorientiert, OOP, Datenkapselung |
Python |
|
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Fachkonzept - Datenkapselung |
|
|
|
| 3. Exkurs - Datenkapselung in Python |
|
|
|
| 4. Übungen |
|
|
|
| 4. Verwaltung von Objekten |
Programmierung, objektorientiert, OOP, Referenz |
Python |
|
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Strukturierung - Zeiger / Referenz |
|
|
|
| 3. Fachkonzept - Zeiger / Referenz |
|
|
|
| 4. Exkurs - Objekte in Python |
|
|
|
| 5. Übungen |
|
|
|
| 5. Beziehungen zwischen Objekten |
Programmierung, objektorientiert, OOP, Beziehung, Interaktion |
Python |
|
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Fachkonzept - Beziehung |
Programmierung, objektorientiert, OOP, Kennt-Beziehung, Hat-Beziehung |
Python |
|
| 3. Exkurs - Implementierung in Python |
|
|
|
| 4. Fachkonzept - Interaktion zwischen Objekten |
|
|
|
| 5. Übungen |
|
|
|
| 6. Miniwelt und Datenmodell |
Programmierung, objektorientiert, OOP, Datenmodell, UML |
Python |
UML |
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Fachkonzept - Datenmodell |
|
|
|
| 3. Fachkonzept - Zuständigkeit |
|
|
|
| 4. Fachkonzept - UML |
|
|
|
| 5. Übungen |
|
|
|
| 7. Datenmodell und grafische Benutzeroberfläche |
Programmierung, objektorientiert, OOP, Datenmodell, GUI |
Python |
|
| 1. Einstieg - Würfeln |
|
|
|
| 2. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 3. Fachkonzept - Trennung zwischen Datenmodell und GUI |
|
|
|
| 4. Exkurs - Model-View-Control-Architektur |
|
|
|
| 5. Fachkonzept - Callback-Funktion |
|
|
|
| 6. Exkurs - Befragen / Beobachten |
|
|
|
| 7. Übungen |
|
|
|
| 8. Vererbung |
Programmierung, objektorientiert, OOP, Vererbung |
Python |
|
| 1. Einstieg - Verwaltung von Bankkonten |
|
|
|
| 2. Fachkonzept - Vererbung |
|
|
|
| 3. Exkurs - Implementierung in Python |
|
|
|
| 4. Übungen |
|
|
|
| 5. Anwendung - Streckenzüge |
|
|
|
| 4. Simulation eines Roboters |
Programmierung, objektorientiert, OOP |
Python |
Miniprojekt |
| 1. Objekte und Klassen |
Programmierung, objektorientiert, OOP, Objekt, Klasse |
Python |
|
| 1. Einstieg - Simulation eines Roboters |
|
|
|
| 2. Fachkonzept - Objekt |
|
|
|
| 3. Fachkonzept - Klasse |
|
|
|
| 4. Exkurs - Implementierung in Python |
|
|
|
| 5. Übungen |
|
|
|
| 2. Modularisierung |
Programmierung, objektorientiert, OOP, Modularisierung, Schnittstelle |
Python |
|
| 1. Einstieg - Simulation eines Roboters |
|
|
|
| 2. Fachkonzept - Modularisierung |
|
|
|
| 3. Exkurs - Modularisierung in Python |
|
|
|
| 4. Fachkonzept - Schnittstelle |
|
|
|
| 5. Übungen |
|
|
|
| 3. Datenkapselung |
Programmierung, objektorientiert, OOP, Datenkapselung |
Python |
|
| 1. Einstieg - Simulation eines Roboters |
|
|
|
| 2. Fachkonzept - Datenkapselung |
|
|
|
| 3. Exkurs - Datenkapselung in Python |
|
|
|
| 4. Übungen |
|
|
|
| 4. Verwaltung von Objekten |
Programmierung, objektorientiert, OOP, Referenz |
Python |
|
| 1. Einstieg - Simulation eines Roboters |
|
|
|
| 2. Fachkonzept - Zeiger / Referenz |
|
|
|
| 3. Exkurs - Objekte in Python |
|
|
|
| 4. Übungen |
|
|
|
| 5. Beziehungen zwischen Objekten |
Programmierung, objektorientiert, OOP, Beziehung, Interaktion |
Python |
|
| 1. Einstieg - Simulation eines Roboters |
|
|
|
| 2. Fachkonzept - Beziehung |
Programmierung, objektorientiert, OOP, Kennt-Beziehung, Hat-Beziehung |
Python |
|
| 3. Exkurs - Implementierung in Python |
|
|
|
| 4. Fachkonzept - Interaktion zwischen Objekten |
|
|
|
| 5. Übungen |
|
|
|
| 6. Miniwelt und Datenmodell |
Programmierung, objektorientiert, Datenmodell, UML |
Python |
UML |
| 1. Einstieg - Modelle zur Roboterwelt |
|
|
|
| 2. Fachkonzept - Datenmodell |
|
|
|
| 3. Fachkonzept - Zuständigkeit |
|
|
|
| 4. Fachkonzept - UML |
|
|
|
| 5. Übungen |
|
|
|
| 7. Datenmodell und grafische Benutzeroberfläche |
Programmierung, objektorientiert, Datenmodell, GUI |
Python |
|
| 1. Einstieg - Grafische Benutzeroberflächen zur Roboterwelt |
|
|
|
| 2. Fachkonzept - Trennung zwischen Datenmodell und GUI |
|
|
|
| 3. Übungen |
|
|
|
| 8. Vererbung |
Programmierung, objektorientiert, Vererbung |
Python |
|
| 1. Einstieg - Ein Roboter mit Rucksack |
|
|
|
| 2. Fachkonzept - Vererbung |
|
|
|
| 3. Exkurs - Implementierung in Python |
|
|
|
| 4. Übungen |
|
|
|
| 5. Vier Gewinnt |
Programmierung, objektorientiert, OOP |
Python |
Miniprojekt |
| 1. Das Spiel |
|
|
|
| 2. Objektorientierte Modellierung |
|
|
|
| 1. Die Miniwelt 'Vier Gewinnt' |
|
|
|
| 2. Die Akteure unserer Miniwelt |
|
|
|
| 3. Beziehungen zwischen den Akteuren |
|
|
|
| 4. Modellierung eines Klassendiagramms |
|
|
|
| 3. Implementierung |
|
|
|
| 1. Der Programmrumpf |
|
|
|
| 2. Die Klasse 'Player' |
|
|
|
| 3. Die Klasse 'Field' |
|
|
|
| 4. Die Klasse 'GUI' |
|
|
|
| 5. Die Klasse 'Ruleset' |
|
|
|
| 6. Fourwinsgame (Master Klasse) |
|
|
|
| 4. Vertiefungen |
|
|
|
| 1. Ein guter Computergegner?! |
|
|
|
| 2. Das Rule Set Optimiert |
|
|
|
| 3. Einführung objektorientierter Denkweisen mit Scratch |
Programmierung, objektorientiert, OOP |
Scratch |
|
| 1. Objekte als Bausteine |
|
|
|
| 1. Einstieg - Gefährliche Kreuzung |
|
|
|
| 2. Fachkonzept - Objekt |
|
|
|
| 3. Fachkonzept - Attribut |
|
|
|
| 4. Fachkonzept - Methode |
|
|
|
| 2. Entwicklung neuer Objekte |
|
|
|
| 1. Einstieg - Kreuzung mit Ampel |
|
|
|
| 2. Exkurs - Neue Objekte in Scratch |
|
|
|
| 3. Übungen |
|
|
|
| 3. Zusammenarbeit von Objekten |
|
|
|
| 1. Einstieg - Animation der Ampel |
|
|
|
| 2. Fachkonzept - Zugriff auf Attribute |
|
|
|
| 3. Fachkonzept - Aktivierung von Operationen |
|
|
|
| 4. Zuständigkeit von Objekten |
|
|
|
| 1. Einstieg - Steuerung der Ampel |
|
|
|
| 2. Fachkonzept - Zuständigkeit |
|
|
|
| 4. Spiele in Python objektorientiert programmieren |
|
|
|
| 1. Vorbereitungen |
|
|
|
| 1. Installation des Mu-Editors |
|
|
|
| 2. Zusätzliche Dateien |
|
|
|
| 3. Bedienung Mu-Editor |
|
|
|
| 2. Erste Programme |
|
|
|
| 1. Leeres Fenster |
|
|
|
| 2. Fachkonzept: Funktion |
|
|
|
| 3. Hintergrundfarbe |
|
|
|
| 4. Fachkonzept: RGB-Farben |
|
|
|
| 5. Hintergrund-Bilder |
|
|
|
| 3. Spielfiguren als Objekte |
|
|
|
| 1. Eine Spielfigur |
|
|
|
| 2. Spielfiguren platzieren |
|
|
|
| 3. Fachkonzept: Objekt, Attribut, Methode, Klasse und Konstruktor |
|
|
|
| 4. Ausrichtung einer Spielfigur |
|
|
|
| 5. Mehrere Objekte |
|
|
|
| 4. Ereignisse |
|
|
|
| 1. Reaktion auf den Spieler |
|
|
|
| 2. Bewegung der Spielfigur |
|
|
|
| 3. Ändern der Spielfigur-Graphik |
|
|
|
| 4. Fachkonzept: Zuweisungen |
|
|
|
| 5. Übungen zu Ereignissen |
|
|
|
| 5. Entscheidungen |
|
|
|
| 1. Tasten unterscheiden |
|
|
|
| 2. Fachkonzept: Fallunterscheidung |
|
|
|
| 3. Kollisionserkennung |
|
|
|
| 4. Eigene Funktionen |
|
|
|
| 6. Zeitsteuerung |
|
|
|
| 1. Befehle im Takt |
|
|
|
| 2. Zeitlich verzögerte Befehle |
|
|
|
| 7. Zahlen und Zufall |
|
|
|
| 1. Zufallszahlen |
|
|
|
| 8. Viele Objekte |
|
|
|
| 1. Listen von Objekten |
|
|
|
| 2. Fachkonzept - Liste |
|
|
|
| 3. Durchlaufen von Listen |
|
|
|
| 4. Fachkonzept - Zählschleife und Durchlaufen von Listen |
|
|
|
| 1. Funktionale Programmierung mit Python |
Programmierung, funktional, Modellierung |
Python |
|
| 1. Warum funktional programmieren? |
Programmierung, funktional, Modellierung |
Python |
|
| 1. Einstieg - Spaghetticode |
|
|
|
| 2. Exkurs - Von der maschinennahen zur strukturierten Programmierung |
Programmierung, maschinennah, strukturiert |
Python |
|
| 3. Einstieg - Seiteneffekte |
Programmierung, funktional, Seiteneffekt |
Python |
|
| 4. Exkurs - Von der strukturierten zur funktionalen Programmierung |
|
|
|
| 2. Funktionen als Programmierbausteine |
Programmierung, Funktion |
Python |
|
| 1. Station - Datenverarbeitung mit Funktionen |
|
|
|
| 2. Station - Funktionskomposition |
Programmierung, Funktion, Funktionskomposition |
Python |
|
| 3. Station - Fallunterscheidungen |
Programmierung, Funktion, Fallunterscheidung |
Python |
|
| 4. Station - Rekursion |
Programmierung, Funktion, Rekursion |
Python |
|
| 5. Praktikum - Programmieren mit (rekursiven) Funktionen |
|
|
|
| 3. Funktionen als Datenobjekte |
Programmierung, Funktion, Datenobjekt |
Python |
|
| 1. Station - Funktionen höherer Ordnung |
|
|
|
| 2. Station - Der map-Operator |
|
|
|
| 3. Station - Der filter-Operator |
|
|
|
| 4. Deklarative Programmierung |
Programmierung, Funktion, deklarativ |
Python |
|
| 1. Station - Beschreiben statt Befehlen |
|
|
|
| 2. |
|
|
|
| 3. Miniprojekt - Geometrische Abbildungen |
|
|
|
| 2. Funktionale Programmierung mit Elm |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Vorwort |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Warum funktional programmieren? |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Lokale Installation |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Online-Alternativen |
Programmierung, funktional, Modellierung |
Elm |
|
| 4. REPL |
Programmierung, funktional, Modellierung |
Elm |
|
| 5. Mögliche Wege durch das Kapitel |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Programmierung mit Elm |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Daten und ihre Verarbeitung |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Wandtattoo |
|
|
|
| 1. Ein Berechnungsproblem |
|
|
|
| 1. Berechnungen in der REPL |
|
|
|
| 2. Das Kostenberechnungsproblem |
|
|
|
| 2. Experimente - Int und Float |
|
|
|
| 1. Zwei Sorten von Zahlen |
|
|
|
| 1. Rechenoperationen |
|
|
|
| 2. Typumwandlungen |
|
|
|
| 3. Vordefinierte Funktionen |
|
|
|
| 3. Beispiel - Verschlüsselung |
|
|
|
| 1. Zwei einfache Verschlüsselungsverfahren |
|
|
|
| 1. Experimente in der REPL zum Caesar-Verfahren |
|
|
|
| 2. Experimente in der REPL zum Umkehrverfahren |
|
|
|
| 3. Rückblick und Ausblick |
|
|
|
| 4. Experimente - Char und String |
|
|
|
| 1. Zeichen und Zeichenketten |
|
|
|
| 1. Vordefinierte Funktionen zur Verarbeitung von Zeichen |
|
|
|
| 2. Vordefinierte Funktionen zur Verarbeitung von Zeichenketten |
|
|
|
| 5. Beispiel - Schaltjahre |
|
|
|
| 1. Ein Berechnungsproblem |
|
|
|
| 1. Experimente in der REPL |
|
|
|
| 6. Experimente - Bool |
|
|
|
| 1. Wahrheitswerte |
|
|
|
| 1. Logische Operatoren |
|
|
|
| 2. Vordefinierte boolsche Funktionen |
|
|
|
| 7. Vertiefung - Operatorrangfolge |
|
|
|
| 8. Übungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 9. Fachkonzept - Datentyp |
|
|
|
| 10. Fachkonzept - Vordefinierte Funktion |
|
|
|
| 11. Fachkonzept - Ausdruck |
|
|
|
| 2. Funktionen als Programmierbausteine |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Wandtattoo |
|
|
|
| 1. Modellierung einer Funktion |
|
|
|
| 2. Implementierung einer Funktion |
|
|
|
| 3. Eine weitere Funktion |
|
|
|
| 4. Typangaben |
|
|
|
| 2. Vertiefung - Module und Elm-Projekte |
|
|
|
| 3. Übungen |
|
|
|
| 4. Fachkonzept - Funktion |
|
|
|
| 5. Fachkonzept - Konstante |
|
|
|
| 6. Fachkonzept - REPL und Projekte |
|
|
|
| 3. Listen und Zeichenketten |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Notenliste |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Verwaltung der Daten |
|
|
|
| 2. Daten hinzufügen |
|
|
|
| 3. Verarbeitung mit vordefinierten Funktionen |
|
|
|
| 4. Listen von Listen |
|
|
|
| 5. Funktionen höherer Ordnung |
|
|
|
| 6. Partielle Funktionsanwendung |
|
|
|
| 2. Beispiel - Caesar |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Zeichenketten als Listen |
|
|
|
| 2. Funktionen höherer Ordnung |
|
|
|
| 3. Partielle Funktionsanwendung |
|
|
|
| 3. Übungen |
|
|
|
| 4. Fachkonzept - Liste |
|
|
|
| 5. Fachkonzept - Funktion höherer Ordnung |
|
|
|
| 4. Gestaltung von Funktionsausdrücken |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Verschlüsselung |
|
|
|
| 1. Ein neues Verfahren |
|
|
|
| 1. Entwicklung einer Funktionsdefinition |
|
|
|
| 2. Analyse der Funktionsdefinition |
|
|
|
| 3. Verwendung lokaler Konstanten |
|
|
|
| 4. Verwendung des Pipe-Operators |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept - let-Ausdrücke |
|
|
|
| 4. Fachkonzept - Pipe-Operator |
|
|
|
| 5. Fallunterscheidungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Eintrittspreise |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Eine Fallunterscheidung |
|
|
|
| 2. Geschachtelte Fallunterscheidungen |
|
|
|
| 3. Mehrfachauswahl mit einem Musterabgleich |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept - Fallunterscheidung |
|
|
|
| 4. Fachkonzept - Musterabgleich |
|
|
|
| 6. Erzeugung von Funktionen |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Anonyme Funktionen |
|
|
|
| 1. Funktionen mit Namen |
|
|
|
| 1. Funktionen ohne Namen |
|
|
|
| 2. Partiell angewandte Funktionen |
|
|
|
| 1. Partielle Funktionsanwendung |
|
|
|
| 1. Iterierte Funktionsanwendung |
|
|
|
| 2. Beispiele und Anwendungen |
|
|
|
| 3. Komposition von Funktionen |
|
|
|
| 1. Der Pipe-Operator |
|
|
|
| 1. Der Kompositionsoperator |
|
|
|
| 2. Anwendung - Caesar-Verfahren |
|
|
|
| 4. Übungen |
|
|
|
| 5. Fachkonzept - anonyme Funktion |
|
|
|
| 6. Fachkonzept - Currying |
|
|
|
| 7. Fachkonzept - Funktionskomposition |
|
|
|
| 7. Verarbeitung von Datensätzen |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Mailadressen |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Verwaltung als Record |
|
|
|
| 2. Verwendung von Aliasnamen |
|
|
|
| 3. Zugriff auf die Attribute |
|
|
|
| 4. Automatisch erzeugte Funktionen |
|
|
|
| 5. Verarbeitung von Datensätzen mit Attributzugriffen |
|
|
|
| 6. Verarbeitung von Datensätzen über Mustererkennung |
|
|
|
| 7. Aktualisierung von Datensätzen |
|
|
|
| 8. Geschachtelte Datensätze |
|
|
|
| 2. Beispiel - Metadaten |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Verwaltung als Tupel |
|
|
|
| 2. Verarbeitung von Tupeln |
|
|
|
| 3. Übungen |
|
|
|
| 4. Fachkonzept - Datensatz als Record |
|
|
|
| 5. Fachkonzept - Datensatz als Tupel |
|
|
|
| 8. Erzeugung von Datentypen |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Begrüßung |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Definition eines neuen Datentyps |
|
|
|
| 2. Implementierung |
|
|
|
| 3. Experimente in der REPL |
|
|
|
| 2. Beispiel - Interpreter |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Verwaltung der Daten |
|
|
|
| 2. Definition eines neuen Datentyps |
|
|
|
| 3. Ausführung von Befehlen |
|
|
|
| 4. Automatisierung der Befehlsausführung |
|
|
|
| 5. Ein wiederhole-Befehl |
|
|
|
| 6. Erweiterungen |
|
|
|
| 3. Übungen |
|
|
|
| 4. Fachkonzept - Typdefinition |
|
|
|
| 9. Fehlerbehandlung |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Beispiel - Benutzereingaben |
|
|
|
| 1. Problemsituation |
|
|
|
| 1. Implementierungsvorschlag |
|
|
|
| 2. Umwandlung von Zahlen |
|
|
|
| 3. Der Datentyp Maybe |
|
|
|
| 4. Ausgabefunktion |
|
|
|
| 2. Übungen |
|
|
|
| 3. Fachkonzept - Fehlerbehandlung |
|
|
|
| 10. Rekursion |
Programmierung, funktional, Modellierung |
Elm |
|
| 11. Module |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Dynamische Webseiten mit Elm |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Hallo Elm |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. HTML-Grundlagen |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Hallo Elm - online |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. ellie-app.com |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Analyse |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Tipps |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Hallo Elm - lokal |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. elm init |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. elm make |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. elm-live |
Programmierung, funktional, Modellierung |
Elm |
|
| 4. Übungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Caesar I |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Ziele und Voraussetzungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Elementknoten |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Listen von Knoten |
Programmierung, funktional, Modellierung |
Elm |
|
| 4. Mehrere Elementknoten |
Programmierung, funktional, Modellierung |
Elm |
|
| 5. Geheimtext berechnen |
Programmierung, funktional, Modellierung |
Elm |
|
| 6. view-Funktion |
Programmierung, funktional, Modellierung |
Elm |
|
| 7. Datentypen |
Programmierung, funktional, Modellierung |
Elm |
|
| 8. Verarbeitung von Listen |
Programmierung, funktional, Modellierung |
Elm |
|
| 9. Übungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Notenauswertung |
Programmierung, funktional, Modellierung |
Elm |
|
| 1. Ziele und Voraussetzungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 2. Einzelnote |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Gesamtliste |
Programmierung, funktional, Modellierung |
Elm |
|
| 4. Auswertung |
Programmierung, funktional, Modellierung |
Elm |
|
| 5. Übungen |
Programmierung, funktional, Modellierung |
Elm |
|
| 4. Sport-Ergebnisse |
Programmierung, funktional, Modellierung |
Elm |
|
| 5. Caesar II |
Programmierung, funktional, Modellierung |
Elm |
|
| 6. Nim-Spiel |
Programmierung, funktional, Modellierung |
Elm |
|
| 7. Umgang mit Fehlern |
Programmierung, funktional, Modellierung |
Elm |
|
| 8. Zufall |
Programmierung, funktional, Modellierung |
Elm |
|
| 4. Nachwort |
Programmierung, funktional, Modellierung |
Elm |
|
| 3. Logische Programmierung |
logisch, Programmierung, Modellierung |
Prolog |
|
| 1. Modellierung von Wissen |
Fakten, Regeln, Anfragen, Programmierung, logisch, Modellierung, logisches Schließen |
Prolog |
|
| 1. Die Wissensbasis |
|
|
|
| 2. Modellierung mit Fakten |
|
|
|
| 3. Fachkonzept Fakten |
|
|
|
| 4. Programmieren mit Prolog |
|
|
|
| 5. Anfragen an die Wissensbasis |
|
|
|
| 6. Fachkonzept Anfragen |
|
|
|
| 7. Übungen zu Anfragen |
|
|
|
| 8. Modellierung mit Regeln |
|
|
|
| 9. Fachkonzept Regeln |
|
|
|
| 10. Rekursive Regeln |
|
|
|
| 11. Übungen zu Regeln |
|
|
|
| 12. Zusammenfassung - Programmierkonzept |
|
|
|
| 13. Zusammenfassende Übungen |
|
|
|
| 2. Auswertung von Anfragen |
|
|
|
| 1. Die Schlussregel modus ponens |
|
|
|
| 2. Suche nach logischen Herleitungen |
|
|
|
| 3. Automatisierung des logischen Schließens |
|
|
|
| 4. Experimente mit Prolog |
|
|
|
| 3. Verwaltung von Daten |
Anfragen, Terme, Liste, Programmierung, logisch, Modellierung |
Prolog |
|
| 1. Terme |
|
|
|
| 1. Stadt-Land-Fluss |
|
|
|
| 2. Konstanten |
|
|
|
| 3. Zusammengesetzte Terme |
|
|
|
| 4. Beispiele und Übungen |
|
|
|
| 2. Listen und ihre Verarbeitung |
|
|
|
| 1. Stadt-Land-Fluss |
|
|
|
| 2. Kopf-Rest-Methode |
|
|
|
| 3. Rekursive Verarbeitung von Listen |
|
|
|
| 4. Akkumulatormethode |
|
|
|
| 5. Beispiele und Übungen |
|
|
|
| 6. Das Bootstourproblem |
|
|
|
| 3. Zahlen und ihre Verarbeitung |
|
|
|
| 1. Stadt-Land-Fluss |
|
|
|
| 2. Vergleiche |
|
|
|
| 3. Berechnungen |
|
|
|
| 4. Beispiele und Übungen |
|
|
|
| 4. Ausgabe von Daten |
|
|
|
| 4. Deklarative Programmierung |
Graphen, Programmierung, logisch, Modellierung |
Prolog |
|
| 1. Ein Graphenproblem |
|
|
|
| 2. Problemlösestrategien |
|
|
|
| 3. Lösung des Graphenproblems |
|
|
|
| 1. Lösung eines vereinfachten Problems |
|
|
|
| 2. Exkurs - Tiefensuche in Graphen |
|
|
|
| 3. Aufsammeln von Wegknoten |
|
|
|
| 4. Aufsammeln von Wegknoten in einer Akkumulatorliste |
|
|
|
| 5. Lösung des Problems |
|
|
|
| 4. Anwendungen zum Graphenproblem |
|
|
|
| 1. Das Tratsch-Problem der Chatoren |
|
|
|
| 2. Ein Umfüllproblem |
|
|
|
| 1. Sicherheitsprobleme |
Kryptologie, Kommunikation, Sicherheitsziel, Phishing, Signatur |
|
|
| 1. Einstieg - Gefälschte E-Mails |
|
|
|
| 2. Einstieg - Neuer Personalausweis |
|
|
|
| 3. Fachkonzept - Sicherheitsziele |
|
|
|
| 4. Übungen |
|
|
|
| 2. Historische Chiffriersysteme |
|
|
|
| 1. Station - Chiffrierung mit dem Verschiebeverfahren |
Kryptologie, Kommunikation, historisch, monoalphabetisch, Kryptographie |
Python |
|
| 2. Station - Kryptoanalyse beim Verschiebeverfahren |
Kryptologie, Kommunikation, historisch, monoalphabetisch, Kryptoanalyse |
|
|
| 3. Station - Chiffrierung mit dem Ersetzungsverfahren |
Kryptologie, Kommunikation, historisch, monoalphabetisch, Kryptographie |
|
|
| 4. Station - Kryptoanalyse beim Ersetzungsverfahren |
Kryptologie, Kommunikation, historisch, monoalphabetisch, Kryptoanalyse |
|
|
| 5. Station - Chiffrierung mit dem Vigenère-Verfahren |
Kryptologie, Kommunikation, historisch, polyalphabetisch, Kryptographie |
|
|
| 6. Station - Kryptoanalyse beim Vigenère-Verfahren |
Kryptologie, Kommunikation, historisch, polyalphabetisch, Kryptoanalyse |
|
|
| 7. Station - One-Time-Pad |
Kryptologie, Kommunikation, polyalphabetisch, Kryptographie, one-time-pad |
|
|
| 8. Station - Sicherheit beim One-Time-Pad |
Kryptologie, Kommunikation, polyalphabetisch, Kryptographie, one-time-pad |
|
|
| 9. Übungen |
|
|
|
| 3. Moderne Chiffriersysteme |
Kryptologie, Kommunikation, Schlüssel, Kryptographie |
|
|
| 1. Einstieg - Symmetrische Chiffriersysteme |
Kryptologie, Kommunikation, Kryptographie, symmetrisch, Schlüssel |
|
|
| 2. Fachkonzept - Symmetrische Chiffriersysteme |
|
|
|
| 3. AES - Ein modernes symmetrisches Chiffrierverfahren |
Kryptologie, Kommunikation, Kryptographie, symmetrisch, AES |
|
Cryptool |
| 1. Exkurs - Experimente mit CrypTool |
|
|
|
| 4. Einstieg - Asymmetrische Chiffriersysteme |
Kryptologie, Kommunikation, Kryptographie, asymmetrisch, Schlüssel |
|
|
| 5. Fachkonzept - Asymmetrische Chiffriersysteme |
|
|
|
| 6. RSA - Ein modernes asymmetrisches Chiffrierverfahren |
Kryptologie, Kommunikation, Kryptographie, asymmetrisch, Schlüssel, RSA |
|
Cryptool, GnuPG |
| 1. Exkurs - Experimente mit CrypTool |
|
|
|
| 2. Exkurs - Experimente mit GnuPG |
|
|
|
| 3. Exkurs - Experimente mit GnuPG / Kleopatra |
|
|
|
| 7. Exkurs - Hybride Chiffriersysteme |
Kryptologie, Kommunikation, Kryptographie, asymmetrisch, symmetrisch, RSA, AES |
|
Cryptool |
| 8. Exkurs - Sicherheit von Chiffriersystemen |
|
|
|
| 9. Exkurs - Diffie-Hellman-Schlüsselaustausch |
Kryptologie, Kommunikation, Kryptographie, Schlüssel, Diffie-Hellmann, symmetrisch |
|
|
| 4. Das RSA-Verfahren |
Kryptologie, Kommunikation, Kryptographie, asymmetrisch, Primzahl, Schlüssel |
|
Cryptool |
| 1. Experimente mit CrypTool |
|
|
|
| 1. Station - RSA-Demo |
|
|
|
| 2. Modulares Rechnen |
|
|
|
| 1. Station - Uhrenaddition |
|
|
|
| 2. Station - Modulare Gleichheit |
|
|
|
| 3. Station - Modulare Addition |
|
|
|
| 4. Station - Modulare Multiplikation |
|
|
|
| 5. Station - Modulare Potenz |
|
|
|
| 3. Verschlüsselung mit modularer Addition |
|
|
|
| 1. Station - Caesar-Verfahren |
|
|
|
| 2. Station - Codierung mit Zahlen |
|
|
|
| 3. Station - Verfahren mit modularer Addition |
|
|
|
| 4. Station - Korrektheit und Sicherheit |
|
|
|
| 5. Station - Implementierung |
|
|
|
| 4. Verschlüsselung mit modularer Multiplikation |
|
|
|
| 1. Station - Verschlüsselung mit modularer Multiplikation |
|
|
|
| 2. Station - Das Verfahren und seine Korrektheit |
|
|
|
| 3. Station - Implementierung |
|
|
|
| 4. Station - Sicherheit des Verfahrens |
|
|
|
| 5. Station - Berechnung des modularen Inversen |
|
|
|
| 5. Verschlüsselung mit modularer Potenz |
|
|
|
| 1. Station - Verfahren mit modularer Potenz |
|
|
|
| 2. Station - Schnelles modulares Potenzieren |
|
|
|
| 3. Station - Implementierung des Verfahrens |
|
|
|
| 4. Station - Erzeugung der Schlüssel |
|
|
|
| 5. Station - Korrektheit des Verfahrens |
|
|
|
| 6. Station - Sicherheit des Verfahrens |
|
|
|
| 7. Station - RSA-Kryptosystem |
|
|
|
| 6. Primzahlalgorithmen |
Kryptologie, Kommunikation, Primzahl |
Python |
|
| 1. Station - Primzahltest |
|
|
|
| 2. Station - Faktorisierung |
|
|
|
| 5. Digitale Signatur |
Kryptologie, Kommunikation, Sicherheitsziel, Signatur |
|
|
| 1. Einstieg - Signiersysteme |
|
|
|
| 2. Fachkonzept - Signiersysteme |
|
|
|
| 3. Einstieg - Digitale Fingerabdrücke |
Kryptologie, Kommunikation, Hashfunktion, MD5 |
|
Cryptool |
| 1. Experimente mit CrypTool |
|
|
|
| 2. Experimente mit Python |
|
|
|
| 3. Experimente mit dem MD5-Algorithmus |
|
|
|
| 4. Fachkonzept - Kryptologische Hash-Funktion |
|
|
|
| 5. Übungen |
|
|
|
| 6. Sicherer E-Mail-Austausch |
|
|
|
| 1. Exkurs - Vorbereitung eines E-Mail-Programms |
|
|
|
| 2. Exkurs - E-Mails signieren und verschüsseln |
|
|
|
| 7. Sicherheitsinfrastruktur |
Kryptologie, Kommunikation, Schlüssel, Kryptographie, Zertifikat, Sicherheitsziel |
|
|
| 1. Einstieg - Vertrauen in Schlüssel |
|
|
|
| 2. Exkurs - Schlüssel zertifizieren |
|
|
|
| 3. Fachkonzept - Web of Trust |
|
|
|
| 4. Einstieg - (Wo)Man in the middle Angriff |
|
|
|
| 5. Fachkonzept - Public-Key-Zertifikat |
|
|
|
| 6. Fachkonzept - Public Key Infrastruktur |
|
|
|
| 7. Exkurs - Browser-Experimente |
|
|
|
| 8. Exkurs - HTTPS |
|
|
|
| 8. Blockchain Einführung |
Kryptologie, Kommunikation, Hashfunktion, Blockchain |
|
|
| 1. Währungssystem Teil 1 |
|
|
|
| 2. Währungssystem Teil 2 |
|
|
|
| 3. Geldzuwachs |
|
|
|
| 4. Blockchain Beispiel Teil 1 |
|
|
|
| 5. Blockchain Beispiel Teil 2 |
|
|
|
| 6. Fachkonzept - Blockchain |
|
|
|
| 7. Probiere es aus |
|
|
|
| 9. Geheimnisse teilen |
|
|
|
| 1. Einführung |
|
|
|
| 2. Einführung – Aufgaben |
|
|
|
| 3. Grundlagen |
|
|
|
| 4. Grundlagen – Aufgaben |
|
|
|
| 5. Geometrische Variante |
|
|
|
| 6. Geometrische Variante – Aufgaben |
|
|
|
| 7. Modulare Variante |
|
|
|
| 8. Modulare Variante - Aufgaben |
|
|
|
| 9. Lösungen der Aufgaben |
|
|
|
| 10. Tor-Netz |
Tor, Tor-Netz, Tornetz, Tor-Browser, Torbrowser |
|
|
| 1. Protokolle Webseiten |
|
|
|
| 1. http |
|
|
|
| 2. https |
|
|
|
| 2. Aufbau des TOR-Netzes |
Tor-Circuit |
|
|
| 1. Software |
Torbrowser |
|
|
| 2. Aufbau Circuit |
Tor-Circuit |
|
|
| 3. Verschlüsselung Hinweg |
|
|
|
| 4. Verschlüsselung Rückweg |
|
|
|
| 3. Bridges und Snowflake |
Tor-Bridge, Snowflake |
|
|
| 4. Hidden Services |
Tor-Hidden-Service |
|
|
| 5. Secure Drop |
Secure-Drop |
|
|
| 6. Sicherheit des Tor-Netzes |
|
|
|
| 7. Historisches |
|
|
|
| 8. Gesellschaftliches |
|
|
|
| 1. Künstliche Intelligenz |
Künstliche Intelligenz, KI, Artificial Intelligenz, AI |
|
|
| 1. KI - Eine Übersicht |
Künstliche Intelligenz |
|
|
| 1. KI: Faszination und Ängste |
|
|
|
| 2. Automatisierung und KI |
|
|
|
| 3. Expertensysteme und Maschinelles Lernen |
|
|
|
| 4. Ethische und moralische Aspekte |
Ethische/moralische Aspekte von KI |
|
|
| 1. Unbegründbarkeit von KI-Entscheidungen |
|
|
|
| 2. Werbetracking als Quelle für persönliche Daten |
|
|
|
| 3. Zum Weiterhören |
|
|
|
| 2. Überwachtes maschinelles Lernen mit Neuronalen Netzen |
Maschinelles Lernen, Machine Learning, ML, Perzeptron |
Python, Jupyter-Notebooks |
|
| 1. Neuronen |
|
|
|
| 2. Perzeptron als künstliches Neuron |
|
|
|
| 1. Aufgaben (Notebook) |
|
|
|
| 3. Separationsgerade |
|
|
|
| 1. Aufgaben (unplugged) |
|
|
|
| 2. Aufgaben (Notebook) |
|
|
|
| 4. Fachkonzept Perzeptron |
|
|
|
| 5. Maschinelles Lernen: Delta-Regel nach Rosenblatt |
|
|
|
| 1. Aufgaben (Notebook) |
|
|
|
| 6. XOR-Problem |
|
|
|
| 1. Aufgaben (Notebook) |
|
|
|
| 7. Fachkonzept künstliche Neuronen |
|
|
|
| 8. Gradientenabstiegsverfahren |
|
|
|
| 1. Umsetzung in Python |
|
|
|
| 9. Künstliche Neuronale Netze |
Künstliche Neuronale Netze, KNN, Forward Propagation |
Python, Jupyter-Notebooks |
|
| 1. Fachkonzept Forward-Propagation |
|
|
|
| 2. Forward-Propagation mit Python |
|
|
|
| 10. Ziffernerkennung |
Maschinelles Lernen, Machine Learning, ML |
Python, Jupyter-Notebooks |
|
| 1. MNIST-Datensatz |
Maschinelles Lernen, Machine Learning, ML |
Python, Jupyter-Notebooks |
|
| 2. Machine Learning |
Maschinelles Lernen, Machine Learning, ML |
Python, Jupyter-Notebooks |
|
| 11. Maschinelles Lernen |
Backward-Propagation, Gradientenabstiegs-Verfahren |
Python, Jupyter-Notebooks |
|
| 1. Gradientenabstiegverfahren |
|
|
|
| 2. Backward Propagation |
|
|
|
| 3. Bestärkendes maschinelles Lernen mit Q-Learning |
|
|
|
| 1. Wahrnehmungs-Aktions-Schleife |
|
|
|
| 1. Erkundung: Ein einfaches Computerspiel |
|
|
|
| 2. Fachkonzept: Wahrnehmungs-Aktions-Schleife |
|
|
|
| 2. Hartkodierte Intelligenz |
|
|
|
| 3. Weicher kodierte Intelligenz |
|
|
|
| 1. Die Q-Tabelle |
|
|
|
| 2. Verhalten aus der Q-Tabelle |
|
|
|
| 3. Fachkonzept: Gierig und neugierig |
|
|
|
| 4. Implementation einer neugierigen Strategie |
|
|
|
| 4. Anpassung der Q-Werte |
|
|
|
| 1. Kurzsichtiges Lernen |
|
|
|
| 2. Fachkonzept: Verzögerte Belohnung |
|
|
|
| 3. Implementation |
|
|
|
| 5. Umgang mit Chancen und Risiken |
|
|
|
| 1. Bisheriges Verfahren bei Chancen und Risiken |
|
|
|
| 2. Fachkonzept: Lernrate |
|
|
|
| 3. Implementation |
|
|
|
| 4. Überwachtes maschinelles Lernen mit Neuronalen Netzen (ohne numpy) |
Maschinelles Lernen, Machine Learning, ML, Perzeptron |
|
|
| 1. Biologische Neuronen |
|
|
|
| 2. Einfaches Perzeptron als künstliches Neuron |
|
|
|
| 3. Eine weitere Vereinfachung |
|
|
|
| 4. Schrittweises Verbessern |
|
|
|
| 5. Maschinelles Lernen: Delta-Regel nach Rosenblatt |
|
|
|
| 6. Einfaches Perzeptron in Python |
Künstliche Neuronale Netze, KNN, Forward Propagation |
|
|
| 7. XOR-Problem |
|
|
|
| 8. Mehrlagige Perzeptrone |
Künstliche Neuronale Netze, KNN, Forward Propagation |
|
|
| 9. Mehrlagige Perzeptrone in Python |
Künstliche Neuronale Netze, KNN, Forward Propagation |
|
|
| 10. Fehler-Rückleitung |
Backward-Propagation, Gradientenabstiegs-Verfahren |
|
|
| 11. Fehler-Rückleitung in Python |
Künstliche Neuronale Netze, KNN, Forward Propagation |
|
|
| 2. Roboterprogrammierung mit leJOS |
Robotik |
Java, leJOS |
NXT, EV3 |
| 1. Roboter im Einsatz |
|
|
|
| 1. Fachkonzept - Roboter |
|
|
|
| 2. Exkurs - Robotergesetze |
|
|
|
| 2. Vorbereitung von Hard- und Software |
|
|
|
| 1. Softwareinstallationen |
|
|
|
| 2. Einsatz des EV3-Bausteins |
|
|
|
| 3. Einsatz des NXT-Bausteins |
|
|
|
| 4. Einstieg - Hallo Welt! |
|
|
|
| 3. Einstieg in leJOS |
|
|
|
| 1. Probefahrt |
|
|
|
| 2. Planen mit Flussdiagrammen |
|
|
|
| 3. Variablen und Operatoren |
|
|
|
| 4. Wiederverwendung: Methoden und Parameter |
|
|
|
| 1. Methoden definieren |
|
|
|
| 2. Parametrisierte Methoden |
|
|
|
| 3. Parcours planen und befahren |
|
|
|
| 5. Exkurs: NXT-Kurvenfahrt |
|
|
|
| 6. Flexibiltät: Fallunterscheidung |
|
|
|
| 7. Schachtelung |
|
|
|
| 1. Schachtelung mit if/else |
|
|
|
| 2. Schachtelung mit logischen Operatoren |
|
|
|
| 8. Schleifen |
|
|
|
| 1. for-Schleife |
|
|
|
| 2. while-/do-while-Schleife |
|
|
|
| 3. Endlosschleifen |
|
|
|
| 9. Exkurs: Labyrinth und Zufall |
|
|
|
| 4. Messen und Darstellen |
|
|
|
| 2. Ultraschallsensor |
|
|
|
| 1. Funktionstest mit leJOS |
|
|
|
| 2. Übungen |
|
|
|
| 3. Licht- und Farbsensor |
|
|
|
| 1. Funktionstest mit leJOS |
|
|
|
| 2. Übungen |
|
|
|
| 4. Audio: Mikrofon und Lautsprecher |
|
|
|
| 1. Funktionstest mit leJOS |
|
|
|
| 2. Übungen |
|
|
|
| 5. Exkurs - Threads |
|
|
|
| 3. Der Raspberry Pi als Informatiksystem |
Informatiksystem, Computer, Linux, Hardware |
|
RaspberryPi |
| 1. Materialguide |
|
|
|
| 2. Kennenlernen des RasPi |
Informatiksystem, Linux, Hardware, Betriebssystem |
Raspbian |
RaspberryPi |
| 1. Hardware |
|
|
|
| 2. Den Raspi konfigurieren |
|
|
|
| 3. Linux als Betriebssystem |
|
|
|
| 3. Grundlagen für praktische Experimente mit dem RasPi |
Steckbrett, GPIO, LED, Taster |
Python |
RaspberryPi |
| 1. Das Steckbrett für Schaltungen |
|
|
|
| 2. Die GPIO-Schnittstelle |
|
|
|
| 3. Ausgabe über GPIO |
|
|
|
| 4. Eingabe über GPIO |
|
|
|
| 4. Experiment: Bitübertragung zwischen RasPis |
Kommunikation, Protokoll, Bitübertragung, Zeichenkodierung, binär, Rechnernetze, Fehlererkennung, Prüfbit |
Python |
RaspberryPi |
| 1. Lesen eines Eingangssignals |
|
|
|
| 2. Senden von Signalen |
|
|
|
| 3. Datenübertragung |
|
|
|
| 1. Senden von Texten |
|
|
|
| 2. Empfangen von Texten |
|
|
|
| 5. Experiment: Wetterstation |
Steckbrett, Sensor |
|
RaspberryPi |
| 1. Sensorwerte lesen und schreiben |
|
|
|
| 4. Der Calliope mini als Informatiksystem |
Calliope, Informatiksystem, OpenRoberta, MakeCode, Sensor, Aktor |
OpenRoberta, MakeCode |
Calliope |
| 1. Kennenlernen |
|
|
|
| 2. Programmieren |
|
|
|
| 3. Aktoren |
|
|
|
| 4. Sensoren |
|
|
|
| 1. Lichtsensor |
|
|
|
| 2. Temperatursensor |
|
|
|
| 3. Taster |
|
|
|
| 4. Mikrofon |
|
|
|
| 5. Kompass |
|
|
|
| 6. Lagesensor |
|
|
|
| 7. Externe Sensoren |
|
|
|
| 5. Kommunikation |
|
|
|
| 1. Bluetooth Modul |
|
|
|
| 2. Bituebertragung über die Pins des Calliope mini |
|
|
|
| 6. Projekte |
|
|
|
| 7. Sonstiges |
|
|
|
| 8. LoRaWAN |
IoT, TTN, Sensor, Sender, LoRaWAN |
|
Calliope |
| 1. Datenerfassung überall |
|
|
|
| 1. The Things Network (TTN) |
|
|
|
| 2. Device anlegen |
|
|
|
| 3. Die LoRa-Hardware |
|
|
|
| 4. LoRa mit Makecode |
|
|
|
| 5. Daten kontrollieren |
|
|
|
| 6. Datenformate |
|
|
|
| 7. Daten darstellen |
|
|
|
| 8. Das hast du hier gelernt |
|
|
|
| 9. Abstandssensor Automodell |
IoT, Sensor |
|
Calliope |
| 1. Abstandssensor am Auto |
|
|
|
| 1. Ultraschallsensoren am Auto |
|
|
|
| 2. Ultraschallsensor am Calliope |
|
|
|
| 3. Automodellbau |
|
|
|
| 4. Programmierung Abstand |
|
|
|
| 5. Programmierung Warnung |
|
|
|
| 10. Füllstand Zisterne |
IoT, Sensor |
|
Calliope |
| 1. Füllstand Zisterne |
|
|
|
| 1. Ultraschallsensor am Calliope |
|
|
|
| 2. Zisternenmodell |
|
|
|
| 3. Ultraschallsenor und WLAN-Modul |
|
|
|
| 4. Programmierung Zisternenmodell |
|
|
|
| 11. Halterung |
|
|
|
| 1. Einfache Halterung |
|
|
|
| 2. IoT-Halterung |
|
|
|
| 12. Calliope Solar |
IoT, Sensor |
|
Calliope |
| 1. Solarzelle |
|
|
|
| 1. Solarzelle ohne Calliope |
|
|
|
| 2. Solarzelle am Calliope |
|
|
|
| 3. Spannung einer Solarzelle |
|
|
|
| 4. Leistung einer Solarzelle |
|
|
|
| 5. Leistung an eine Cloud senden |
|
|
|
| 6. Solarnachführung |
|
|
|
| 13. KI Kamera |
IoT, Sensor, Kamera |
|
Calliope |
| 1. Videoüberwachung mit KI |
|
|
|
| 1. Husky Lens KI |
|
|
|
| 2. Husky Lens trainieren |
|
|
|
| 3. Programmieren des Calliopes |
|
|
|
| 4. Spiel Stein-Schere-Papier |
|
|
|
| 5. Office-Anwendungen |
Gesellschaft, Freie Software, LibreOffice, Office, Textverarbeitung, Konzepte und Werkzeuge, Formatierung |
|
|
| 1. Orientierung |
Gesellschaft, Freie Software, LibreOffice, Office, Textverarbeitung, Konzepte und Werkzeuge |
|
|
| 2. Textverarbeitung-Grundlagen |
LibreOffice, Office, Textverarbeitung, Formatierung |
|
|
| 3. Textverarbeitung-Formatvorlagen |
LibreOffice, Office, Textverarbeitung, Formatierung, CSS |
|
|
| 4. Textverarbeitung-Dokumentvorlage |
LibreOffice, Office, Textverarbeitung, Formatierung |
|
|
