Klasse 11 (Basisfach)

Um negative Zahlen in Informatik darzustellen, werden spezielle Verfahren wie das Einer- und Zweierkomplement genutzt, die es ermöglichen, Vorzeichen und Betrag in einer einzigen Binärzahl zu kodieren. Beim **Einerkomplement** wird jede positive Zahl invertiert (Bits werden umgedreht), um ihren negativen Gegenwert zu erhalten, wobei jedoch eine Besonderheit bei der Null auftritt, da sie zwei Darstellungen besitzt (+0 und -0). Das **Zweierkomplement** löst dieses Problem, indem es zum invertierten Wert noch eine 1 addiert, wodurch eine eindeutige Darstellung entsteht und Rechenoperationen einfacher durchführbar sind. Schüler müssen verstehen, wie diese Verfahren funktionieren, welche Vor- und Nachteile sie haben und wie man Zahlen zwischen den Darstellungen umwandelt. Zudem sollten sie in der Lage sein, die Ergebnisse zu interpretieren, etwa bei der Addition zweier Zahlen im Zweierkomplement, um Überläufe oder korrekte Ergebnisse zu erkennen.

Um Binärzahlen in Zweierkomplementdarstellung schriftlich zu addieren oder zu subtrahieren, musst du zunächst verstehen, dass diese Darstellung negative Zahlen durch eine festgelegte Bitstruktur codiert – das höchste Bit (Vorzeichenbit) gibt an, ob es sich um eine positive oder negative Zahl handelt. Für die Addition und Subtraktion gelten dieselben Regeln wie bei normalen Binärzahlen, allerdings musst du auf Überläufe achten, die bei der Verarbeitung der Vorzeichenbits entstehen können. Wichtig ist, dass du die Bitlänge des Ergebnisses beachtest, da durch das Zweierkomplement eine feste Anzahl von Bits vorgegeben ist und Überläufe oder Unterläufe zu falschen Interpretationen führen können. Zudem solltest du wissen, wie man das Zweierkomplement einer Zahl bildet, um Subtraktionen in Additionen umzuwandeln.

In der Informatik führt die begrenzte Stellenzahl in der Binärdarstellung von Zahlen zu konkreten Problemen, weil Computer nur eine feste Anzahl an Bits (z. B. 8, 16 oder 32) für die Speicherung verwenden. Dadurch können Ergebnisse von Rechenoperationen entweder zu groß werden, um dargestellt zu werden – man spricht dann von einem *Overflow* –, oder sie verlieren an Genauigkeit, weil Nachkommastellen abgeschnitten oder gerundet werden müssen. Um diese Einschränkungen zu verstehen, musst du wissen, wie ganze Zahlen (*Integer*) und Gleitkommazahlen (*Floating-Point*) im Binärsystem codiert werden, etwa im *Zweierkomplement* für negative Zahlen oder im *IEEE-754-Standard* für Dezimalbrüche. Praktisch bedeutet das, dass du berechnen können musst, wann ein Overflow auftritt (z. B. bei der Addition zweier großer Zahlen) oder wie sich Rundungsfehler bei wiederholten Operationen auswirken. Zudem solltest du erkennen, wie Programmiersprachen oder Hardware mit solchen Fehlern umgehen – etwa durch automatische Typumwandlung oder Fehlermeldungen.

Um Codes in der Informatik zu verstehen, musst du zunächst wissen, dass sie Informationen in binäre Folgen (Bits) umwandeln, wobei bestimmte Eigenschaften entscheidend sind. Ein Code ist **umkehrbar**, wenn sich die ursprüngliche Information aus dem Code eindeutig rekonstruieren lässt – das ist essenziell, um Daten fehlerfrei zu decodieren, etwa bei Kompression oder Fehlerkorrektur. **Präfixfreiheit** bedeutet, dass kein Codewort Anfang eines anderen ist, was die Dekodierung ohne Trennzeichen ermöglicht, wie bei Huffman-Codes in der Datenkompression. Zudem spielt die **Bitlänge** eine Rolle: Bei **fester Bitlänge** haben alle Codewörter die gleiche Länge (z. B. ASCII mit 8 Bit), während **variable Bitlänge** effizienter ist, wenn häufige Symbole kürzere Codes erhalten (z. B. Morsezeichen). Du solltest also erkennen können, wann ein Code diese Merkmale erfüllt, und verstehen, warum sie für die Verarbeitung und Übertragung von Daten wichtig sind.

Das Lernziel bedeutet, dass ihr verstehen sollt, wie das Huffmanverfahren funktioniert – ein Verfahren, das Daten ohne Informationsverlust komprimiert, indem es häufige Zeichen mit kürzeren Codes darstellt und seltene mit längeren. Dafür müsst ihr zunächst wissen, wie ein Huffmanbaum aufgebaut wird: Ausgehend von den Häufigkeiten der Zeichen werden diese schrittweise zu einem binären Baum kombiniert, wobei die häufigsten Zeichen näher an der Wurzel landen. Anschließend sollt ihr in der Lage sein, diesen Baum zu nutzen, um die ursprünglichen Zeichen in eine binäre Zeichenfolge zu codieren – also eine Abbildung von Symbolen auf Bitfolgen vorzunehmen. Umgekehrt müsst ihr auch die Decodierung beherrschen: Aus der komprimierten Bitfolge und dem Huffmanbaum die ursprünglichen Daten rekonstruieren können, indem ihr den Baum von der Wurzel zu den Blättern durchlauft. Praktisch bedeutet das, dass ihr sowohl die theoretische Grundlage als auch die handwerkliche Umsetzung des Verfahrens nachvollziehen könnt.

Um dieses Lernziel zu erreichen, müssen Schüler verstehen, wie eine einfach verkettete Liste funktioniert: Jedes Element enthält nicht nur seinen Wert, sondern auch einen Verweis auf das nächste Element in der Liste. Sie sollten die Grundoperationen wie das Einfügen eines Elements am Anfang, Ende oder an einer bestimmten Position sowie das Löschen eines Elements durch Anpassung der Verweise korrekt umsetzen können. Dazu gehört auch, die Vor- und Nachteile dieser Datenstruktur im Vergleich zu anderen linearen Strukturen wie Arrays zu kennen, etwa die dynamische Größe bei Listen gegenüber der festen Größe von Arrays. Praktisch bedeutet das, dass sie in einer Programmiersprache wie Python oder Java eine solche Liste selbst programmieren und die Operationen fehlerfrei anwenden können. Wichtig ist zudem, die Laufzeitkomplexität der Operationen zu verstehen, etwa dass Einfügen und Löschen am Listenanfang in O(1) erfolgen, während das Durchsuchen der Liste O(n) benötigt.

Um Binärbäume als Datenstruktur zu implementieren, müssen Sie zunächst verstehen, dass es sich um eine hierarchische Struktur handelt, bei der jeder Knoten höchstens zwei Nachfolger (linkes und rechtes Kind) besitzt. Dazu gehört es, die grundlegenden Operationen wie Einfügen, Suchen und Durchlaufen (z. B. inorder, preorder oder postorder) nicht nur theoretisch zu kennen, sondern auch praktisch in einer Programmiersprache umzusetzen. Sie benötigen Kenntnisse über Rekursion, da viele Baumoperationen natürlich rekursiv definiert sind, sowie ein solides Verständnis von Zeigern oder Referenzen, um die Verbindungen zwischen den Knoten zu verwalten. Zudem sollten Sie mit den Eigenschaften von Binärbäumen vertraut sein, etwa der Balance oder der Höhe, um effiziente Implementierungen zu gewährleisten. Praktische Erfahrung mit der Fehlerbehebung – etwa bei der Handhabung von Randfällen wie leeren Bäumen oder doppelten Werten – rundet die Vorbereitung ab.

Graphen sind grundlegende Strukturen in der Informatik, die Beziehungen zwischen Objekten modellieren – etwa Netzwerke, soziale Verbindungen oder Datenflüsse. Um sie zu beschreiben, lernst du zwei zentrale Repräsentationsformen kennen: die **Adjazenzmatrix**, die die Verbindungen zwischen Knoten in einer quadratischen Tabelle speichert, und die **Adjazenzliste**, die für jeden Knoten eine Liste seiner Nachbarn führt. Beide Darstellungen haben Vor- und Nachteile: Die Matrix ist effizient für dichte Graphen und einfache Abfragen, während die Liste bei dünn besetzten Graphen Speicher spart und das Durchlaufen der Nachbarn beschleunigt. Du solltest verstehen, wie man beide Formen aus einem gegebenen Graphen ableitet und wann welche Darstellung sinnvoll ist. Praktisch bedeutet das, dass du Graphen nicht nur zeichnen, sondern auch formal in Datenstrukturen überführen kannst, um sie später algorithmisch zu verarbeiten.

