1. Informationsdarstellung im Internet |
|
|
|
1. Vorwort: Das WWW |
WWW ,
Hyperlink ,
Hypertext ,
URL ,
Webseite |
|
|
1. Orientierung |
|
|
|
2. Erkundung |
|
|
|
3. Strukturierung |
|
|
|
4. Fachkonzept |
|
|
|
5. Exkurs – WWW gleich Internet? |
|
|
|
6. Übungen |
|
|
|
7. Überprüfung |
|
|
|
2. Webseiten erstellen |
HTML ,
Formale Sprache ,
CSS ,
Formatierung ,
Validierung |
|
|
1. Erkundung: HTML |
|
|
|
2. Erkundung: CSS |
|
|
|
3. Syntax und Semantik |
|
|
|
4. Browser und Editor |
|
|
|
5. Projekt |
|
|
|
6. Elementstruktur |
|
|
|
7. Validierung von Webseiten |
|
|
|
1. Fehlerhafte Quelltexte |
|
|
|
1. Validierer |
|
|
|
2. CSS validieren |
|
|
|
3. Das hast du hier gelernt |
|
|
|
8. Exkurs: Responsive Design |
|
|
|
9. Exkurs: CSS Grid |
HTML ,
CSS ,
CSS-Grid ,
Formatierung ,
Responsive |
|
|
1. HTML 5 |
|
|
|
2. Einstieg CSS Grid |
|
|
|
3. Erweiterung CSS Grid |
|
|
|
4. Card Layout |
|
|
|
5. Container Layout |
|
|
|
6. Projektideen |
|
|
|
3. Gesellschaftliches |
Datenschutz |
|
|
1. Rechtliches |
|
|
|
1. Bilder auf Webseiten |
|
|
|
1. Rechtliche Begriffe |
|
|
|
2. Rechtsfälle |
|
|
|
3. Übungen und Vernetzung |
|
|
|
4. Zusammenfassung |
|
|
|
2. Persönliches |
Datenschutz |
|
|
1. Barrierefreiheit |
HTML ,
Barrierefrei ,
Gleichstellung |
HTML |
|
1. Einstieg - Webseiten anders wahrnehmen |
|
|
|
2. Fachkonzept - Barrierefreiheit |
|
|
|
2. Persönliche Daten |
Datenschutz |
|
|
1. Einstieg - Spuren im Internet |
|
|
|
2. Exkurs - Persönliche Daten im Internet |
|
|
|
3. Umweltauswirkungen |
Datenschutz |
|
|
2. Binärdarstellung von Information |
|
|
|
1. Binärdarstellung von Daten |
Daten ,
Information ,
Binärdarstellung ,
Bit ,
Byte |
|
|
1. Einstieg - Fußballergebnisse |
|
|
|
2. Fachkonzept - Information/Daten |
|
|
|
3. Fachkonzept - Bit/Byte |
|
|
|
4. Übungen |
|
|
|
5. Überprüfung - Alles klar? |
|
|
|
2. Binärdarstellung von Zahlen |
Binärdarstellung ,
Dualzahl ,
Hexadezimalsystem ,
Basis ,
Stellenwert |
|
|
1. Einstieg - Gefängnisausbruch |
|
|
|
2. Exkurs - Stellenwertsysteme |
|
|
|
3. Fachkonzept - Dualsystem |
|
|
|
4. Einstieg - Hexadezimalzahlen |
|
|
|
5. Fachkonzept - Hexadezimalsystem |
|
|
|
6. Exkurs - Andere Zahldarstellungen |
Binärdarstellung ,
ganze Zahl ,
Kommazahl ,
Gleitkommazahl ,
Fließkommazahl |
|
|
1. Einstieg - Ganze Zahlen |
|
|
|
2. Fachkonzept - Ganze Zahlen |
|
|
|
3. Einstieg - Kommazahlen |
|
|
|
4. Fachkonzept - Kommazahlen |
|
|
|
5. Übungen - Kommazahlen |
|
|
|
7. Übungen |
|
|
|
8. Überprüfung - Alles klar? |
|
|
|
3. Binärdarstellung von Zeichen |
Binärdarstellung ,
Zeichencodierung ,
ASCII ,
Unicode ,
UTF |
|
|
1. Einstieg - Gefängnisausbruch |
|
|
|
2. Fachkonzept - ASCII-Code |
|
|
|
3. Exkurs - ASCII-Code |
|
|
|
4. Exkurs - Experimente mit einem Hexeditor |
|
|
|
5. Exkurs - Zeichencodierung bei Webseiten |
|
|
|
6. Einstieg - Unicode |
|
|
|
7. Fachkonzept - Unicode |
|
|
|
8. Übungen |
|
|
|
4. Binärdarstellung von Bildern |
Binärdarstellung ,
Pixel ,
Grauwert ,
RGB ,
Farbcode ,
Grafikformat |
|
|
1. Einstieg - Pixel |
|
|
|
2. Einstieg - Schwarz-Weiß-Bilder |
|
|
|
3. Einstieg - Graustufenbilder |
|
|
|
4. Einstieg - Farbbilder |
|
|
|
5. Fachkonzept - Pixelgrafik |
|
|
|
6. Exkurs - Grafik-Formate |
|
|
|
7. Exkurs - PBM, PGM, PPM |
|
|
|
8. Vertiefung - Speicheraufwand |
|
|
|
9. Übungen |
|
|
|
10. Exkurs - Steganografie |
Binärdarstellung ,
Steganografie |
|
|
1. Einstieg - SW-Bilder in Graustufenbilder |
|
|
|
2. Fachkonzept - SW-Bilder in Graustufenbilder |
|
|
|
3. Vertiefung - SW-Bilder in Graustufenbilder |
|
|
|
4. Einstieg - Graustufenbilder in Graustufenbilder |
|
|
|
5. Fachkonzept - Graustufenbilder in Graustufenbilder |
|
|
|
6. Einstieg - Farbbilder in Farbbilder |
|
|
|
7. Fachkonzept - Farbbilder in Farbbilder |
|
|
|
3. Informationsdarstellung mit XML |
|
|
|
1. Darstellung von Information |
|
|
|
1. Fallstudie - Darstellung von Webseiten |
XML ,
HTML ,
Webseite ,
Auszeichnungssprache |
XML |
|
1. Erkundung - Darstellung von Webseiten |
|
|
|
2. Fachkonzept - HTML |
|
|
|
3. Exkurs: Texte auszeichnen |
|
|
|
2. Fallstudie - Darstellung von Grafiken |
XML ,
Vektorgrafik ,
SVG ,
Auszeichnungssprache |
XML |
|
1. Erkundung - Darstellung von Grafiken |
|
|
|
2. Fachkonzept - Vektorgrafik |
|
|
|
3. Lernstrecke SVG |
Information ,
Grafik ,
Vektorgrafik ,
Formale Sprache ,
Sprache |
SVG |
|
1. SVG-Grafik |
|
|
|
1. SVG-Grundgerüst |
|
|
|
2. Kreise |
|
|
|
3. Rechtecke |
|
|
|
4. Linien |
|
|
|
5. Text |
|
|
|
6. Polygone |
|
|
|
7. Das hast du hier gelernt |
|
|
|
4. Übungen |
|
|
|
3. Fallstudie - Darstellung von Musik |
XML ,
MusicXML ,
Auszeichnungssprache |
XML |
|
1. Erkundung - Darstellung von Musik |
|
|
|
2. Zusammenfassung - MusicXML |
|
|
|
3. Erkundung - die Sprache ABC |
|
|
|
4. Fallstudie - Darstellung von Routen |
XML ,
GPX ,
Auszeichnungssprache |
XML |
|
1. Erkundung - Darstellung von Routen |
XML ,
GPX ,
Auszeichnungssprache |
XML |
|
2. Zusammenfassung - GPX |
XML ,
GPX ,
Auszeichnungssprache |
XML |
|
5. Fallstudie - Darstellung von Geoinformation |
XML ,
Geoinformation ,
OSM ,
OpenStreetMap ,
Auszeichnungssprache |
XML |
|
1. Erkundung - Darstellung von Geoinformation |
|
|
|
2. Exkurs - OSM |
|
|
|
6. Fallstudie - 3D-Grafiken |
XML ,
3D ,
X3D ,
Auszeichnungssprache |
XML |
|
1. Einführung - X3D |
|
|
|
2. Hintergrund - X3D |
|
|
|
3. Elemente von X3D |
|
|
|
1. Grundstruktur |
|
|
|
2. Basisobjekte |
|
|
|
3. Oberflächen |
|
|
|
4. Transformationen |
|
|
|
5. Nebel |
|
|
|
6. Netze |
|
|
|
7. Licht und Sicht |
|
|
|
8. Definitionen |
|
|
|
9. Gruppen |
|
|
|
10. Sonstiges |
|
|
|
4. Komplexere Übungen |
|
|
|
7. Zusammenfassung - Darstellung von Information |
|
|
|
8. Übungen - Blick hinter die Kulissen |
|
|
|
2. XML-Dokumente |
Extensible Markup Language ,
Auszeichnungssprache ,
wohlgeformt |
XML |
|
1. Erkundung - XML-Dokumente |
|
|
|
2. Erkundung - XML-Dokumente selbst konzipieren |
|
|
|
3. Fachkonzept - XML |
|
|
|
4. Exkurs - XML |
|
|
|
5. Anwendung - FilmXML |
|
|
|
6. Anwendung - FussballXML |
|
|
|
7. Übungen |
|
|
|
3. XML-Dokumenttypen |
XML ,
Dokumenttyp ,
Validierung ,
Gültigkeit ,
Strukturbeschreibung ,
DTD ,
XML-Schema ,
XSD |
XML |
|
1. Erkundung - Fehler im XML-Dokument |
|
|
|
2. Erkundung - Dokumenttypdefinitionen |
|
|
|
3. Fachkonzept - Validierung von XML-Dokumenten |
|
|
|
4. Exkurs - Dokumenttypdefinitionen |
|
|
|
5. Anwendung - FilmXML |
|
|
|
6. Anwendung - FussballXML |
|
|
|
7. Übungen |
|
|
|
8. Miniprojekt - MyXHTML |
|
|
|
9. Ausblick - XML-Schema |
|
|
|
4. Verarbeitung von XML-Dokumenten |
XML ,
DOM ,
Document Object Model ,
Python ,
OOP |
XML ,
Python |
|
1. Erkundung - DOM-Baum |
|
|
|
2. Exkurs - Das Document Object Model (DOM) |
|
|
|
3. Anwendung - FussballXML |
|
|
|
4. Weitere Übungen |
|
|
|
5. Miniprojekt - Automatensimulator |
|
|
|
6. Anwendung - StammbaumXML |
|
|
|
5. XML-basierte Sprachen |
XML ,
Sprache ,
Lexik ,
Syntax ,
Semantik |
XML |
|
1. Fallstudie - DiagramML |
|
|
|
1. Station - Die Sprache DiagramML |
|
|
|
2. Station - Eine Grammatik für DiagramML |
|
|
|
3. Station - Ein Interpreter für DiagramML |
|
|
|
2. Fachkonzept - Sprache |
|
|
|
4. Markdown |
Markdown |
|
|
1. Überschriften und Formatierungen |
|
|
|
2. Listen |
|
|
|
3. Tabellen |
|
|
|
4. Bilder |
|
|
|
5. Hyperlinks |
|
|
|
6. Zitate, Codeblöcke, Fußnoten |
|
|
|
7. Diagramme |
|
|
|
8. Formeln mit $\LaTeX$ |
|
|
|
1. Latex als eigenständiges Programm |
|
|
|
9. Verwendung und Editoren |
|
|
|
5. Barcodes und QR-Codes |
Binärdarstellung ,
QR-Code ,
Barcode ,
Strichcode ,
GTIN ,
EAN |
|
|
1. Einstieg Barcodes |
|
|
|
2. Barcode-Prüfung |
|
|
|
3. Fachkonzept Barcodes |
|
|
|
4. Struktur von QR-Codes |
|
|
|
1. Inhalte von QR-Codes |
|
|
|
2. Fachkonzept - Struktur in QR-Codes |
|
|
|
3. Codierung von Worten |
|
|
|
5. Redundanzen in QR-Codes |
|
|
|
1. Wozu Redundanz |
|
|
|
2. Hamming-Codes |
|
|
|
6. Anwendung von Masken |
|
|
|
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. Ein Lösungsansatz |
|
|
|
3. Das Zufallssurfermodell |
|
|
|
4. Modellerweiterung |
|
|
|
5. Ein Ranking-Algorithmus |
|
|
|
6. Gesellschaftliche Bedeutung |
|
|
|
7. Exkurs: Google |
|
|
|
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 ,
Suche ,
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. Laufzeitverhalten |
|
|
|
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. Datenbank für Geodaten (terra) |
|
|
|
1. Relationale Datenbanken |
Datenbank ,
Tabelle ,
Datensatz ,
Attribut ,
Datentyp ,
Abfrage ,
Miniwelt |
SQL |
|
1. Ein Geoinformationssystem |
|
|
|
2. Fachkonzept - Relationale Datenbank |
|
|
|
3. Daten abfragen |
|
|
|
4. Fachkonzept - SQL |
|
|
|
5. Exkurs - Ausschnitt der realen Welt |
|
|
|
6. Übungen |
|
|
|
7. Das hast du hier gelernt |
|
|
|
2. Verknüpfen von Daten |
Datenbank ,
Primärschlüssel ,
Fremdschlüssel ,
Join |
SQL |
|
1. Einen Datensatz finden |
|
|
|
2. Fachkonzept - Schlüssel |
|
|
|
3. Fehler in den Daten |
|
|
|
4. Fachkonzept - Beziehungen zwischen Tabellen |
|
|
|
5. Daten aus zwei Tabellen auslesen |
|
|
|
6. Fachkonzept - SQL-Join |
|
|
|
7. Übungen |
|
|
|
8. Das hast du hier gelernt |
|
|
|
3. Verbessern der Ausgabe |
Datenbank ,
Funktion |
SQL |
|
1. Probleme der Ausgabe |
|
|
|
2. Fachkonzept - Verbessern der Ausgabe |
|
|
|
3. Exkurs - Funktionen in der Ausgabe |
|
|
|
4. Übungen |
|
|
|
4. Beziehungstabellen |
Datenbank ,
n:m-Beziehung ,
Nullwert |
SQL |
|
1. Flüsse speichern |
|
|
|
2. Fachkonzept - Beziehungstabelle |
|
|
|
3. Übungen |
|
|
|
4. Exkurs - Nullwerte und Wertebereich |
|
|
|
5. Das hast du hier gelernt |
|
|
|
5. Ergebnisse Zusammenfassen |
Datenbank ,
Aggregation ,
Gruppierung ,
Subselect |
SQL |
|
1. Statistische Daten |
|
|
|
2. Fachkonzept - Aggregation |
|
|
|
3. Exkurs - Subselect |
|
|
|
4. Übungen |
|
|
|
6. Beziehungen innerhalb von Tabellen |
Datenbank ,
reflexive Beziehung ,
Selbstreferenz |
SQL |
|
1. Verlauf eines Flusses |
|
|
|
2. Fachkonzept - Selbstreferenz |
|
|
|
3. Erweiterung von SQL |
|
|
|
4. Übungen |
|
|
|
7. Grenzen des terra-Modells |
Datenbank ,
Modell ,
Miniwelt |
|
|
1. Ozeane speichern |
|
|
|
2. Exkurs - SQLite Datenbank |
|
|
|
3. Exkurs - Tabelle erzeugen |
|
|
|
4. Exkurs - Daten automatisch erzeugen |
|
|
|
5. Landesteile |
|
|
|
6. Hauptstadt oder Hauptstädte? |
|
|
|
7. Fachkonzept |
|
|
|
8. Übungen |
|
|
|
2. Datenbank für Soz. Netzwerk (gbuch) |
|
|
|
1. Relationale Datenbanken |
Datenbank ,
Tabelle ,
Datensatz ,
Attribut ,
Datentyp ,
Abfrage |
SQL |
|
1. Einstieg - soziales Netzwerk |
|
|
|
2. Fachkonzept - Relationale Datenbank |
|
|
|
3. Einstieg - Datenbankabfrage |
|
|
|
4. Fachkonzept - SQL |
|
|
|
5. Exkurs - Nullwerte |
|
|
|
6. Übungen |
|
|
|
2. Verknüpfen von Daten |
Datenbank ,
Primärschlüssel ,
Fremdschlüssel ,
Join |
SQL |
|
1. Einstieg - Datensatz finden |
|
|
|
2. Fachkonzept - Schlüssel |
|
|
|
3. Einstieg - Daten zuordnen |
|
|
|
4. Fachkonzept - Beziehungen zwischen Tabellen |
|
|
|
5. Einstieg - Daten aus zwei Tabellen |
|
|
|
6. Fachkonzept - SQL-Join |
|
|
|
7. Übungen |
|
|
|
3. Verbessern der Ausgabe |
Datenbank ,
Funktion |
SQL |
|
1. Einstieg - Probleme der Ausgabe |
|
|
|
2. Fachkonzept - Verbessern der Ausgabe |
|
|
|
3. Exkurs - Funktionen in der Ausgabe |
|
|
|
4. Übungen |
|
|
|
4. Beziehungstabellen |
Datenbank ,
n:m-Beziehung ,
Nullwert |
SQL |
|
1. Einstieg - Gruppen speichern |
|
|
|
2. Fachkonzept - Beziehungstabelle |
|
|
|
3. Übungen |
|
|
|
5. Ergebnisse Zusammenfassen |
Datenbank ,
Aggregation ,
Gruppierung |
SQL |
|
1. Einstieg - Statistische Daten |
|
|
|
2. Fachkonzept - Aggregation |
|
|
|
3. Übungen |
|
|
|
6. Beziehungen innerhalb von Tabellen |
Datenbank ,
reflexive Beziehung ,
Selbstreferenz |
SQL |
|
1. Einstieg - Wer wirbt wen? |
|
|
|
2. Fachkonzept - Selbstreferenz |
|
|
|
3. Erweiterung von SQL |
|
|
|
4. Exkurs - Hierarchien speichern |
|
|
|
5. Exkurs - Datenbank-View |
|
|
|
6. Übungen |
|
|
|
7. Fehlende Join-Partner |
Datenbank ,
Outer Join |
SQL |
|
1. Einstieg - Benutzerübersicht |
|
|
|
2. Fachkonzept - Outer Join |
|
|
|
3. Übungen |
|
|
|
3. Entwurf von Datenbanken |
Datenbank ,
ER-Modell ,
Modellierung ,
Miniwelt ,
Entität ,
Beziehung ,
Kardinalität |
|
|
1. Einstieg - eine Schuldatenbank |
|
|
|
2. Die Miniwelt |
|
|
|
3. Entitätstypen |
|
|
|
4. Beziehungen |
|
|
|
5. Beziehungstypen |
|
|
|
6. Kardinalität |
|
|
|
7. Alles eindeutig? |
|
|
|
8. Relationales Datenmodell |
|
|
|
9. Andere Miniwelten |
|
|
|
4. Zugriff auf Datenbanken |
|
|
|
1. Installation einer Datenbank |
Datenbank ,
Informationssystem ,
Schichtenarchitektur ,
Client ,
Server |
|
|
1. Architektur eines Informationssystems |
|
|
|
2. Exkurs - Installation der Testumgebung |
|
|
|
3. Exkurs - elementarer Schutz |
|
|
|
4. Zugriff von anderen Rechnern |
|
|
|
2. Zugriffsrechte |
Datenbank ,
Zugriffsrechte |
SQL |
|
1. Einstieg - Schulverwaltungs-DB |
|
|
|
2. Beispiel - terra-DB |
|
|
|
3. Fachkonzept - Benutzer |
|
|
|
4. Übungen |
|
|
|
3. Datenbankzugriff mit Python |
Datenbank ,
Cursor |
SQL ,
Python |
|
1. Einstieg DB-Zugriff über Python |
|
|
|
2. Fachkonzept - Datenbankzugriff |
|
|
|
3. Fachkonzept - Cursor |
|
|
|
4. Exkurs - Fehlerbehandlung |
|
|
|
5. Übungen |
|
|
|
6. Projekt Kartendarstellung |
|
|
|
7. Erweiterung als Spiel |
|
|
|
4. Strukturen anlegen/verändern |
Datenbank ,
Tabelle ,
Datendefinition |
SQL |
|
1. Verwaltung einer Fahrschule |
|
|
|
2. Fachkonzept - Strukturen anlegen |
|
|
|
3. Übungen |
|
|
|
5. Daten anlegen/verändern |
Datenbank ,
Datenmanipulation ,
Schlüsselerzeugung ,
Primärschlüssel |
SQL |
|
1. Fahrschüler anlegen |
|
|
|
2. Fachkonzept - Daten anlegen |
|
|
|
3. Exkurs - Schlüssel erzeugen |
|
|
|
4. Exkurs - Gefahren bei Benutzereingaben |
|
|
|
5. Übungen |
|
|
|
5. Daten-Detektive |
Datenbank ,
Datenschutz ,
BigData ,
Gesellschaft ,
SQL ,
Aggregation ,
Gruppierung |
SQL |
|
1. Einstieg - Melderegister |
|
|
|
2. Mehr Daten - Zahlungsdaten |
|
|
|
3. Exkurs - Marketinganalyse |
|
|
|
4. Kombinieren der Datenquellen |
|
|
|
5. Erzeugen der Zuordnungstabelle |
|
|
|
6. Auswertung - Wohnort |
|
|
|
7. Exkurs - Nachbarorte |
|
|
|
8. Auswertung pro Karte |
|
|
|
9. Vergleich mit Haushalt |
|
|
|
10. Weitere Möglichkeiten |
|
|
|
6. SQLite |
SQLite |
|
|
1. DB Browser for SQLite |
|
|
|
2. Zugriff über Konsolenprogramm sqlite |
|
|
|
3. Zugriff auf SQLite-Dateien mit Python |
|
|
|
4. Konvertieren von SQL-Dateien in SQLite-Dateien |
|
|
|
1. Zustandsorientierte Modellierung |
Modellierung ,
Zustand ,
Automat |
|
|
1. Zustandsbasierte Modellierung mit Simulation im Browser |
System ,
Zustand |
|
|
1. Türsysteme |
System ,
Zustand |
|
|
1. System 1 |
System ,
Zustand |
|
|
2. System 2 |
System ,
Zustand |
|
|
3. System 3 |
System ,
Zustand |
|
|
4. System 4 |
System ,
Zustand |
|
|
5. Fachkonzept - Endlicher Automat |
System ,
Zustand |
|
|
6. System 4 - neu |
System ,
Zustand |
|
|
2. Übungen |
System ,
Zustand |
|
|
1. Kunstautomat |
System ,
Zustand |
|
|
2. Ampel |
System ,
Zustand |
|
|
3. Zahlenschloss |
System ,
Zustand |
|
|
4. Garagentor |
System ,
Zustand |
|
|
5. Türsystem |
System ,
Zustand |
|
|
6. Der Becher-Zurück-O-Mat (Rollenspiel) |
|
|
|
7. Kunstautomat - Python |
System ,
Zustand |
|
|
2. Systemmodellierung mit Zustandsdiagrammen |
Modellierung ,
Zustand ,
Automat |
Scratch |
|
1. Einführung - Zustandsdiagramme |
|
|
|
1. Ereignisgesteuerte Zustandsübergänge |
|
|
|
2. Bedingte Zustandsübergänge |
|
|
|
3. Zustände mit Aktionen und Aktivitäten |
|
|
|
4. Selbst definierte Ereignisse |
|
|
|
2. Fallstudie - Digitaluhr |
|
|
|
1. Das Verhalten modellieren |
|
|
|
2. Das Modell implementieren |
|
|
|
3. Fallstudie - Aufzug |
|
|
|
1. Ein einfacher Aufzug |
|
|
|
1. Das Verhalten erkunden |
|
|
|
2. Das Verhalten modellieren |
|
|
|
3. Das Modell implementieren |
|
|
|
2. Ein Aufzug mit Referenzfahrt |
|
|
|
1. Das Verhalten erkunden |
|
|
|
2. Das Verhalten modellieren |
|
|
|
3. Das Modell implementieren |
|
|
|
4. Fallstudie - Zeichenstift |
|
|
|
1. Das Verhalten erkunden |
|
|
|
2. Das Verhalten modellieren |
|
|
|
3. Das Modell implementieren |
|
|
|
5. Fallstudie - Autorennen |
|
|
|
1. Eine Rennstrecke befahren |
|
|
|
2. Das Auto modellieren |
|
|
|
3. Eine Ziellinie modellieren |
|
|
|
4. Eine Stoppuhr modellieren |
|
|
|
6. Übungen |
|
|
|
3. Zustandsbasierte Modellierung mit Mikrocontrollern |
|
|
|
1. Grundbegriffe |
|
|
|
1. Erkundung - Drei Systeme |
|
|
|
2. Erkundung - Zustandsdiagramm |
|
|
|
3. Fachkonzept - Zustandsbasiertes Modell und Zustandsdiagramm |
|
|
|
4. Übung - Modelle erweitern |
|
|
|
5. Übung - Modelle konstruieren |
|
|
|
6. Erkundung - Determinismus |
|
|
|
7. Fachkonzept - Determinismus |
|
|
|
2. Modellierungstechniken |
|
|
|
1. Erkundung - Sensorsteuerung |
|
|
|
2. Erkundung - Effektfreie Übergänge |
|
|
|
3. Erkundung - Sequenzen |
|
|
|
4. Erkundung - Dauerschleifen (und Priorität der Ereignisse) |
|
|
|
5. Erkundung - Zeitsteuerung |
|
|
|
6. Erkundung - Funksteuerung |
|
|
|
3. Modellierungsprojekte |
|
|
|
1. Projekt - Pomodoro-Uhr |
|
|
|
2. Projekt - Eierlaufen |
|
|
|
3. Projekt - Aufstehwecker |
|
|
|
4. Projekt - Kanon, aber über Oberammergau |
|
|
|
4. Spielwiese |
|
|
|
5. Ausblick |
|
|
|
4. Vertiefung - Simulation in Python |
|
|
|
1. Modellierung |
|
|
|
2. Implementierung |
|
|
|
3. Übungen |
|
|
|
2. Sprachen und Automaten |
|
|
|
1. Formale Sprachen |
|
|
|
1. Einführung - Sprache als Zeichensystem |
|
|
|
1. Kommunikation mit Zeichensystemen |
|
|
|
2. Syntax, Semantik, Pragmatik |
|
|
|
3. Sprachen in der Informatik |
|
|
|
2. Einführung - Formale Sprachen |
|
|
|
1. Beispiel - Römische Zahlen |
|
|
|
2. Beispiel - Chemische Verbindungen |
|
|
|
3. Fachkonzept - Formale Sprache |
|
|
|
4. Beispiel - Schach |
|
|
|
5. Beispiel - Ein Sprachenrätsel |
|
|
|
6. Übungen |
|
|
|
2. Sprachbeschreibung |
Modellierung ,
Zustand ,
Automat |
Sprache ,
formal ,
Syntaxdiagramm ,
Grammatik ,
regulärer Ausdruck |
|
1. Sprachbeschreibung mit Syntaxdiagrammen |
Sprache ,
Beschreibung ,
Syntaxdiagramm |
|
|
1. Beispiel - Turtle-Programme |
|
|
|
2. Beispiel - Rechenausdrücke |
|
|
|
3. Beispiel - Biber-Song-Contest |
|
|
|
4. Fachkonzept - Syntaxdiagramm |
|
|
|
5. Exkurs - Eine Sprache zur Beschreibung von Syntaxdiagrammen |
|
|
|
6. Übungen |
|
|
|
2. Sprachbeschreibung mit Grammatiken |
Sprache ,
Beschreibung ,
Grammatik |
|
|
1. Fallstudie - E-Mail-Adressen |
|
|
|
1. Validierung von E-Mail-Adressen |
|
|
|
2. Ein Blick in die RFC 822 |
|
|
|
3. Vereinfachte E-Mail-Adressen |
|
|
|
4. Eine Grammatik in erweiterter Backus-Naur-Form |
|
|
|
5. Eine Grammatik aus Produktionen |
|
|
|
6. Experimente mit JFlap |
|
|
|
2. Fallstudie - Zahlen |
|
|
|
1. Gleitkommazahlen in Python |
|
|
|
2. Ein Blick in die Grammatik von Python |
|
|
|
3. Grammatikregeln als Ersetzungsregeln |
|
|
|
4. Experimente mit dem Railroad Diagram Generator |
|
|
|
5. Experimente mit dem EBNF-Visualizer |
|
|
|
3. Fachkonzept - Grammatik |
|
|
|
4. Exkurs - Grammatik in erweiterter Backus-Naur-Form |
|
|
|
5. Exkurs - Alltagssprachen |
|
|
|
6. Übungen |
|
|
|
3. Sprachbeschreibung mit regulären Ausdrücken |
Sprache ,
Beschreibung ,
regulärer Ausdruck |
|
|
1. Fallstudie - Mustersuche |
|
|
|
1. Mustersuche in OpenOffice |
|
|
|
2. Mustersuche mit Python |
|
|
|
2. Exkurs - Regulärer Ausdrücke in der Praxis |
|
|
|
3. Fachkonzept - Regulärer Ausdruck |
|
|
|
4. Übungen |
|
|
|
3. Spracherkennung mit Automaten |
|
|
|
1. Spracherkennung mit endlichen Automaten |
Sprache ,
Erkennung ,
endlicher Automat |
|
|
1. Fallstudie - Zahlen |
|
|
|
1. Gleitkommazahlen in Python |
|
|
|
2. Spracherkennung mit der Brute-Force-Methode |
|
|
|
3. Ein zustandsbasiertes System zur Spracherkennung |
|
|
|
2. Fachkonzept - Endlicher Automat als Akzeptor |
|
|
|
3. Ausblick - Theoriebildung |
|
|
|
4. Übungen |
|
|
|
2. Endliche Automaten und reguläre Sprachen |
Sprache ,
Erkennung ,
regulär ,
endlicher Automat |
|
|
1. Fallstudie - Experimente mit JFlap |
|
|
|
1. Vom Automaten zur Grammatik |
|
|
|
2. Von der Grammatik zum Automaten |
|
|
|
3. Nichtdeterministische Automaten |
|
|
|
4. Vom regulären Ausdruck zum Automaten |
|
|
|
5. Vom Automaten zum regulären Ausdruck |
|
|
|
2. Fachkonzept - Reguläre Sprache |
|
|
|
3. Fachkonzept - Nichtdeterministischer Automat |
|
|
|
4. Theorie - Reguläre Sprachen und endliche Automaten |
|
|
|
5. Exkurs - Anwendung der Theorie |
|
|
|
6. Theorie - Reguläre Ausdrücke und endliche Automaten |
|
|
|
7. Exkurs - Aufwand bei der Spracherkennung |
|
|
|
8. Exkurs - Grenzen von endlichen Automaten |
|
|
|
9. Übungen |
|
|
|
3. Kellerautomat als Verarbeitungsmodell |
Sprache ,
Erkennung ,
Kellerautomat |
|
|
1. Fallstudie - Klammersprachen |
|
|
|
1. Beispiele für Klammersprachen |
|
|
|
2. Spracherkennung bei Klammersprachen |
|
|
|
3. Experimente mit JFlap |
|
|
|
2. Fachkonzept - Kellerautomat |
|
|
|
3. Ausblick - Theoriebildung |
|
|
|
4. Übungen |
|
|
|
4. Kellerautomaten und kontextfreie Sprachen |
Sprache ,
Erkennung ,
kontextfrei ,
Kellerautomat |
|
|
1. Fallstudie - Experimente mit JFlap |
|
|
|
1. Von der Grammatik zum Kellerautomaten |
|
|
|
2. Vom Kellerautomaten zur Grammatik |
|
|
|
3. Strategien zur Erzeugung von Kellerautomaten |
|
|
|
2. Fachkonzept - Kontextfreie Sprache |
|
|
|
3. Theorie - Kontextfreie Sprachen und Kellerautomaten |
|
|
|
4. Exkurs - Shift-Reduce-Parser |
|
|
|
5. Übungen |
|
|
|
5. Turingmaschine als Verarbeitungsmodell |
Sprache ,
Erkennung ,
Turingmaschine |
|
|
1. Erkundung - Turingmaschine |
|
|
|
2. Fachkonzept - Turingmaschine |
|
|
|
3. Exkurs - Bedeutung der Turingmaschine |
|
|
|
4. Übungen |
|
|
|
4. Sprachverarbeitung |
Sprache ,
Scanner ,
Parser ,
Interpreter |
Bonsai |
|
1. Station - Die Bonsai-Assemblersprache |
|
|
|
2. Station - Tokenerzeugung mit dem Scanner |
|
|
|
3. Station - Syntaxanalyse mit dem Parser |
|
|
|
4. Station - Erzeugung eines Strukturgerüsts mit dem Parser |
|
|
|
5. Station - Ein Interpreter für Bonsai-Assemblerprogramme |
|
|
|
3. Compiler und Interpreter |
Sprache ,
Scanner ,
Parser ,
Compiler ,
Interpreter |
Python |
|
1. Syntax und Semantik im Überblick |
|
|
|
1. Einstieg - Die Programmiersprache MyKa |
|
|
|
2. Exkurs - Die Programmiersprache MyKa |
|
|
|
3. Fachkonzept - Syntax |
|
|
|
4. Fachkonzept - Semantik |
|
|
|
2. Scanner und Parser im Überblick |
|
|
|
1. Einstieg - Die Programmiersprache MyKa |
|
|
|
2. Exkurs - MyKaList |
|
|
|
3. Fachkonzept - Scanner |
|
|
|
4. Fachkonzept - Parser |
|
|
|
3. Interpreter und Compiler im Überblick |
|
|
|
1. Einstieg - Die Programmiersprache MyKa |
|
|
|
2. Exkurs - MyKaGoto |
|
|
|
3. Fachkonzept - Interpreter |
|
|
|
4. Fachkonzept - Compiler |
|
|
|
4. Entwicklung eines Compilers - MyKa |
|
|
|
1. Station - Die Programmiersprache MyKa |
|
|
|
2. Station - LEX und YACC |
|
|
|
3. Station - Tokenerzeugung mit dem Scanner |
|
|
|
4. Station - Syntaxanalyse mit dem Parser |
|
|
|
5. Station - Erzeugung eines Strukturgerüsts mit dem Parser |
|
|
|
6. Station - Ein Interpreter für strukturierte MyKa-Programme |
|
|
|
7. Station - Ein Code-Erzeuger für strukturierte MyKa-Programme |
|
|
|
8. Station - Ein Code-Interpreter für strukturierte MyKaGoto-Programme |
|
|
|
9. Station - Simulationsprogramm zum Compiler |
|
|
|
5. Entwicklung eines Compilers - MyWhile |
|
|
|
1. Station - Die Programmiersprache MyWhile |
|
|
|
2. Station - LEX und YACC |
|
|
|
3. Station - Tokenerzeugung mit dem Scanner |
|
|
|
4. Station - Syntaxanalyse mit dem Parser |
|
|
|
5. Station - Erzeugung eines Strukturgerüsts mit dem Parser |
|
|
|
6. Station - Ein Interpreter für strukturierte MyWhile-Programme |
|
|
|
7. Station - Ein Code-Erzeuger für strukturierte MyWhile-Programme |
|
|
|
8. Station - Ein Code-Interpreter für strukturierte MyGoto-Programme |
|
|
|
9. Station - Simulationsprogramm zum Compiler |
|
|
|
6. Entwicklung eines Compilers - MiniPython |
|
|
|
1. Station - Die Programmiersprache MiniPython |
|
|
|
2. Station - LEX und YACC |
|
|
|
3. Station - Tokenerzeugung mit dem Scanner |
|
|
|
4. Station - Syntaxanalyse mit dem Parser |
|
|
|
5. Station - Erzeugung eines Strukturgerüsts mit dem Parser |
|
|
|
6. Station - Ein Interpreter für strukturierte MiniPython-Programme |
|
|
|
7. Station - Ein Code-Erzeuger für strukturierte MiniPython-Programme |
|
|
|
8. Station - Ein Code-Interpreter für Assemblerprogramme |
|
|
|
9. Station - Simulationsprogramm zum Compiler |
|
|
|
1. Imperative Programmierung mit Python-Spacebug |
Anweisung ,
Sequenz ,
Spacebug ,
Python ,
Programmierung |
PythonSpacebug |
|
1. Anweisungen und Sequenzen |
Anweisung ,
Sequenz ,
Spacebug ,
Python ,
Programmierung |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Strukturierung |
|
|
|
3. Fachkonzept |
|
|
|
4. Übungen |
|
|
|
5. Vertiefung und Vernetzung |
|
|
|
2. Wiederholungen |
Schleife ,
Spacebug ,
Python ,
Programmierung |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Strukturierung |
|
|
|
3. Fachkonzept |
|
|
|
4. Übungen |
|
|
|
5. Vertiefung und Vernetzung |
|
|
|
3. Fallunterscheidungen |
Fallunterscheidung ,
Spacebug ,
Python ,
Programmierung |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Strukturierung |
|
|
|
3. Fachkonzept |
|
|
|
4. Übungen |
|
|
|
5. Vertiefung und Vernetzung |
|
|
|
4. Unterprogramme |
Unterprogramm ,
Spacebug ,
Python ,
Programmierung |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Strukturierung |
|
|
|
3. Fachkonzept |
|
|
|
4. Übungen |
|
|
|
5. Vertiefung und Vernetzung |
|
|
|
5. Variablen |
Variable ,
Spacebug ,
Python ,
Programmierung |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Strukturierung |
|
|
|
3. Fachkonzept |
|
|
|
4. Übungen |
|
|
|
5. Vertiefung und Vernetzung |
|
|
|
6. Vertiefungen |
|
|
|
1. Zählschleifen |
Spacebug ,
Python ,
Programmierung ,
Schleife |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Fachkonzept |
|
|
|
3. Übungen |
|
|
|
2. EVA-Prinzip |
|
|
|
1. Erkundung |
|
|
|
2. Fachkonzept |
|
|
|
3. Übungen |
|
|
|
3. Zeichenketten |
Spacebug ,
Python ,
Programmierung ,
Zeichenkette |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Fachkonzept |
|
|
|
3. Übungen |
|
|
|
4. Parameter |
Spacebug ,
Python ,
Programmierung ,
Parameter ,
Funktion ,
Unterprogramm |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Fachkonzept |
|
|
|
3. Übungen |
|
|
|
5. Funktionen |
Spacebug ,
Python ,
Programmierung ,
Rückgabewert ,
Funktion ,
Unterprogramm |
PythonSpacebug |
|
1. Erkundung |
|
|
|
2. Fachkonzept |
|
|
|
3. Übungen |
|
|
|
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 |
Programmierung ,
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 |
|
|
|
5. Jupyter-Notebook |
Jupyter-Notebook |
|
|
1. Online Version (Lab) |
|
|
|
2. Online Version (Notebook) |
|
|
|
3. Offline Version (JupyterLab-Desktop) |
|
|
|
4. Grundlagen Jupyter |
|
|
|
1. Aufgaben (Markdown-Latex-Python) |
|
|
|
2. Aufgaben (Jupyter) |
|
|
|
3. Aufgaben (Matplotlib) |
|
|
|
5. Exkurs: Jupyter-Notebook als CAS |
|
|
|
1. CAS-Programme |
|
|
|
6. Exkurs: Lokale Installation als Webserver |
|
|
|
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. Go Home als Programm |
|
|
|
4. Fachkonzept - Referenzen |
|
|
|
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 |
|
|
|
1. Warum funktional programmieren? |
|
|
|
2. Online Programmieren |
|
|
|
3. Lokale Installation |
|
|
|
4. REPL |
|
|
|
5. Mögliche Wege durch das Kapitel |
|
|
|
2. Programmierung mit Elm |
|
|
|
1. Daten und ihre Verarbeitung |
|
|
|
1. Wandtattoos |
|
|
|
1. Berechnungen in der REPL |
|
|
|
2. Kostenberechnung |
|
|
|
2. Int und Float |
|
|
|
1. Zwei Typen von Zahlen |
|
|
|
2. Rechenoperationen |
|
|
|
3. Typumwandlungen |
|
|
|
4. Vordefinierte Funktionen |
|
|
|
3. Verschlüsselung |
|
|
|
1. Caesar-Verfahren in der REPL |
|
|
|
2. Umkehrverfahren in der REPL |
|
|
|
3. Rückblick und Ausblick |
|
|
|
4. Char und String |
|
|
|
1. Zeichen und Zeichenketten |
|
|
|
2. Vordefinierte Funktionen zur Verarbeitung von Zeichen |
|
|
|
3. Vordefinierte Funktionen zur Verarbeitung von Zeichenketten |
|
|
|
5. Schaltjahre |
|
|
|
1. Schaltjahre berechnen |
|
|
|
2. Experimente in der REPL |
|
|
|
6. Bool |
|
|
|
1. Wahrheitswerte |
|
|
|
2. Logische Operatoren |
|
|
|
3. Vordefinierte boolsche Funktionen |
|
|
|
7. Vertiefung - Operatorrangfolge |
|
|
|
8. Fachkonzept - Datentyp |
|
|
|
9. Fachkonzept - Vordefinierte Funktion |
|
|
|
10. Fachkonzept - Ausdruck |
|
|
|
11. Übungen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
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. Elm-Projekte |
|
|
|
1. Projekt erzeugen |
|
|
|
2. Online-REPL |
|
|
|
3. Kommentare |
|
|
|
3. Fachkonzept - Funktion |
|
|
|
4. Fachkonzept - Konstante |
|
|
|
5. Fachkonzept - REPL und Projekte |
|
|
|
6. Übungen |
|
|
|
3. Listen und Zeichenketten |
|
|
|
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. Fachkonzept - Liste |
|
|
|
4. Fachkonzept - Funktion höherer Ordnung |
|
|
|
5. Übungen |
|
|
|
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. Fachkonzept - let-Ausdrücke |
|
|
|
3. Fachkonzept - Pipe-Operator |
|
|
|
4. Übungen |
|
|
|
5. Fallunterscheidungen |
|
|
|
1. Beispiel - Eintrittspreise |
|
|
|
1. Problemsituation |
|
|
|
1. Eine Fallunterscheidung |
|
|
|
2. Geschachtelte Fallunterscheidungen |
|
|
|
3. Mehrfachauswahl mit einem Musterabgleich |
|
|
|
2. Fachkonzept - Fallunterscheidung |
|
|
|
3. Fachkonzept - Musterabgleich |
|
|
|
4. Übungen |
|
|
|
6. Erzeugung von Funktionen |
|
|
|
1. Anonyme Funktionen |
|
|
|
1. Funktionen mit Namen |
|
|
|
1. Funktionen ohne Namen |
|
|
|
2. Partiell angewandte Funktionen |
|
|
|
1. Partielle Funktionsanwendung |
|
|
|
1. Iterierte Funktionsanwendung |
|
|
|
3. Komposition von Funktionen |
|
|
|
1. Der Pipe-Operator |
|
|
|
1. Der Kompositionsoperator |
|
|
|
4. Fachkonzept - anonyme Funktion |
|
|
|
5. Fachkonzept - Currying |
|
|
|
6. Fachkonzept - Funktionskomposition |
|
|
|
7. Übungen |
|
|
|
7. Verarbeitung von Datensätzen |
|
|
|
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. Fachkonzept - Datensatz als Record |
|
|
|
4. Fachkonzept - Datensatz als Tupel |
|
|
|
5. Übungen |
|
|
|
8. Erzeugung von Datentypen |
|
|
|
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. Fachkonzept - Typdefinition |
|
|
|
4. Übungen |
|
|
|
9. Fehlerbehandlung |
|
|
|
1. Beispiel - Benutzereingaben |
|
|
|
1. Problemsituation |
|
|
|
1. Implementierungsvorschlag |
|
|
|
2. Umwandlung von Zahlen |
|
|
|
3. Der Datentyp Maybe |
|
|
|
4. Verbesserte Funktion |
|
|
|
2. Fachkonzept - Fehlerbehandlung |
|
|
|
3. Übungen |
|
|
|
10. Rekursion |
|
|
|
1. Beispiel - Türme von Hanoi |
|
|
|
1. Problemsituation |
|
|
|
1. Lösung für kleine Türme |
|
|
|
2. Allgemeine Strategie |
|
|
|
3. Implementierung in Elm |
|
|
|
4. Zusammenfassung |
|
|
|
2. Beispiel - Begrüßungen |
|
|
|
1. Problemsituation |
|
|
|
1. Beispielrechnungen |
|
|
|
2. Verallgemeinerung |
|
|
|
3. Aufwandsbetrachtung |
|
|
|
4. Endrekursion |
|
|
|
3. Beispiel - Eigene map-Funktion |
|
|
|
1. Problemsituation |
|
|
|
1. Problempräzisierung |
|
|
|
2. Mustererkennung |
|
|
|
3. Implementierung von map |
|
|
|
4. Verschlüsselung |
|
|
|
4. Beispiel - Wege im Gitternetz |
|
|
|
1. Problemsituation |
|
|
|
1. Problempräzisierung |
|
|
|
2. Problemreduktion |
|
|
|
3. Rekursive Funktion |
|
|
|
4. Aufwandsbetrachtung |
|
|
|
5. Alternative Berechnungen |
|
|
|
5. Fachkonzept - Rekursion |
|
|
|
6. Fachkonzept - Endrekursion |
|
|
|
7. Übungen - Verarbeitung von Zahlen |
|
|
|
8. Übungen - Verarbeitung von Zeichenketten |
|
|
|
3. Dynamische Webseiten mit Elm |
|
|
|
1. Hallo Elm |
|
|
|
1. HTML-Grundlagen |
|
|
|
2. Hallo Elm - online |
|
|
|
1. ellie-app.com |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
2. Analyse |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Tipps |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Hallo Elm - lokal |
|
|
|
1. elm init |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
2. elm make |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Hot reloading |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
4. Übungen |
|
|
|
2. Morsecode |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
1. Elementknoten |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
2. Listen von Knoten |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Mehrere Elementknoten |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
4. Morsecode berechnen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
5. view-Funktion |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
6. Datentypen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
7. Verarbeitung von Listen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
8. Übungen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Notenliste |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
1. Einzelnote |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
2. Gesamtliste |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Auswertung |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
4. Übungen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
4. Sportergebnisse |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
1. Datenstruktur |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
2. Grundstruktur |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Tabellendarstellung |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
4. Auswertung |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
5. Übungen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
5. Caesar |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
1. Elm - Architektur |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
2. TEA - Implementierung |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
3. Texteingabe |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
4. Erweiterungen |
Programmierung ,
funktional ,
Modellierung |
Elm |
|
5. Übungen |
|
|
|
6. Nim-Spiel |
|
|
|
1. Model |
|
|
|
2. View |
|
|
|
3. Update |
|
|
|
4. Erweiterungen |
|
|
|
7. Umgang mit Fehlern |
|
|
|
8. Zufall |
|
|
|
9. Subscriptions |
|
|
|
10. Flags |
|
|
|
4. Nachwort |
|
|
|
3. Logische Programmierung |
logisch ,
Programmierung ,
Modellierung |
Prolog |
|
1. Modellierung von Wissen |
Fakten ,
Regel ,
Anfrage ,
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 ,
Term ,
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 |
Graph ,
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. Experimente am Computer |
Kryptologie ,
Kommunikation ,
Kryptographie ,
asymmetrisch ,
Schlüssel |
|
|
6. Fachkonzept - Asymmetrische Chiffriersysteme |
|
|
|
7. Ein Einblick ins RSA-Verfahren |
Kryptologie ,
Kommunikation ,
Kryptographie ,
asymmetrisch ,
Schlüssel ,
RSA |
|
Cryptool ,
GnuPG |
1. Die Einwegfunktion hinter RSA |
|
|
|
2. RSA-Demo |
|
|
Cryptool |
3. Exkurs - Experimente mit CrypTool |
|
|
|
4. Exkurs - Experimente mit GnuPG |
|
|
|
5. Exkurs - Experimente mit GnuPG / Kleopatra |
|
|
|
8. Exkurs - Hybride Chiffriersysteme |
Kryptologie ,
Kommunikation ,
Kryptographie ,
asymmetrisch ,
symmetrisch ,
RSA ,
AES |
|
Cryptool |
9. Exkurs - Sicherheit von Chiffriersystemen |
|
|
|
10. 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 (RSA) |
|
|
|
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 |
|
|
|
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 - Machine 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 ,
Tor-Browser |
|
|
1. Protokolle Webseiten |
|
|
|
1. http |
|
|
|
2. https |
|
|
|
2. Aufbau des TOR-Netzes |
Tor-Circuit |
|
|
1. Software |
Tor-Browser |
|
|
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 |
|
|
|
11. Passwörter - Theorie und Praxis |
Passwort |
Python |
|
1. Passwörter |
|
|
|
2. Passphrasen |
Passphrasen |
|
|
3. Entropie von Passwörtern |
Entropie |
|
|
4. Zufallspasswörter und Passwortmanager |
Passwort-Manager ,
Zufallspasswörter |
|
|
5. Vertrauensvolle Speicherung von Passwort-Dateien |
Salt ,
Pepper |
|
|
6. Zweifaktor-Authentifizierung (2FA) |
Zweifaktor-Authentifizierung ,
2FA ,
One-Time-Password ,
OTP ,
TOTP ,
HMAC |
Python |
|
1. Zählerbasierte Einmalpasswörter |
|
|
|
2. HMAC-based One-time Password (HOTP) |
|
|
|
3. Zeitbasierte Einmalpasswörter |
|
|
|
4. Time-based One-time Password (TOTP) |
|
|
|
5. TOTP als 2FA |
|
|
|
7. Mögliche Fallstricke |
|
|
|
12. Schlüsseltausch mit elliptischen Kurven |
Elliptische Kurven ,
ECC |
|
|
1. Erkundung elliptische Kurven |
|
|
|
2. Schlüsseltausch nach Diffie-Hellman |
|
|
|
3. Addition von Punkten auf elliptischen Kurven |
|
|
|
4. Multiplikation von Punkten mit natürlichen Zahlen |
|
|
|
5. Gruppengesetze |
|
|
|
6. Einwegfunktion |
|
|
|
7. Schlüsseltausch mit elliptischen Kurven |
|
|
|
8. Exkurs: Endliche Körper |
|
|
|
9. Literatur und Links |
|
|
|
1. Blog |
|
|
|
2. Themencafé |
|
|
|
3. Konzept |
|
|
|
1. inf-schule als Schulbuch |
|
|
|
2. Didaktische Struktur |
|
|
|
1. Orientierungen |
|
|
|
2. Alternative Didaktisierungen |
|
|
|
3. Lehr-/Lernkonzept |
|
|
|
1. Problemorientiertes Lernen |
|
|
|
2. Bausteine zum Lernen |
|
|
|
1. Initiieren |
|
|
|
2. Erkunden |
|
|
|
3. Strukturieren |
|
|
|
4. Üben |
|
|
|
5. Überprüfen |
|
|
|
4. Offenes Konzept |
|
|
|
5. Infrastruktur |
|
|
|
6. Evolutionäre Entwicklung |
|
|
|
7. Webbasierte Technologien |
|
|
|
1. inf-schule in Kombination mit einer Lernplattform |
|
|
|
8. Multimediale Darstellung mit Interaktionsmöglichkeiten |
|
|
|
9. Datenhaltung und Seitenerzeugung |
|
|
|
1. Für das Schulbuch schreiben |
|
|
|
2. Schulbuchentwicklung im Team |
|
|
|
3. Reduktion des Aufwands von AutorInnen bei Interaktivität |
|
|
|
4. Seitenaufruf durch das System |
|
|
|
10. Ausblick und Perspektive |
|
|
|
4. Lehrpläne |
|
|
|
0. IPS - Klasse 5 |
|
|
|
1. Wahl(pflicht)fach Informatik |
|
|
|
2. Grundfach Informatik |
|
|
|
1. Ohne vorangegangenes Wahlfach |
|
|
|
2. Objects first mit Java |
|
|
|
5. Archiv |
|
|
|
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. Berufspraxis |
|
|
|
1. Projekte des Modellunternehmens |
|
|
|
1. Was sind Projekte? |
|
|
|
2. Das Modellunternehmen |
|
|
|
3. Projekte und Arbeitsaufträge |
|
|
|
1. Test-PC bauen und einrichten |
|
|
|
1. Situation |
|
|
|
2. Dokumentation des Zusammenbaus |
|
|
|
3. Aufgaben |
|
|
|
2. Internetpräsenz verbessern |
|
|
|
1. Digitale Bildbearbeitung |
|
|
|
1. Situation |
|
|
|
2. Material |
|
|
|
3. Aufgaben |
|
|
|
2. Aktuelle Website verbessern |
|
|
|
1. Situation |
|
|
|
2. Material |
|
|
|
3. Aufgaben |
|
|
|
4. Lösung |
|
|
|
3. Website-Relaunch mit einem CMS |
|
|
|
1. Projektmanagement |
|
|
|
2. Vorgehensmodelle |
|
|
|
3. Projektantrag |
|
|
|
4. Soll-Konzept und Projektstrukturplan |
|
|
|
5. Testumgebung einrichten |
|
|
|
6. Realisierung, Test und Abnahme |
|
|
|
2. Betriebliche Datenbanken |
|
|
|
1. Aufgabenstellung |
|
|
|
2. ER-Modellierung |
|
|
|
3. Relationale DB einrichten |
|
|
|
4. Datenbankabfragen: Relationale Algebra |
|
|
|
5. Datenbankabfragen: SQL |
|
|
|
6. Mercatus-Datenbank: GUI |
|
|
|
7. Änderungswünsche |
|
|
|
3. Internetrecherche |
|
|
|
1. Google und Wikipedia |
|
|
|
2. Suchdienste und Datenmissbrauch |
|
|
|
3. Suchmaschinen |
|
|
|
4. Kataloge und Metasuchmaschinen |
|
|
|
5. Digitale- und virtuelle Bibliotheken |
|
|
|
4. Tabellenkalkulation |
|
|
|
1. Grundlagen |
|
|
|
2. Einfache Berechnungen |
|
|
|
3. Ansichten und Druck |
|
|
|
4. Zellen und Adressierungsarten |
|
|
|
5. Diagramme |
|
|
|
6. Logische Funktionen |
|
|
|
7. Suchfunktionen |
|
|
|
8. Zusammenfassende Aufgabe |
|
|
|
3. Informationsdarstellung im Internet |
|
|
|
1. World Wide Web |
WWW ,
Hyperlink ,
Hypertext ,
URL ,
Webseite |
|
|
1. Einstieg - WWW |
|
|
|
2. Fachkonzept - World Wide Web |
|
|
|
3. Übungen |
|
|
|
2. Strukturbeschreibung mit HTML |
HTML ,
Hypertext ,
Element ,
Attribut ,
Auszeichnungssprache |
HTML |
|
1. Einstieg - Blick hinter die Kulissen |
|
|
|
2. Fachkonzept - HTML |
|
|
|
3. Miniprojekt - Steckbrief |
|
|
|
4. Exkurs - HTML |
HTML ,
Element ,
Attribut ,
Tag ,
Überschrift ,
Tabelle ,
Liste |
HTML |
|
1. Gerüst aus Kopf und Körper |
|
|
|
2. Kopfangaben |
|
|
|
3. Überschriften und Absätze |
|
|
|
4. Listen |
|
|
|
5. Tabellen |
|
|
|
6. Verweise |
|
|
|
7. Bilder |
|
|
|
8. Hervorhebungen |
|
|
|
9. Audio- und Videodateien |
|
|
|
5. Fachkonzept - Elementstruktur |
|
|
|
6. Übungen |
|
|
|
7. Überprüfung - Alles klar? |
|
|
|
3. Validierung von Webseiten |
HTML ,
Validierung ,
Gültigkeit |
HTML |
|
1. Einstieg - Fehler im Quelltext |
|
|
|
2. Einstieg - Experimente mit einem Validierer |
|
|
|
3. Einstieg - HTML-Versionen |
|
|
|
4. Fachkonzept - Validierung |
|
|
|
5. Übungen |
|
|
|
6. Hinweise |
|
|
|
4. Formatierung mit CSS |
HTML ,
CSS ,
Formatierung ,
Layout ,
Regel ,
Selektor |
|
|
1. Einstieg - Layout gestalten |
|
|
|
2. Exkurs - CSS |
|
|
|
1. CSS-Regeln |
|
|
|
2. Selektoren |
|
|
|
3. Schrift und Farbe |
|
|
|
4. Validierung |
|
|
|
3. Übungen |
|
|
|
4. Fachkonzept - Trennung Strukturierung/Formatierung |
|
|
|
5. Barrierefreiheit |
HTML ,
Barrierefrei ,
Gleichstellung |
HTML |
|
1. Einstieg - Webseiten anders wahrnehmen |
|
|
|
2. Fachkonzept - Barrierefreiheit |
|
|
|
6. Rechtliches |
Recht ,
Urheberrecht ,
Persönlichkeitsrecht ,
Markenrecht ,
Haftung ,
Abmahnung |
|
|
1. Einstieg - Rechtsfälle |
|
|
|
2. Fachkonzept - Rechtliche Bestimmungen |
|
|
|
3. Übungen |
|
|
|
7. Persönliches |
Datenschutz |
|
|
1. Einstieg - Spuren im Internet |
|
|
|
2. Exkurs - Persönliche Daten im Internet |
|
|
|
8. Globale Auswirkungen |
|
|
|
9. Hinweise |
|
|
|
4. Algorithmisches Problemlösen mit Spacebug (endet im Sommer 24) |
|
|
|
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 |
|
|
|
5. Überwachtes maschinelles Lernen mit Neuronalen Netzen (ohne numpy) |
|
|
|
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 |
|
|
|
7. XOR-Problem |
|
|
|
8. Mehrlagige Perzeptrone |
|
|
|
9. Mehrlagige Perzeptrone in Python |
|
|
|
10. Fehler-Rückleitung |
|
|
|
11. Fehler-Rückleitung in Python |
|
|
|
6. Lösungen |
|
|
|