Graphen sind zentrale Datenstrukturen in der Informatik, mit denen sich Beziehungen zwischen Objekten modellieren lassen – etwa Netzwerke, Abhängigkeiten oder Pfade. Um sie zu verstehen und anzuwenden, musst du zunächst die Grundbausteine kennen: Knoten (auch *Vertices* genannt) repräsentieren die Objekte, während Kanten (*Edges*) die Verbindungen zwischen ihnen darstellen. Wichtig ist auch der *Knotengrad*, der angibt, wie viele Kanten an einem Knoten anliegen, sowie die Unterscheidung zwischen gerichteten und ungerichteten Graphen – bei gerichteten Graphen haben Kanten eine klare Richtung, bei ungerichteten sind sie symmetrisch. Zudem solltest du wissen, wann ein Graph *gewicht*et ist (Kanten haben numerische Werte, z. B. Kosten oder Distanzen) oder *ungewichtet*, und ob er *zyklisch* (enthält geschlossene Pfade) oder *azyklisch* (keine Kreise) ist. Diese Eigenschaften bestimmen, welche Algorithmen – etwa zur Pfadfindung oder Netzwerkanalyse – auf den Graphen anwendbar sind.

Ein Stack (oder Stapel) ist ein abstrakter Datentyp, der Daten nach dem **LIFO-Prinzip** (Last In, First Out) verwaltet: Das zuletzt hinzugefügte Element wird als Erstes wieder entfernt. Um einen Stack zu verstehen und anzuwenden, musst du seine beiden grundlegenden Operationen kennen – **push** (Element hinzufügen) und **pop** (oberstes Element entfernen) – sowie die damit verbundenen Eigenschaften wie die **Top-Operation** (Zugriff auf das oberste Element ohne Entfernen). Praktisch bedeutet das, dass du nachvollziehen kannst, wie der Stack Daten organisiert und wie sich diese Struktur auf Algorithmen auswirkt, etwa bei der Klammerprüfung oder der Rekursion. Wichtig ist auch, die Grenzen des ADT zu verstehen: Ein Stack erlaubt keinen direkten Zugriff auf mittlere Elemente, sondern nur auf das oberste.

Ein **Abstrakter Datentyp (ADT)** wie die **Queue** (Warteschlange) beschreibt ein logisches Konzept, das festlegt, *was* eine Datenstruktur leisten soll – nicht, *wie* sie technisch umgesetzt wird. Für die Queue bedeutet das konkret, dass sie nach dem **FIFO-Prinzip** (First-In-First-Out) arbeitet: Das erste Element, das eingefügt wird, ist auch das erste, das wieder entfernt wird, ähnlich wie bei einer Warteschlange an der Supermarktkasse. Schüler müssen verstehen, dass eine Queue zwei grundlegende Operationen unterstützt: **Enqueue** zum Hinzufügen eines Elements am Ende und **Dequeue** zum Entfernen des vordersten Elements – wobei die Queue dabei ihre innere Struktur dynamisch anpasst. Praktisch relevant ist das etwa bei der Verwaltung von Aufgaben in Betriebssystemen, der Pufferung von Datenströmen oder der Simulation von Prozessen, wo die Reihenfolge der Verarbeitung entscheidend ist. Um das Konzept anzuwenden, sollten sie in der Lage sein, eine Queue in Pseudocode oder einer Programmiersprache zu implementieren – sei es mit einer Liste, einem Array oder einer verketteten Struktur – und die Operationen korrekt zu nutzen.

Mit diesem Lernziel geht es darum, den Aufbau und die Funktionsweise eines relationalen Datenbanksystems zu verstehen – also nicht nur zu wissen, dass es Daten speichert, sondern wie die einzelnen Komponenten zusammenarbeiten und welche Aufgaben sie übernehmen. Konkret müsst ihr die drei Hauptbestandteile kennen: die eigentliche **Datenbank** als physischen oder logischen Speicherort für die strukturierten Daten, das **Datenbankverwaltungssystem (DBMS)** als Software, die den Zugriff regelt, Konsistenz prüft und Operationen wie Abfragen oder Änderungen durchführt, sowie die **Datenbankschnittstelle**, über die Nutzer oder Anwendungen mit dem System kommunizieren – etwa durch SQL-Befehle oder grafische Tools. Dabei solltet ihr nachvollziehen können, warum das DBMS als zentrale Instanz fungiert: Es trennt die Datenhaltung von der Anwendung, verwaltet Zugriffsrechte und sorgt dafür, dass selbst bei komplexen Abfragen oder gleichzeitigem Nutzerzugriff keine Fehler entstehen. Praktisch bedeutet das, dass ihr nicht nur die Begriffe benennen, sondern auch erklären könnt, wie etwa eine SELECT-Abfrage vom DBMS verarbeitet wird oder welche Rolle Transaktionen für die Datenintegrität spielen.

Das Lernziel bedeutet, dass ihr verstehen müsst, wie Daten in relationalen Datenbanksystemen strukturiert und organisiert werden. Dazu gehört, dass ihr Entitäten – also konkrete Objekte oder Begriffe wie „Kunde“ oder „Bestellung“ – als Entitätstypen klassifiziert und deren Eigenschaften durch Attribute wie „Name“ oder „Datum“ beschreibt. Ihr sollt erkennen, wie diese Entitäten über Relationen (Beziehungen) miteinander verknüpft sind, etwa eine „Kunde bestellt Produkt“-Beziehung, und wie diese Beziehungen durch Kardinalitäten (z. B. 1:1, 1:n oder m:n) präzise definiert werden. Praktisch bedeutet das, dass ihr Daten in Tabellen abbilden könnt, wobei jede Zeile einen Datensatz (eine konkrete Instanz) und jede Spalte ein Datenfeld (ein Attribut) darstellt. Ihr müsst also nicht nur die Begriffe kennen, sondern auch ihre Zusammenhänge verstehen, um einfache Datenbankmodelle zu entwerfen oder zu interpretieren.

Um das Lernziel zu erreichen, müssen Sie verstehen, dass Schlüssel in relationalen Datenbanksystemen eine zentrale Rolle spielen, weil sie Datensätze eindeutig identifizieren oder Beziehungen zwischen Tabellen herstellen. Ein **Primärschlüssel** ist dabei ein Attribut oder eine Attributkombination, die jeden Datensatz in einer Tabelle eindeutig bestimmt und keine doppelten oder leeren Werte zulässt – oft wird dafür eine automatisch generierte ID verwendet. Ein **Fremdschlüssel** hingegen verweist auf einen Primärschlüssel in einer anderen Tabelle und stellt so die logische Verknüpfung zwischen den Tabellen her, etwa wenn eine Bestellung einem Kunden zugeordnet wird. Sie sollten erkennen, dass diese Schlüssel nicht nur die Datenintegrität sichern, sondern auch die Grundlage für Abfragen und Joins bilden, um Informationen aus verschiedenen Tabellen zu kombinieren. Praktisch bedeutet das, dass Sie in der Lage sein müssen, in einem gegebenen Datenbankmodell Primär- und Fremdschlüssel zu erkennen, ihre Funktion zu erklären und selbst sinnvolle Schlüssel für neue Tabellen zu entwerfen.

Um die Realität in einem Datenbankmodell abzubilden, müssen Schüler zunächst verstehen, wie sich komplexe Zusammenhänge in einzelne Entitäten (z. B. Personen, Objekte oder Ereignisse) und deren Beziehungen zueinander zerlegen lassen. Dafür benötigen sie die Fähigkeit, relevante Attribute zu identifizieren, die diese Entitäten beschreiben, sowie die Art der Beziehungen zwischen ihnen zu analysieren – etwa ob es sich um 1:1-, 1:n- oder n:m-Verknüpfungen handelt. Zudem müssen sie lernen, diese Strukturen in einem Entity-Relationship-Diagramm (ERD) oder UML-Klassendiagramm grafisch darzustellen, wobei sie Symbole wie Rechtecke für Entitäten, Rauten für Beziehungen und Linien mit Kardinalitäten für die Verknüpfungen korrekt anwenden. Wichtig ist auch, dass sie erkennen, welche Informationen in der Realität redundant wären und wie sich diese durch Normalisierung in einer relationalen Datenbank vermeiden lassen. Schließlich sollten sie verstehen, dass ein solches Modell nicht statisch ist, sondern sich weiterentwickeln kann, wenn sich die Anforderungen an die Datenbank ändern.

Um ein relationales Datenbankschema in die 3. Normalform (3NF) zu überführen, müssen Schüler zunächst verstehen, dass Redundanzen – also doppelt gespeicherte Informationen – zu Inkonsistenzen führen können, wenn Daten an einer Stelle geändert werden, aber nicht an anderen. Dafür benötigen sie Kenntnisse über funktionale Abhängigkeiten: Sie müssen erkennen, welche Attribute von anderen abhängen und wann diese Abhängigkeiten transitiv sind, also wenn ein Attribut indirekt über ein drittes von einem Schlüssel abhängt. Praktisch bedeutet das, dass sie Tabellen so strukturieren müssen, dass jedes Nicht-Schlüsselattribut nur vom gesamten Primärschlüssel abhängt und nicht von Teilen des Schlüssels oder von anderen Nicht-Schlüsselattributen. Dazu gehört auch, Schlüsselkandidaten zu identifizieren und zu entscheiden, ob ein Attribut als Fremdschlüssel in eine andere Tabelle ausgelagert werden muss. Schließlich müssen sie die Normalisierungsregeln anwenden können, um schrittweise von der 1. über die 2. zur 3. Normalform zu gelangen und so ein effizientes, konsistentes Datenmodell zu erstellen.

Um dieses Lernziel zu erreichen, müssen Sie verstehen, wie relationale Datenbankschemata – also die Struktur einer Datenbank mit Tabellen, Attributen und Beziehungen – in grafische Darstellungen wie Entity-Relationship-Diagramme (ER-Diagramme) übertragen werden können und umgekehrt. Dazu gehört, dass Sie die Grundkonzepte von Entitäten, Attributen, Primär- und Fremdschlüsseln sowie die verschiedenen Beziehungstypen (1:1, 1:n, n:m) sicher erkennen und anwenden können. Wichtig ist auch, dass Sie die Notation von ER-Diagrammen beherrschen, etwa wie Entitäten als Rechtecke, Attribute als Ovale und Beziehungen als Rauten dargestellt werden, sowie die Regeln für die Umsetzung in relationale Schemata kennen. Zudem sollten Sie in der Lage sein, Kardinalitäten und optionale/obligatorische Partizipationen korrekt zu interpretieren und in beide Richtungen – vom Schema zum Diagramm und umgekehrt – zu übersetzen. Praktische Übungen helfen dabei, diese Abstraktion zwischen abstrakter Modellierung und konkreter Implementierung zu verinnerlichen.

Mit diesem Lernziel geht es darum, dass ihr lernt, wie man ein Datenbankverwaltungssystem (DBMS) wie MySQL, PostgreSQL oder SQLite praktisch einsetzt, um eigene Datenbanken zu erstellen, zu strukturieren und zu verwalten. Dazu gehört, Tabellen mit passenden Datentypen und Beziehungen (z. B. Primär- und Fremdschlüssel) anzulegen, Abfragen mit SQL zu formulieren und die Datenintegrität durch Constraints wie `NOT NULL` oder `UNIQUE` zu sichern. Ihr sollt verstehen, wie man Benutzerrechte verwaltet, Backups erstellt und grundlegende Optimierungen vornimmt, um die Performance zu verbessern. Praktisch bedeutet das, dass ihr selbstständig eine Datenbank für ein konkretes Szenario – etwa ein Schulverwaltungssystem oder ein Online-Shop – entwerft und mit echten Daten füllt. Wichtig ist dabei, dass ihr die theoretischen Konzepte aus dem relationalen Modell (wie Normalisierung oder Joins) in der Praxis anwendet und nachvollziehen könnt, warum bestimmte Design-Entscheidungen sinnvoll sind.

Um dieses Lernziel zu erreichen, müssen Schüler verstehen, wie man in SQL gezielt Daten aus relationalen Datenbanken abfragt – etwa durch **Projektion** (Spaltenauswahl mit `SELECT`), **Selektion** (Zeilenfilterung mit `WHERE`) oder **Verbundoperationen** (Zusammenführen von Tabellen über Schlüssel). Sie sollten in der Lage sein, Abfragen über mehrere Tabellen zu formulieren, indem sie logische Bedingungen in der `WHERE`-Klausel nutzen oder explizite Joins einsetzen, um Beziehungen zwischen Entitäten wie Kunden und Bestellungen herzustellen. Wichtig ist dabei, die Struktur der Datenbank (Tabellen, Attribute, Fremdschlüssel) zu kennen und zu erkennen, wie diese über Bedingungen verknüpft werden. Zudem müssen sie verstehen, wie SQL-Anweisungen aufgebaut sind und welche Auswirkungen Filter oder Verbunde auf das Ergebnis haben – etwa bei der Vermeidung von Redundanzen oder der korrekten Verknüpfung von Datensätzen. Praktisch bedeutet das, dass sie selbstständig komplexere Abfragen schreiben können, die mehrere dieser Konzepte kombinieren, um gezielt Informationen aus einem relationalen Modell zu extrahieren.

Mit diesem Lernziel geht es darum, dass ihr lernt, wie man in einer relationalen Datenbank nicht nur Daten abfragt, sondern sie auch gezielt verändert – also neue Einträge hinzufügt, bestehende aktualisiert oder überflüssige löscht. Dafür müsst ihr die grundlegenden SQL-Befehle `INSERT`, `UPDATE` und `DELETE` beherrschen, die jeweils unterschiedliche Operationen auf Tabellen ausführen: `INSERT` fügt neue Zeilen ein, `UPDATE` ändert vorhandene Werte in bestimmten Spalten, und `DELETE` entfernt ganze Zeilen nach bestimmten Bedingungen. Wichtig ist dabei, dass ihr versteht, wie diese Befehle mit den Tabellenstrukturen (Primärschlüssel, Fremdschlüssel, Constraints) zusammenhängen, um Fehler wie doppelte Einträge oder Verletzungen der Datenintegrität zu vermeiden. Zudem solltet ihr wissen, wie man diese Manipulationen gezielt steuert – etwa durch `WHERE`-Klauseln, die festlegen, welche Zeilen betroffen sind, oder durch Transaktionen, die mehrere Änderungen als Einheit sichern. Praktische Übungen mit echten Datenbanken helfen euch, ein Gefühl für die Auswirkungen dieser Befehle zu entwickeln und sie sicher anzuwenden.

Um dieses Lernziel zu erreichen, müssen Schüler verstehen, wie Daten in Programmen organisiert und verwaltet werden. Dazu gehört, dass sie den Unterschied zwischen einem Bezeichner (dem Namen einer Variable) und ihrem Datentyp (z. B. ganze Zahl, Text oder Wahrheitswert) kennen, da dieser bestimmt, welche Operationen mit der Variable möglich sind. Sie sollten wissen, dass eine Variable erst deklariert werden muss, bevor sie genutzt wird, und dass sie bei der Initialisierung einen Anfangswert erhält – oder später durch eine Wertzuweisung verändert werden kann. Wichtig ist auch, dass sie den Gültigkeitsbereich einer Variable verstehen, also wo im Programmcode sie überhaupt angesprochen werden darf, um Fehler zu vermeiden. Ohne dieses Grundwissen können selbst einfache Programme nicht korrekt strukturiert oder später objektorientiert erweitert werden.

In diesem Lernziel geht es darum, dass ihr versteht, wie Computer unterschiedliche Arten von Daten speichern und verarbeiten – konkret ganze Zahlen, Kommazahlen und Wahrheitswerte. Ihr müsst wissen, welche Datentypen es dafür gibt (z. B. `int`, `float`, `double` oder `bool` in vielen Programmiersprachen) und wie sich diese in ihrem Wertebereich unterscheiden, etwa dass ein `int` in Java nur Zahlen bis 2³¹–1 darstellen kann, während ein `long` größere Werte zulässt. Wichtig ist auch, dass ihr erkennt, wann ihr welchen Typ einsetzt: Ganze Zahlen für Zählungen, Gleitkommazahlen für Messwerte und boolesche Werte für logische Entscheidungen wie Bedingungen in `if`-Anweisungen. Praktisch bedeutet das, dass ihr diese Typen bewusst in Programmen verwendet, um Fehler durch Überläufe oder falsche Genauigkeit zu vermeiden. Zudem solltet ihr verstehen, warum die Wahl des richtigen Datentyps die Effizienz und Korrektheit eures Codes beeinflusst.

In der Informatik geht es darum, Werte zwischen verschiedenen Datentypen umzuwandeln, wenn sie in einem Programm kombiniert oder verarbeitet werden sollen – etwa wenn eine ganze Zahl als Gleitkommazahl dargestellt oder ein Text in eine Zahl umgewandelt werden muss. Dafür gibt es zwei grundlegende Methoden: die *explizite* Typumwandlung, bei der der Programmierer die Konvertierung mit einem sogenannten *Type Cast* (z. B. `(int)3.7` oder `float("5")`) direkt anweist, und die *implizite*, bei der der Compiler oder Interpreter die Umwandlung automatisch vornimmt, wenn die Datentypen kompatibel sind oder keine Daten verloren gehen. Um dieses Lernziel zu erreichen, müsst ihr verstehen, wann welche Methode sinnvoll ist, welche Risiken – wie Genauigkeitsverluste oder Fehler – damit verbunden sind und wie ihr in eurem Code solche Situationen gezielt steuert, etwa durch Überprüfung der Wertebereiche oder die Verwendung von Hilfsfunktionen. Praktisch bedeutet das, dass ihr nicht nur die Syntax von Type Casts beherrschen, sondern auch deren Auswirkungen auf die Programmausführung einschätzen könnt, etwa wenn eine Division zweier ganzer Zahlen plötzlich eine Gleitkommazahl ergibt oder ein String nicht in eine Zahl umgewandelt werden kann.

Um dieses Lernziel zu erreichen, müssen Schüler zunächst verstehen, wie man in einer Programmiersprache Zeichenketten (Strings) manipuliert, etwa durch Verknüpfung (Verketten) mit dem `+` Operator oder Methoden wie `concat()`. Dazu gehört auch, dass sie wissen, wie Strings in Objekten gespeichert werden und welche Eigenschaften sie haben, etwa Unveränderlichkeit (Immutabilität) in vielen Sprachen. Gleichzeitig müssen sie die Grundprinzipien der objektorientierten Programmierung (OOP) anwenden können, also Klassen und Objekte erkennen, Methodenaufrufe auf Strings wie `substring()` oder `toUpperCase()` verstehen und selbst einfache Klassen mit Attributen und Methoden entwerfen. Wichtig ist dabei, dass sie den Unterschied zwischen strukturierter und objektorientierter Herangehensweise begreifen – etwa, dass OOP Daten und zugehörige Operationen in einem Objekt kapselt, während strukturierte Programmierung oft mit Funktionen arbeitet. Praktisch bedeutet das, dass sie sowohl einfache String-Operationen in Code umsetzen als auch eigene Klassen mit String-Attributen und passenden Methoden implementieren können.

Um dieses Lernziel zu erreichen, müssen Schüler verstehen, wie man eigene Klassen definiert – also Baupläne für Objekte erstellt, die Daten (Attribute) und Funktionen (Methoden) enthalten. Dazu gehört, dass sie wissen, wie man Attribute mit Datentypen deklariert und Methoden mit Parametern und Rückgabewerten entwirft, die auf diesen Attributen operieren. Wichtig ist auch, den Unterschied zwischen Klassen- und Instanzattributen zu kennen sowie den Zugriff auf Attribute über die `this`-Referenz oder Punktnotation zu beherrschen. Praktisch müssen sie in der Lage sein, Klassen in einem Programm zu instanziieren, ihre Methoden aufzurufen und die Interaktion zwischen Objekten zu steuern. Zudem sollten sie grundlegende Konzepte wie Sichtbarkeit (public/private) und Kapselung kennen, um Daten gezielt zu schützen und kontrolliert zu verarbeiten.

In diesem Lernziel geht es darum, den grundlegenden Unterschied zwischen primitiven Datentypen und Referenztypen in der Programmierung zu verstehen. Primitivtypen wie `int`, `boolean` oder `char` speichern direkt Werte und sind effizient für einfache Daten, während Referenztypen – etwa Objekte oder Arrays – auf Speicheradressen verweisen und komplexere Strukturen abbilden. Du solltest wissen, dass primitive Variablen ihre Daten direkt im Speicher halten, Referenzvariablen aber nur eine „Adresse“ auf den eigentlichen Wert speichern, was Speicherverwaltung und Performance beeinflusst. Praktisch bedeutet das, dass du bei Referenztypen mit Methoden wie `new` arbeiten musst, um Speicher zu reservieren, während primitive Typen direkt deklariert werden. Ein zentraler Punkt ist auch, dass Änderungen an Referenzvariablen sich auf alle referenzierten Instanzen auswirken können, während primitive Variablen unabhängig bleiben.

Um dieses Lernziel zu erreichen, müssen Schülerinnen und Schüler verstehen, wie Methoden in der Programmierung funktionieren – also wie man Codeblöcke definiert, die bestimmte Aufgaben erfüllen. Dazu gehört, Methoden sowohl mit als auch ohne Rückgabewert zu schreiben, etwa wenn eine Methode nur eine Aktion ausführt (ohne Rückgabe) oder ein Ergebnis liefert (mit Rückgabe). Gleichzeitig lernen sie, Methoden mit und ohne Parameter zu nutzen, um flexibel auf unterschiedliche Eingaben reagieren zu können. Ein zentraler Begriff ist die Methodensignatur, die aus Methodennamen, Parametertypen und Rückgabetyp besteht und festlegt, wie eine Methode aufgerufen werden muss. Praktisch bedeutet das, dass Schülerinnen und Schüler in der Lage sein sollten, solche Methoden selbst zu implementieren und ihre Funktionsweise in Programmen gezielt einzusetzen.

Mit den Zugriffsmodifikatoren *public*, *private* und *protected* steuerst du, von wo aus auf Attribute und Methoden eines Objekts oder einer Klasse zugegriffen werden darf – das ist zentral für die Kapselung in der objektorientierten Programmierung. Du musst verstehen, dass *public* den uneingeschränkten Zugriff von überall erlaubt, während *private* die Nutzung auf die eigene Klasse beschränkt und *protected* zusätzlich Unterklassen den Zugriff ermöglicht. Praktisch bedeutet das, dass du mit diesen Modifikatoren die Sichtbarkeit von Code-Elementen gezielt einschränkst, um unerwünschte Änderungen zu verhindern und die Datenintegrität zu sichern. Gleichzeitig solltest du wissen, wie diese Modifikatoren in der Praxis eingesetzt werden, etwa um Getter- und Setter-Methoden für kontrollierte Zugriffe auf private Attribute zu definieren. Ohne dieses Wissen kannst du Klassen nicht sicher strukturieren oder saubere Schnittstellen für andere Entwickler erstellen.

Das Lernziel bedeutet, dass ihr versteht, wie man in der objektorientierten Programmierung Daten (Attribute) und Funktionen (Methoden) in einer Klasse so zusammenfasst, dass sie nur über definierte Schnittstellen (Zugriffsmethoden) nutzbar sind – das nennt man Kapselung. Ihr müsst also lernen, warum es sinnvoll ist, Attribute als *privat* zu deklarieren und stattdessen öffentliche Methoden wie *getter* und *setter* bereitzustellen, um kontrolliert auf diese Daten zuzugreifen. Dabei geht es darum, unerwünschte Manipulationen zu verhindern und die Stabilität des Programms zu erhöhen. Praktisch bedeutet das, dass ihr in euren eigenen Klassen Attribute zunächst versteckt und dann gezielt Zugriffsmöglichkeiten schafft, um die Datenintegrität zu wahren. Zusätzlich sollt ihr verstehen, dass dieses Prinzip nicht nur die Sicherheit, sondern auch die Wartbarkeit und Erweiterbarkeit von Code verbessert.

Um ein Objekt in der objektorientierten Programmierung zu erzeugen, wird eine Klasse als Bauplan genutzt, und der Konstruktor ist die Methode, die diesen Prozess steuert. Er sorgt dafür, dass ein neues Objekt mit den richtigen Anfangswerten initialisiert wird, etwa indem er Attribute setzt oder Ressourcen reserviert. Schüler müssen verstehen, dass Konstruktoren denselben Namen wie die Klasse tragen und optional Parameter für die Übergabe von Startwerten akzeptieren können. Praktisch bedeutet das, dass sie in der Lage sein sollten, Konstruktoren zu definieren, zu überladen und gezielt aufzurufen, um Objekte korrekt zu instanziieren. Zudem ist es wichtig zu erkennen, dass ein Standardkonstruktor ohne Parameter oft automatisch bereitgestellt wird, sofern kein eigener definiert ist.

Um das Lernziel zu erreichen, müssen Schülerinnen und Schüler verstehen, dass Vererbung ein zentrales Konzept der objektorientierten Programmierung ist, mit dem Klassen ihre Eigenschaften und Methoden an untergeordnete Klassen weitergeben können. Dazu gehört, dass sie den Unterschied zwischen Ober- und Unterklassen erkennen und wissen, wie man durch Vererbung Redundanzen im Code vermeidet und die Wiederverwendbarkeit von Programmteilen erhöht. Praktisch bedeutet das, dass sie in der Lage sein müssen, Vererbungshierarchien zu modellieren – etwa durch UML-Klassendiagramme – und diese anschließend in einer Programmiersprache wie Java oder Python umzusetzen. Zudem sollten sie die Begriffe *extends* (Java) oder *Vererbung* (Python) sowie die Rolle von *protected*- und *public*-Sichtbarkeitsmodifizierern kennen, um Zugriffsrechte korrekt zu steuern. Nicht zuletzt müssen sie verstehen, dass Vererbung nicht nur Code spart, sondern auch die logische Struktur eines Programms klarer macht, indem sie Gemeinsamkeiten zwischen Klassen systematisch abbildet.

Um dieses Lernziel zu erreichen, müssen Schülerinnen und Schüler zunächst verstehen, dass Algorithmen – also präzise Handlungsanweisungen zur Lösung eines Problems – in verschiedenen Notationen dargestellt werden können, die jeweils unterschiedliche Vorteile bieten. Beim Nassi-Shneiderman-Diagramm handelt es sich um eine grafische Darstellungsform, die den Ablauf eines Algorithmus in klar abgegrenzte Strukturen wie Sequenzen, Verzweigungen und Schleifen unterteilt und so die Übersichtlichkeit fördert, während Pseudocode eine textbasierte, halbformale Schreibweise nutzt, die näher an der späteren Implementierung in einer Programmiersprache liegt, aber dennoch unabhängig von einer konkreten Syntax bleibt. Beide Notationen erfordern die Fähigkeit, logische Zusammenhänge zu erkennen und in strukturierte Abläufe zu übersetzen, etwa durch das korrekte Anwenden von Bedingungen, Schleifen oder Variablenmanipulationen. Zudem müssen Schüler verstehen, wie sich diese Darstellungen gegenseitig ergänzen: Während das Nassi-Shneiderman-Diagramm besonders für die visuelle Analyse komplexer Kontrollstrukturen geeignet ist, ermöglicht Pseudocode eine kompaktere und flexiblere Formulierung von Algorithmen, die später direkt in Code überführt werden kann. Praktisch bedeutet das, dass sie nicht nur vorgegebene Darstellungen interpretieren, sondern auch selbst Algorithmen in beide Notationen übertragen können müssen, um ihre Problemlösungsfähigkeiten zu trainieren.

Um dieses Lernziel zu erreichen, müssen Schülerinnen und Schüler verstehen, wie man mit UML-Klassendiagrammen die Struktur eines Programms modelliert, indem man Klassen, ihre Attribute, Methoden und Beziehungen zueinander abbildet. Dazu gehört insbesondere, Vererbung als zentrales Konzept der objektorientierten Programmierung darzustellen – etwa durch Generalisierungsspezialisierungsbeziehungen zwischen Ober- und Unterklassen – sowie Assoziationen, die zeigen, wie Objekte miteinander interagieren, auch rekursiv, wenn eine Klasse sich selbst referenziert. Praktisch bedeutet das, dass sie eigenständig Diagramme entwerfen können, die nicht nur statische Hierarchien, sondern auch dynamische Abhängigkeiten zwischen Objekten abbilden, etwa in komplexen Datenstrukturen wie Bäumen oder Graphen. Entscheidend ist dabei, dass sie die Semantik der Notation (z. B. Pfeile, Multiplizitäten, Rollennamen) korrekt anwenden und die modellierten Zusammenhänge später in Code umsetzen können. Ohne dieses Verständnis lassen sich größere Softwareprojekte nicht systematisch planen oder warten.

Dieses Lernziel bedeutet, dass ihr lernt, euren Programmcode so zu schreiben, dass er nicht nur von euch selbst, sondern auch von anderen Entwicklern verstanden werden kann – heute oder in Zukunft. Dazu gehört, dass ihr euch an gängige Kommentierungsstandards haltet, etwa durch präzise Erklärungen zu Klassen, Methoden oder komplexen Algorithmen, die nicht sofort aus dem Code ersichtlich sind. Gleichzeitig sollt ihr die Hilfsmittel eurer Entwicklungsumgebung (IDE) nutzen, wie etwa automatische Dokumentationsgeneratoren oder Code-Analyse-Tools, um eure Kommentare konsistent und hilfreich zu gestalten. Wichtig ist auch, dass ihr versteht, wann Kommentare sinnvoll sind – etwa bei ungewöhnlichen Lösungsansätzen oder Schnittstellen – und wann sie überflüssig wären, weil der Code selbsterklärend ist. Am Ende geht es darum, sauberen, wartbaren Code zu schreiben, der auch in Teamarbeit funktioniert.

Um Quellcode und Bibliotheken effektiv zu nutzen, müssen Schülerinnen und Schüler zunächst verstehen, wie man technische Dokumentationen liest und interpretiert. Dazu gehört, dass sie die Bedeutung von Klassen, Methoden und Attributen in objektorientiertem Code erkennen und deren Zusammenhänge nachvollziehen können, etwa durch UML-Diagramme oder Kommentare im Quelltext. Gleichzeitig sollten sie wissen, wie man in strukturierten Programmen Funktionen, Schleifen und Datenstrukturen einsetzt, um vorgegebene Aufgaben zu lösen. Praktisch bedeutet das, dass sie in der Lage sein müssen, aus Dokumentationen die richtigen Parameter für Methodenaufrufe abzuleiten oder Bibliotheksfunktionen gezielt auszuwählen, ohne den gesamten Implementierungscode verstehen zu müssen. Wichtig ist auch, dass sie erkennen, wann sie auf externe Bibliotheken zurückgreifen können, statt selbst Code zu schreiben – etwa bei komplexen Algorithmen oder Standardfunktionen wie Sortierverfahren.

Um das Lernziel zu erreichen, müssen Schüler verstehen, wie die lineare Suche funktioniert und warum sie auf verschiedenen Datenstrukturen unterschiedlich effizient ist. Dazu gehört, dass sie Arrays und verkettete Listen als grundlegende Datenstrukturen kennen und deren Eigenschaften – wie direkter Zugriff bei Arrays versus sequenzieller Verknüpfung bei Listen – vergleichen können. Praktisch müssen sie in der Lage sein, eine Suchfunktion zu implementieren, die ein gegebenes Element in einer Schleife durchläuft und bei Erfolg dessen Position zurückgibt oder eine entsprechende Rückmeldung liefert. Wichtig ist auch, dass sie die Zeitkomplexität der linearen Suche (O(n)) verstehen und erkennen, wann diese Methode sinnvoll eingesetzt wird. Schließlich sollten sie die Implementierung in einer Programmiersprache wie Python oder Java umsetzen können, um das Konzept anwendungsbezogen zu vertiefen.

Um die binäre Suche auf sortierten Arrays implementieren zu können, musst du zunächst verstehen, dass es sich um einen effizienten Suchalgorithmus handelt, der auf dem Prinzip der **Teilung und Eroberung** (*Divide and Conquer*) beruht. Dafür ist es essenziell, dass du die Grundlagen von Arrays – also geordneten Datensammlungen mit direktem Zugriff über Indizes – sicher beherrschst und weißt, warum die Eingabedaten **sortiert** sein müssen. Zudem solltest du mit Schleifen (insbesondere *while*-Schleifen) und bedingten Anweisungen (*if-else*) vertraut sein, um die iterative oder rekursive Abfrage der Array-Mitte und die Anpassung der Suchgrenzen umzusetzen. Wichtig ist auch, dass du die **Laufzeitkomplexität** der binären Suche kennst (O(log n)), um ihre Überlegenheit gegenüber der linearen Suche (O(n)) zu verstehen. Schließlich benötigst du Kenntnisse in der Implementierung von Funktionen oder Methoden, um den Algorithmus strukturiert in Code zu übersetzen.

Um dieses Lernziel zu erreichen, müssen Schülerinnen und Schüler verstehen, wie die Breitensuche (BFS, *Breadth-First Search*) und die Tiefensuche (DFS, *Depth-First Search*) funktionieren, wenn sie auf Bäumen angewendet werden. Beide Algorithmen dienen dazu, systematisch alle Knoten eines Baumes zu durchlaufen, wobei sie sich in ihrer Vorgehensweise grundlegend unterscheiden: Die Breitensuche erkundet zunächst alle Knoten einer Ebene, bevor sie tiefer in den Baum vordringt, während die Tiefensuche einen Pfad so weit wie möglich verfolgt, bevor sie zurückweicht und alternative Wege erkundet. Dazu müssen die Lernenden die rekursive oder iterative Implementierung dieser Suchverfahren nachvollziehen können, etwa durch das Arbeiten mit Keller- oder Warteschlangen-Datenstrukturen, die für DFS bzw. BFS typisch sind. Wichtig ist auch, die Unterschiede in der Reihenfolge der Knotenbesuche zu verstehen und zu erkennen, in welchen Anwendungsszenarien – etwa bei der Suche nach dem kürzesten Pfad oder der vollständigen Durchmusterung – welcher Algorithmus besser geeignet ist. Zudem sollten sie die Laufzeitkomplexität beider Verfahren analysieren können, die bei Bäumen in der Regel linear zur Anzahl der Knoten und Kanten ist.

Dieses Lernziel vermittelt dir, wie grundlegende Sortierverfahren funktionieren, die auf Vergleichen zwischen Elementen basieren – also ohne zusätzliche Annahmen über die Datenstruktur. Du lernst drei klassische Algorithmen kennen: Bubblesort, Selectionsort und Insertionsort, die jeweils unterschiedliche Strategien verfolgen, um eine Liste schrittweise zu ordnen. Dabei geht es nicht nur um das theoretische Verständnis der Abläufe, sondern auch um die praktische Anwendung: Du sollst die Verfahren händisch auf konkrete Eingabedaten anwenden können, um die Zwischenschritte nachzuvollziehen und die Effizienz der Algorithmen zu vergleichen. Zusätzlich wirst du einen dieser Algorithmen selbst in einer Programmiersprache umsetzen, um zu verstehen, wie sich die abstrakten Schritte in ausführbaren Code übersetzen lassen. Dieses Wissen ist essenziell, weil Sortierverfahren in fast allen Bereichen der Informatik vorkommen – von Datenbanken bis zu Suchalgorithmen – und dir helfen, die Grundprinzipien der algorithmischen Effizienz zu begreifen.

Um dieses Lernziel zu erreichen, müssen Sie verstehen, wie Algorithmen Datenstrukturen wie Arrays oder Listen systematisch sortieren, indem sie diese in kleinere Teilprobleme zerlegen und rekursiv verarbeiten. Konkret geht es darum, dass Sie ein höheres, vergleichsbasiertes Sortierverfahren wie Mergesort oder Quicksort nicht nur anwenden, sondern auch dessen Funktionsweise erklären können – etwa die Aufteilung der Daten, die rekursive Sortierung der Teilmengen und die anschließende Zusammenführung (Merge) bzw. Partitionierung (Quick). Dazu gehört, dass Sie die Grundprinzipien der Rekursion beherrschen, also die Fähigkeit, eine Funktion so zu definieren, dass sie sich selbst aufruft, um Teilprobleme zu lösen, sowie die Bedeutung von Vergleichsoperationen und Zeitkomplexität (z. B. O(n log n)) einordnen können. Praktisch bedeutet das, dass Sie den Ablauf des Algorithmus Schritt für Schritt nachvollziehen und in Pseudocode oder einer Programmiersprache umsetzen können, etwa durch die Angabe der Rekursionsbasis und des rekursiven Falls. Zudem sollten Sie die Vor- und Nachteile der Verfahren gegenüber einfacheren Sortieralgorithmen wie Bubble-Sort kennen, um deren Effizienz in verschiedenen Szenarien zu bewerten.

Um dieses Lernziel zu erreichen, müssen Sie verstehen, wie verschiedene Sortierverfahren funktionieren und wie sie sich in puncto Laufzeit, Speicherbedarf und Stabilität unterscheiden. Dazu gehört, dass Sie die drei Laufzeitkategorien *best case*, *worst case* und *average case* kennen und erklären können – etwa warum ein Verfahren wie *Quicksort* im Durchschnitt schneller ist als *Bubblesort*, aber im ungünstigsten Fall (z. B. bei bereits sortierten Daten) deutlich langsamer werden kann. Sie sollten zudem die *O-Notation* anwenden können, um die Komplexität von Algorithmen zu vergleichen, und wissen, was es bedeutet, wenn ein Sortierverfahren *stabil* ist (also gleiche Schlüssel in der ursprünglichen Reihenfolge belässt). Praktisch bedeutet das, dass Sie nicht nur die theoretischen Grundlagen beherrschen, sondern auch konkrete Beispiele analysieren und bewerten können, etwa warum *Mergesort* zwar stabil ist, aber mehr Speicher verbraucht als *Heapsort*.

Um dieses Lernziel zu erreichen, müssen Schüler verstehen, dass ein Algorithmus wie der von Dijkstra ein systematisches Verfahren ist, um in einem Graphen den kürzesten Pfad zwischen zwei Knoten zu finden – etwa in einem Straßennetz oder einem Netzwerk von Computern. Sie sollten die grundlegenden Konzepte von Graphen (Knoten, Kanten, Gewichte) beherrschen und wissen, wie Dijkstras Algorithmus schrittweise vorgeht: Er wählt iterativ den nächstgelegenen, noch nicht besuchten Knoten aus und aktualisiert die Pfadlängen zu seinen Nachbarn, bis der Zielknoten erreicht ist. Praktisch bedeutet das, dass sie in der Lage sein müssen, den Algorithmus auf Papier an einem konkreten Beispiel nachzuvollziehen – etwa durch das Markieren von Knoten, das Führen einer Prioritätswarteschlange und das Protokollieren der Zwischenschritte. Dazu gehört auch, die Bedeutung von Datenstrukturen wie Heaps oder Adjazenzlisten zu erkennen, die den Algorithmus effizient machen. Wichtig ist zudem, dass sie die Grenzen des Verfahrens einschätzen können, etwa dass es nur mit nicht-negativen Kantengewichten funktioniert und warum es in der Praxis oft mit anderen Methoden kombiniert wird.

Rekursion ist ein zentrales Konzept in der Informatik, bei dem ein Algorithmus sich selbst aufruft, um ein Problem in kleinere Teilprobleme zu zerlegen. Um rekursive Algorithmen zu entwerfen, musst du zunächst erkennen, wann ein Problem in sich selbst ähnliche Teilprobleme zerlegbar ist – etwa bei den Türmen von Hanoi, wo ein Turm aus n Scheiben auf einen anderen übertragen wird, indem ein Turm aus n-1 Scheiben bewegt wird. Dafür brauchst du zwei klare Komponenten: die **Rekursionsbasis**, die den Abbruch definiert (z. B. „Wenn nur noch eine Scheibe da ist, bewege sie direkt“), und den **Rekursionsschritt**, der das Problem in kleinere Instanzen zerlegt (z. B. „Bewege n-1 Scheiben auf den Hilfsstab“). Zudem musst du verstehen, wie die rekursiven Aufrufe die Lösung schrittweise aufbauen und warum eine falsche Basis oder ein fehlender Abbruch zu Endlosschleifen führt. Praktisch bedeutet das, dass du solche Algorithmen nicht nur theoretisch analysieren, sondern auch von Hand durchspielen kannst, um ihre Funktionsweise nachzuvollziehen – etwa indem du die einzelnen Schritte der Hanoi-Lösung für kleine n manuell durchgehst.

Das Lernziel bedeutet, dass ihr verstehen sollt, wie das **Divide-and-Conquer-Prinzip** funktioniert und warum es in der Informatik so nützlich ist. Dazu müsst ihr erkennen, dass sich viele Probleme in kleinere, ähnliche Teilprobleme zerlegen lassen, die einzeln gelöst und dann wieder zusammengesetzt werden können – etwa wie beim Sortieren großer Datenmengen oder beim Durchsuchen von Bäumen. Ihr solltet in der Lage sein, solche Zerlegungen selbstständig zu identifizieren und zu beschreiben, etwa durch rekursive Algorithmen wie *MergeSort* oder *Binary Search*, bei denen der Lösungsweg direkt auf der wiederholten Anwendung des Prinzips beruht. Wichtig ist auch, die **Rekursion** als technisches Mittel zu begreifen, um diese Teilprobleme elegant zu bearbeiten, ohne dabei in Endlosschleifen zu geraten – ihr müsst also die **Abbruchbedingung** und die **Rekursionsvorschrift** sicher anwenden können. Schließlich geht es darum, die Effizienzvorteile dieses Ansatzes zu verstehen, etwa die logarithmische Laufzeit von *Binary Search* im Vergleich zu linearen Suchverfahren.

Um rekursive Algorithmen zu implementieren, müssen Schüler zunächst verstehen, dass Rekursion ein Verfahren ist, bei dem eine Funktion sich selbst aufruft, um ein Problem in kleinere, ähnliche Teilprobleme zu zerlegen. Dafür ist es entscheidend, die beiden grundlegenden Komponenten einer rekursiven Lösung zu kennen: den **Basisfall** (eine Abbruchbedingung, die verhindert, dass die Rekursion endlos läuft) und den **Rekursionsschritt** (die schrittweise Zerlegung des Problems). Schüler sollten in der Lage sein, solche Strukturen in Problemstellungen wie der Fakultätsberechnung, der Fibonacci-Folge oder geometrischen Mustern wie der Kochschen Schneeflocke zu erkennen und umzusetzen. Praktisch bedeutet das, dass sie Funktionen schreiben können, die sich selbst mit angepassten Parametern aufrufen, und dabei die Kontrolle über die Rekursionstiefe behalten, um Überläufe oder ineffiziente Berechnungen zu vermeiden. Zudem ist ein Verständnis für die Laufzeitanalyse wichtig, um zu erkennen, wann Rekursion sinnvoll ist – etwa bei Problemen mit natürlicher Teilbarkeit – und wann iterative Lösungen effizienter wären.

Mit diesem Lernziel geht es darum, zu verstehen, wie ein moderner Computer nach dem **Von-Neumann-Prinzip** funktioniert – also wie Daten und Befehle in einer Maschine verarbeitet werden, die nur einen einzigen gemeinsamen Speicher für Programme und Daten nutzt. Ihr müsst dazu die **Grundkomponenten** eines solchen Rechners kennen: das **Rechenwerk** (führt arithmetische und logische Operationen aus), das **Steuerwerk** (koordiniert die Befehlsabfolge und steuert den Datenfluss), das **Speicherwerk** (hält Programme und Daten) sowie die **Register** (schnelle Zwischenspeicher für Operanden und Adressen). Wichtig ist auch, wie diese Teile über den **Adressbus** (überträgt Speicheradressen) und **Datenbus** (überträgt Daten und Befehle) miteinander kommunizieren. Zudem müsst ihr den **Befehlszyklus** (Befehl holen, decodieren, ausführen, Ergebnis speichern) verstehen, der zeigt, wie ein Prozessor schrittweise arbeitet. Ohne dieses Grundwissen könnt ihr später komplexere Konzepte wie Pipelining oder Speicherhierarchien nicht nachvollziehen.

Um dieses Lernziel zu erreichen, müssen Sie verstehen, wie ein Prozessor auf Maschinenebene Befehle wie *ADD*, *SUB* oder *JMP* ausführt, indem er sie in Mikrooperationen zerlegt. Dazu gehört das Wissen über den Aufbau eines einfachen Rechnermodells mit Steuerwerk, Rechenwerk und Register sowie die Fähigkeit, den Datenfluss und die Steuerung dieser Mikrooperationen in einer Simulation nachzubilden. Sie sollten die Grundlagen der Assemblersprache kennen und wissen, wie Befehle in Binärcode übersetzt werden, um die Mikroprogrammierung als Brücke zwischen Hardware und Software zu begreifen. Praktisch bedeutet das, dass Sie in einer Simulationsumgebung Mikroprogramme entwerfen, die den Prozessor anweisen, die gewünschten Operationen Schritt für Schritt auszuführen – etwa Registerinhalte zu addieren oder den Befehlszähler zu aktualisieren. Wichtig ist dabei auch, die Rolle des Mikroprogrammspeichers zu verstehen, der die Steuerinformationen für jeden Befehl enthält.

Dieses Lernziel verlangt, dass ihr die beiden grundlegenden Verschlüsselungsverfahren der modernen Kryptografie – symmetrische und asymmetrische Verschlüsselung – systematisch gegenüberstellen könnt. Ihr müsst verstehen, wie sich die Schlüsselverwaltung in beiden Systemen unterscheidet: Bei symmetrischen Verfahren wird für Ver- und Entschlüsselung derselbe Schlüssel verwendet, der geheim gehalten werden muss, während asymmetrische Systeme ein Schlüsselpaar (public key und private key) nutzen, bei dem nur der private Schlüssel geheim bleibt. Zudem sollt ihr den Prozess des Schlüsseltauschs analysieren, insbesondere das Problem der sicheren Schlüsselübergabe bei symmetrischer Verschlüsselung und wie asymmetrische Verfahren dies durch digitale Zertifikate oder Protokolle wie TLS lösen. Schließlich geht es darum, die praktischen Konsequenzen der unterschiedlichen Geschwindigkeiten beider Verfahren zu bewerten, da symmetrische Algorithmen wie AES deutlich schneller arbeiten, aber asymmetrische Methoden wie RSA für den Schlüsselaustausch unverzichtbar sind.

Um Nachrichten mit asymmetrischer Verschlüsselung zu signieren, muss man verstehen, dass dabei ein Schlüsselpaar aus einem öffentlichen und einem privaten Schlüssel genutzt wird: Der private Schlüssel dient zum Erstellen der Signatur, während der öffentliche Schlüssel zur Überprüfung durch den Empfänger dient. Dafür muss man wissen, wie asymmetrische Verschlüsselungsverfahren wie RSA funktionieren, also dass mathematische Operationen wie die Modulare Exponentiation die Grundlage bilden. Zudem ist es wichtig, den Unterschied zwischen Verschlüsselung und Signatur zu kennen – letztere bestätigt die Authentizität des Absenders und die Integrität der Nachricht, ohne sie zu verbergen. Praktisch bedeutet das, dass man ein solches Verfahren anwenden kann, etwa mit Tools wie OpenSSL, und versteht, warum die Sicherheit des privaten Schlüssels entscheidend ist.

Asymmetrische Kryptoverfahren wie RSA oder das Diffie-Hellman-Verfahren sichern Daten, indem sie auf mathematischen Einwegfunktionen beruhen: Diese Funktionen lassen sich leicht berechnen (z. B. Multiplikation zweier Primzahlen), aber ihre Umkehrung (Faktorisierung großer Zahlen) ist praktisch unmöglich, solange keine effizienten Algorithmen existieren. Die Sicherheit dieser Verfahren hängt also davon ab, dass es für die Umkehrfunktion – die Entschlüsselung oder das Brechen des Schlüssels – nur Angriffe mit exponentieller Laufzeit gibt, die selbst mit heutigen Computern nicht in vertretbarer Zeit durchführbar sind. Schüler müssen verstehen, dass Einwegfunktionen die Grundlage für öffentliche Schlüssel (Public-Key-Kryptografie) bilden, bei der ein Schlüssel zum Verschlüsseln öffentlich ist, während der andere zum Entschlüsseln geheim gehalten wird. Zudem sollten sie erkennen, dass die Sicherheit nicht auf Geheimhaltung des Algorithmus beruht, sondern auf der mathematischen Komplexität der zugrundeliegenden Probleme. Praktisch bedeutet das, dass selbst bei Kenntnis des öffentlichen Schlüssels ein Angreifer ohne den privaten Schlüssel nur mit extrem hohem Rechenaufwand an die verschlüsselten Daten gelangen kann.

Um das Lernziel zu erreichen, müssen Schüler verstehen, dass kryptographische Verfahren in der Informatik drei zentrale Schutzziele verfolgen: Erstens die **Geheimhaltung**, also die sichere Verschlüsselung von Daten, sodass nur berechtigte Personen sie lesen können – etwa durch symmetrische oder asymmetrische Verschlüsselungsalgorithmen wie AES oder RSA. Zweitens die **Authentifizierung**, die sicherstellt, dass eine Nachricht oder ein Nutzer tatsächlich der ist, der er vorgibt zu sein, wofür digitale Signaturen oder Zertifikate genutzt werden. Drittens die **Integritätssicherung**, die verhindert, dass Daten unbemerkt verändert werden, etwa durch Hash-Funktionen wie SHA-256, die Manipulationen erkennbar machen. Praktisch bedeutet das, dass Schüler nicht nur die theoretischen Grundlagen dieser Konzepte kennen, sondern auch nachvollziehen müssen, wie sie in realen Anwendungen – von verschlüsselten Chats bis zu Online-Banking – zusammenwirken, um Sicherheit zu gewährleisten. Dazu gehört auch, typische Angriffsvektoren wie Man-in-the-Middle-Attacken oder Brute-Force-Methoden zu verstehen und zu wissen, wie kryptographische Protokolle wie TLS diese abwehren.

Um das Lernziel zu erreichen, müssen Sie verstehen, wie Public-Key-Infrastrukturen (PKI) funktionieren und wo sie im Alltag eingesetzt werden, etwa beim digitalen Personalausweis, bei verschlüsselten Webseiten (HTTPS) oder bei E-Mail-Verschlüsselung (z. B. PGP/GPG). Dazu gehört, dass Sie die grundlegenden Prinzipien asymmetrischer Verschlüsselung kennen – also wie öffentliche und private Schlüssel zusammenwirken und warum Zertifizierungsstellen (CA) dabei eine zentrale Rolle spielen. Sie sollten erklären können, warum PKI Sicherheit bietet, etwa durch Authentizität, Integrität und Vertraulichkeit, aber auch deren Grenzen und mögliche Angriffsvektoren wie Man-in-the-Middle-Attacken oder Zertifikatsmissbrauch erkennen. Praktisch bedeutet das, dass Sie selbst Verschlüsselungstools nutzen können sollten, etwa um eine E-Mail mit GPG zu signieren oder ein Zertifikat in einem Browser zu überprüfen. Zudem müssen Sie einschätzen können, wann der Einsatz einer PKI sinnvoll ist und wann andere Sicherheitsmechanismen besser geeignet sind.

Dieses Lernziel bedeutet, dass ihr verstehen müsst, wie man Daten in Informatiksystemen vor unbefugtem Zugriff, Verlust oder Manipulation schützt und gleichzeitig sicherstellt, dass persönliche Informationen rechtlich und ethisch korrekt verarbeitet werden. Dafür müsst ihr grundlegende Konzepte wie Verschlüsselung, Zugriffskontrollen und Firewalls kennen, aber auch wissen, wie man diese in der Praxis anwendet – etwa durch sichere Passwörter, Zwei-Faktor-Authentifizierung oder die richtige Konfiguration von Netzwerken. Wichtig ist zudem, die rechtlichen Rahmenbedingungen wie die DSGVO zu verstehen, um zu erkennen, welche Daten überhaupt erhoben werden dürfen und wie Nutzerrechte gewahrt bleiben. Praktisch bedeutet das, dass ihr nicht nur theoretisch erklären könnt, warum Datenschutz wichtig ist, sondern auch konkrete Maßnahmen wie Backups, regelmäßige Software-Updates oder den Umgang mit Phishing erkennen und umsetzen könnt. Letztlich geht es darum, ein Bewusstsein für die Risiken digitaler Systeme zu entwickeln und verantwortungsvoll mit eigenen und fremden Daten umzugehen.

Um dieses Lernziel zu erreichen, müssen Schülerinnen und Schüler verstehen, wie Daten in der modernen Informationsgesellschaft systematisch gesammelt, gespeichert und verarbeitet werden – etwa durch Algorithmen, Cloud-Dienste oder soziale Netzwerke – und welche technischen, rechtlichen sowie ethischen Konsequenzen damit verbunden sind. Dazu gehört, dass sie die Funktionsweise von Big-Data-Analysen, Speicherinfrastrukturen (wie Rechenzentren oder Datenbanken) und Übertragungstechnologien (z. B. Verschlüsselung) nachvollziehen können, um zu erkennen, wo und wie Daten aggregiert oder missbraucht werden könnten. Gleichzeitig müssen sie in der Lage sein, konkrete Szenarien – etwa die Nutzung von Smartphone-Apps, Gesichtserkennung oder personalisierter Werbung – kritisch zu bewerten, indem sie Risiken wie Überwachung, Diskriminierung oder Datenlecks abwägen und mögliche Schutzmaßnahmen (wie Anonymisierung oder Datensparsamkeit) einordnen. Praktisch bedeutet das, dass sie selbstständig recherchieren, Quellen vergleichen und argumentativ begründete Urteile fällen können, etwa über die Verhältnismäßigkeit staatlicher oder unternehmerischer Datenerhebung. Letztlich geht es darum, ein Bewusstsein für die Machtverhältnisse in der digitalen Welt zu entwickeln und die eigene Rolle als Nutzerin oder Nutzer reflektiert zu gestalten.

Mit diesem Lernziel geht es darum zu verstehen, wo und warum Automatenmodelle in der Praxis eingesetzt werden – also nicht nur als theoretische Konzepte, sondern als Werkzeuge, die reale Probleme lösen. Dafür müsst ihr erkennen, dass Automaten wie endliche Automaten, Kellerautomaten oder Turingmaschinen nicht nur abstrakte Maschinen sind, sondern konkrete Anwendungen haben, etwa in der Syntaxprüfung von Programmiersprachen, der Steuerung von Ampelschaltungen oder der Verarbeitung natürlicher Sprache. Ihr solltet nachvollziehen können, wie diese Modelle durch ihre Struktur (Zustände, Übergänge, Eingabealphabet) bestimmte Aufgaben effizient abbilden und warum sie gerade für diese Aufgaben geeignet sind. Außerdem ist wichtig zu wissen, welche Automatenart für welche Problemklasse passt – etwa dass Kellerautomaten für kontextfreie Sprachen wie die Syntax von Programmiersprachen zuständig sind, während endliche Automaten für reguläre Sprachen wie Suchmuster in Texten ausreichen. Praktisch bedeutet das, dass ihr nicht nur die Definitionen kennen, sondern auch Beispiele aus eurem Alltag oder der Technik benennen könnt, in denen solche Automaten im Hintergrund arbeiten.

Mit diesem Lernziel geht es darum, Abläufe in der realen Welt oder in technischen Systemen als endliche Automaten zu modellieren – also als abstrakte Maschinen, die schrittweise Eingaben verarbeiten und dabei zwischen endlich vielen Zuständen wechseln. Dafür müssen Schüler zunächst verstehen, wie ein Zustandsdiagramm aufgebaut ist: Zustände werden als Kreise dargestellt, Übergänge als Pfeile mit Beschriftungen, die Eingaben und optional Ausgaben angeben. Besonders wichtig ist der Mealy-Automat, bei dem jede Ausgabe direkt von einem Zustandsübergang abhängt und nicht vom Zustand selbst. Praktisch bedeutet das, dass sie in der Lage sein müssen, gegebene Abläufe (z. B. eine Ampelschaltung oder eine Türsteuerung) in solche Diagramme zu übersetzen und umgekehrt aus einem Diagramm die Funktionsweise abzulesen. Zudem sollten sie erkennen, wann ein Automat mit Ausgabe (wie der Mealy-Automat) nötig ist und wann ein einfacher Automat ohne Ausgabe ausreicht.

Um dieses Lernziel zu erreichen, müssen Schüler zunächst verstehen, dass ein endlicher Automat (EA) ein mathematisches Modell ist, das aus Zuständen, Übergängen und Eingaben besteht, um bestimmte Sprachen oder Prozesse zu erkennen oder zu verarbeiten. Dafür ist es notwendig, die beiden gängigen Darstellungsformen – das Zustandsdiagramm (graphische Darstellung mit Knoten und Kanten) und die Zustandsübergangstabelle (tabellarische Auflistung aller Übergänge) – sicher ineinander überführen zu können. Dazu gehört, dass man Zustände und Eingaben korrekt identifiziert, Übergänge sowohl grafisch als auch textuell erfasst und dabei die Regeln der jeweiligen Darstellung beachtet, etwa die Beschriftung der Kanten im Diagramm oder die Struktur der Tabelle. Zudem sollte man erkennen, wie sich die Semantik der beiden Formen gegenseitig abbildet, also etwa, dass eine Zeile in der Tabelle einem Pfeil im Diagramm entspricht. Praktische Übung ist hier entscheidend, um die logische Konsistenz zwischen beiden Darstellungen zu gewährleisten.

Endliche Automaten sind ein zentrales Modell in der Informatik, um Systeme mit einer endlichen Anzahl von Zuständen und Übergängen zu beschreiben – etwa bei der Erkennung von Mustern in Texten, der Steuerung von Benutzeroberflächen oder der Modellierung von Kommunikationsprotokollen. Um ihre Einsatzbereiche zu verstehen, musst du zunächst erkennen, wie ein Automat durch Zustände, Eingabesymbole und Übergangsregeln definiert ist und wie er Eingaben verarbeitet, bis er einen Endzustand erreicht oder verwirft. Konkret solltest du in der Lage sein, endliche Automaten für einfache Probleme zu entwerfen, etwa um zu prüfen, ob eine Zeichenkette ein bestimmtes Teilwort enthält, oder um die Logik einer grafischen Oberfläche als Zustandsmaschine abzubilden. Zudem ist es wichtig, die Grenzen dieses Modells zu kennen: Endliche Automaten können zwar bestimmte Muster erkennen, aber keine verschachtelten Strukturen wie bei korrekten Klammerausdrücken, da ihnen ein Speicher für unbegrenzte Daten fehlt. Praktisch bedeutet das, dass du Automaten nicht nur theoretisch analysieren, sondern auch in konkreten Anwendungen wie der Syntaxprüfung von Programmiersprachen oder der Steuerung von Maschinen einsetzen kannst.

In diesem Kapitel geht es darum, wie man Projekte in der Informatik strukturiert plant und durchführt – etwa bei der Entwicklung von Software oder digitalen Systemen. Ihr lernt, was ein Projekt überhaupt ausmacht, wie ein klarer Projektauftrag aussieht und welche typischen Phasen ein solches Vorhaben durchläuft, von der Planung bis zur Abnahme. Dabei werden auch Methoden behandelt, um Anforderungen präzise zu erfassen und sicherzustellen, dass das Endergebnis den Erwartungen entspricht. Ein zentraler Punkt ist der Vergleich verschiedener Vorgehensmodelle: Ihr sollt verstehen, wie klassische Ansätze wie das Wasserfallmodell funktionieren, bei denen Phasen nacheinander ablaufen, und wie agile Methoden wie Scrum durch iterative Schleifen und flexible Anpassungen mehr Dynamik ermöglichen. Am Ende könnt ihr beurteilen, welches Modell sich für welche Art von Projekt eignet und wie ihr Anforderungen systematisch erhebt, um Missverständnisse zu vermeiden.

Um dieses Lernziel zu erreichen, müssen Schüler verstehen, wie man ein Softwareprojekt von der Idee bis zum Prototypen strukturiert plant und umsetzt. Dazu gehört, Anforderungen präzise zu erfassen – etwa durch ein Lastenheft, das die Wünsche des Auftraggebers dokumentiert, oder ein Pflichtenheft, das die technische Umsetzung konkretisiert. Sie sollten wissen, wie man Projektziele in kleinere, handhabbare Aufgaben zerlegt, etwa mit User Stories oder Systemfunktionen, um den Überblick zu behalten und Fortschritte messbar zu machen. Praktisch bedeutet das, Methoden wie agile Planung (z. B. Scrum) oder klassische Phasenmodelle anzuwenden und dabei Risiken, Ressourcen und Zeitrahmen zu berücksichtigen. Am Ende steht die Fähigkeit, einen funktionsfähigen Prototypen zu entwickeln, der zumindest Teile der Anforderungen erfüllt und als Grundlage für weitere Iterationen dient.