Softwareentwicklung

Probleme werden in eindeutige Schritte, Bedingungen, Wiederholungen und Teilprobleme zerlegt. Flussdiagramme und Pseudocode dienen als erste ausführbare Denkmodelle.

Mit Python entstehen erste Programme aus Variablen, Ausdrücken, Ein- und Ausgaben sowie einfachen Datentypen. Die Übungen reichen vom Taschenrechner bis zu kleinen Textwerkzeugen.

Verzweigungen, Schleifen und Zustandsänderungen steuern den Ablauf eines Programms. Typische Fehler wie Endlosschleifen und falsche Randbedingungen werden direkt untersucht.

Funktionen zerlegen Programme in wiederverwendbare Einheiten; Parameter, Rückgabewerte, Gültigkeitsbereiche und Module schaffen klare Schnittstellen. Daraus entsteht ein erstes mehrteiliges Programm.

Listen, Tupel, Mengen, Wörterbücher und Dateien speichern strukturierte Informationen. Praktische Aufgaben verarbeiten Tabellen, Texte und einfache Datensätze.

Fehlermeldungen, Stacktraces, Breakpoints, Logging und kleine reproduzierbare Beispiele helfen, Ursachen statt Symptome zu finden. Ein systematischer Ablauf führt vom beobachteten Fehler zur geprüften Korrektur.

Von Lochkarten und Großrechnern über Unix, Personal Computer und das Web bis zu Open Source, Mobilgeräten und Cloud-Plattformen: Die Entwicklung der Werkzeuge erklärt viele heutige Konventionen und Architekturentscheidungen.

Shell, Verzeichnisse, Prozesse, Umgebungsvariablen, Paketverwaltung und virtuelle Umgebungen bilden die tägliche Arbeitsumgebung. Die Lernenden richten ein reproduzierbares lokales Projekt ein.

Git erfasst Änderungen als Commits, verbindet Arbeit über Branches und löst Konflikte bei Zusammenführungen. Ein gemeinsames Repository wird mit aussagekräftiger Historie und Pull Requests geführt.

Mengen, Relationen, Aussagenlogik, Graphen, Rekursion und Kombinatorik liefern Werkzeuge für Datenmodelle und Algorithmen. Der Schwerpunkt liegt auf Anwendungen in Programmen statt auf formalen Beweisen.

Primitive Typen, zusammengesetzte Typen, Nullwerte, Generics und Typinvarianten machen Annahmen im Code sichtbar. Datenmodelle werden so entworfen, dass ungültige Zustände schwer darstellbar sind.

Klassen, Objekte, Kapselung, Komposition, Vererbung und Polymorphie strukturieren zustandsreiche Programme. Kleine Domänenmodelle zeigen, wann objektorientierte Modellierung hilft und wann sie unnötig kompliziert wird.

Unveränderliche Daten, reine Funktionen, Funktionen höherer Ordnung und deklarative Transformationen vereinfachen viele Datenflüsse. Übungen vergleichen funktionale und zustandsorientierte Lösungen.

Ausnahmen, Ergebniswerte, Validierung, Zeitüberschreitungen und Wiederholungsstrategien machen Fehlerfälle ausdrücklich behandelbar. Programme erhalten verständliche Meldungen und sichere Wiederanlaufpfade.

Arrays, verkettete Listen, Stacks, Queues, Hash-Tabellen, Bäume, Heaps und Graphen werden implementiert und passend ausgewählt. Speicherbedarf und typische Operationen bestimmen die Wahl.

Suchen, Sortieren, Traversieren, Teilen-und-Herrschen, Greedy-Verfahren, Backtracking und dynamische Programmierung lösen wiederkehrende Problemklassen. Implementationen werden mit Tests und Messdaten verglichen.

Big-O-, Big-Theta- und amortisierte Analyse beschreiben, wie Laufzeit und Speicherbedarf wachsen. Die Lernenden erkennen Engpässe, ohne sich von kleinen Einzelmessungen täuschen zu lassen.

Prozesse, Threads, virtueller Speicher, Dateisysteme, Systemaufrufe und Berechtigungen erklären das Verhalten laufender Programme. Diagnosewerkzeuge verbinden diese Modelle mit dem echten Rechner.

Threads, Tasks, Locks, atomare Operationen, Futures und asynchrone Ein- und Ausgabe ermöglichen gleichzeitige Arbeit. Race Conditions, Deadlocks und Backpressure werden reproduziert und behoben.

IP-Adressen, Ports, DNS, Routing, TCP, UDP und TLS bilden den Weg zwischen Anwendungen. Netzwerkverkehr wird mit Diagnosewerkzeugen untersucht und bei Verbindungsfehlern systematisch geprüft.

HTTP-Methoden, Statuscodes, Header, Cookies, Caching und WebSockets bestimmen die Kommunikation im Web. Requests werden von Hand gesendet, analysiert und gegen kleine Server getestet.

Stakeholder-Ziele werden in überprüfbare funktionale und nichtfunktionale Anforderungen, Akzeptanzkriterien und Randbedingungen übersetzt. Interviews, Beispiele und Prototypen helfen, unklare Wünsche früh sichtbar zu machen.

Nutzerflüsse, Informationsarchitektur, Interaktionszustände und visuelle Hierarchie führen zu bedienbaren Oberflächen. Prototypen werden mit echten Aufgaben statt nur nach Geschmack bewertet.

Semantische Strukturen, Tastaturbedienung, Fokusführung, Kontraste und assistive Technologien machen Software für mehr Menschen nutzbar. Automatische Prüfungen werden durch manuelle Tests mit Screenreadern ergänzt.

Kohäsion, geringe Kopplung, klare Verantwortlichkeiten, Abstraktionsgrenzen und Dependency Inversion erleichtern Änderungen. Bestehender Code wird anhand konkreter Änderungswünsche neu geschnitten.

Erzeugungs-, Struktur- und Verhaltensmuster liefern ein gemeinsames Vokabular für wiederkehrende Entwurfsprobleme. Jedes Muster wird gegen einfachere Alternativen und mögliche Fehlanwendungen abgewogen.

Schichten, Ports und Adapter, modulare Monolithen und domänenorientierte Grenzen ordnen größere Systeme. Architekturentscheidungen werden mit Qualitätszielen, Risiken und dokumentierten Kompromissen begründet.

README-Dateien, API-Referenzen, Architekturentscheidungen, Diagramme und Betriebsanleitungen halten Wissen nah am System. Dokumentation wird als versionierter und prüfbarer Bestandteil des Projekts behandelt.

Backlogs, kleine Lieferpakete, Kanban, Iterationen, Schätzungen und Retrospektiven koordinieren Arbeit ohne Scheingenauigkeit. Ein Teamprojekt wird in überprüfbare Aufgaben mit klaren Fertigkriterien zerlegt.

Pull Requests, nachvollziehbares Feedback und kleine Refactorings verbessern Code, ohne sein Verhalten unbeabsichtigt zu ändern. Technische Schulden werden nach Risiko und Nutzen priorisiert.

Unit-Tests prüfen kleine Einheiten schnell und gezielt; Test Doubles isolieren schwer kontrollierbare Abhängigkeiten. Gute Tests beschreiben Verhalten, Randfälle und Fehlerfälle statt interne Umsetzungsschritte.

Integrationstests prüfen Datenbanken, Dateisysteme und Dienste gemeinsam, während End-to-End-Tests kritische Nutzerwege absichern. Testumgebungen und Testdaten werden reproduzierbar aufgebaut.

Eigenschaftsbasierte Tests erzeugen vielfältige Eingaben aus Regeln, Fuzzing sucht Abstürze und Sicherheitsfehler mit unerwarteten Daten. Beide Verfahren ergänzen handgeschriebene Beispiele besonders an komplexen Eingabegrenzen.

Testpyramide, risikobasierte Auswahl, statische Analyse, Coverage und Qualitätsgrenzen verbinden einzelne Prüfverfahren zu einer Strategie. Ein Release erhält passende automatisierte und manuelle Kontrollen.

Tabellen, Schlüssel, Beziehungen, Normalformen und Constraints bilden konsistente Geschäftsobjekte ab. Aus einer fachlichen Beschreibung entsteht ein belastbares relationales Schema.

Abfragen, Joins, Aggregationen, Indizes, Transaktionen und Isolationsstufen steuern Datenzugriff und Konsistenz. Ausführungspläne zeigen, warum manche Abfragen langsam oder nebenläufig unsicher sind.

Dokumenten-, Schlüssel-Wert-, Spalten- und Graphdatenbanken lösen andere Zugriffsprobleme als relationale Systeme. Auswahl und Modellierung richten sich nach Abfragemustern, Konsistenzbedarf und Betriebskosten.

REST, RPC, GraphQL, Versionierung, Pagination und Fehlerformate schaffen stabile Verträge zwischen Systemen. Eine API wird spezifiziert, implementiert, getestet und mit Kompatibilitätsregeln weiterentwickelt.

HTML strukturiert Inhalte, CSS gestaltet responsive Layouts, und Browserwerkzeuge machen Darstellung sowie Netzwerkanfragen sichtbar. Daraus entsteht eine semantische, mehrseitige Website.

JavaScript verarbeitet Ereignisse, verändert das DOM und ruft APIs asynchron auf; TypeScript ergänzt überprüfbare Typen. Ein interaktiver Webclient wird ohne versteckte Framework-Mechanik aufgebaut.

Komponenten, Routing, Zustandsverwaltung, Formulare, Rendering-Strategien und Build-Werkzeuge strukturieren größere Weboberflächen. Performance und Wartbarkeit bestimmen die Auswahl eines Frameworks und seiner Bibliotheken.

Routing, Geschäftslogik, Persistenz, Hintergrundaufgaben und Konfiguration bilden einen serverseitigen Dienst. Eine Webanwendung wird mit klaren Schichten und kontrollierter Fehlerbehandlung umgesetzt.

Sitzungen, Tokens, OAuth 2.0, OpenID Connect, Mehrfaktor-Anmeldung und rollenbasierte Rechte schützen Identitäten und Funktionen. Bedrohungen wie Session-Hijacking und unsichere Passwortspeicherung werden praktisch abgewehrt.

WebSockets, Server-Sent Events, Synchronisation und Konfliktbehandlung unterstützen Chat, Live-Dashboards und gemeinsame Bearbeitung. Verbindungsabbrüche und langsame Clients fließen in das Protokolldesign ein.

Fenster, Ereignisschleifen, lokale Speicherung, Dateizugriff, Updates und plattformübergreifende Frameworks prägen Anwendungen für Arbeitsplatzrechner. Ein kleines Desktop-Programm wird paketiert und verteilt.

Touch-Oberflächen, App-Lebenszyklen, lokale Daten, Gerätesensoren, Benachrichtigungen und Store-Auslieferung bestimmen mobile Software. Offline-Verhalten und begrenzte Ressourcen werden von Beginn an eingeplant.

Zeichencodierung, Übersetzungsressourcen, Datums- und Zahlenformate, Zeitzonen sowie Schreibrichtungen verhindern lokale Annahmen im Code. Eine Anwendung wird für mehrere Sprachen und Regionen vorbereitet.

Konsistenz, Verfügbarkeit, Partitionen, Replikation, Quoren und verteilte Transaktionen erklären das Verhalten mehrerer Knoten. Fehlerszenarien werden modelliert, statt das Netzwerk als zuverlässig anzunehmen.

Queues, Publish-Subscribe, Ereignisprotokolle, Idempotenz und Zustellgarantien entkoppeln Dienste. Ein asynchroner Workflow verarbeitet Nachrichten trotz Duplikaten und vorübergehenden Ausfällen korrekt.

Dienstgrenzen, Service Discovery, API-Gateways, verteilte Daten und organisatorische Kosten prägen Microservices. Ein modularer Monolith wird nur dort aufgeteilt, wo unabhängige Lieferung den Zusatzaufwand rechtfertigt.

Bedrohungsmodelle, sichere Standardwerte, Eingabeprüfung, Geheimnisverwaltung und die OWASP-Risiken führen zu belastbarer Anwendungssicherheit. Angriffswege werden in einer Testanwendung gefunden und geschlossen.

Datenminimierung, Zweckbindung, Einwilligung, Löschfristen, Betroffenenrechte und Datenschutz durch Technikgestaltung beeinflussen Architektur und Betrieb. Datenflüsse werden dokumentiert und riskante Erhebungen vermieden.

Lizenzen, Urheberrecht, Open-Source-Pflichten, Patente, Barrierefreiheitsvorgaben und vertragliche Haftung setzen Grenzen für Entwicklung und Veröffentlichung. Abhängigkeiten und Lieferartefakte werden auf rechtliche Pflichten geprüft.

Profiling, Benchmarks, Lasttests, Caching, Speicheranalyse und Datenbankoptimierung machen Engpässe messbar. Verbesserungen werden gegen Nutzerwirkung und Ressourcenverbrauch geprüft.

Timeouts, Retries, Circuit Breaker, Redundanz, Health Checks und kontrollierter Kapazitätsabbau begrenzen Ausfälle. Fehlerbudgets und Wiederherstellungsziele verbinden technische Maßnahmen mit realen Betriebsanforderungen.

Linux-Dienste, Benutzerrechte, Prozesse, Signale, Dateisysteme und Netzwerkdiagnose bilden die Grundlage vieler Produktionsumgebungen. Eine Anwendung wird sicher als Dienst eingerichtet und bei Störungen untersucht.

Images, Container, Registries, Volumes und Netzwerke schaffen reproduzierbare Laufzeitumgebungen. Mehrere Dienste werden lokal gebaut, verbunden und mit möglichst kleinen Images abgesichert.

Automatisierte Pipelines kompilieren, prüfen, paketieren und veröffentlichen jede Änderung. Deployment-Strategien wie Rolling, Blue-Green und Canary reduzieren das Risiko neuer Versionen.

Rechenleistung, Objektspeicher, verwaltete Datenbanken, Netzwerke, Identitäten und Kostenmodelle bilden typische Cloud-Systeme. Eine Anwendung wird anhand von Verfügbarkeit, Sicherheit und Preis auf passende Dienste verteilt.

Deklarative Konfigurationen versionieren Netzwerke, Laufzeitumgebungen und Berechtigungen. Planbare Änderungen, Zustandsverwaltung und Richtlinien verhindern manuelle, nicht nachvollziehbare Produktionskonfiguration.

Pods, Deployments, Services, Ingress, Konfiguration, Secrets und Autoscaling betreiben Container auf Clustern. Rollouts, Ressourcenlimits und Fehlerdiagnose werden an einer vollständigen Anwendung geübt.

Funktionsbasierte Dienste, verwaltete Ereignisse und Edge-Laufzeiten verkürzen den Weg vom Code zum globalen Endpunkt. Kaltstarts, Zustandsgrenzen, Herstellerbindung und Kosten bestimmen, wann diese Modelle sinnvoll sind.

Logs, Metriken, Traces, Dashboards und Alarme zeigen, was ein verteiltes System tatsächlich tut. Service-Level-Ziele lenken die Beobachtung auf Nutzerwirkung statt auf eine Flut beliebiger Messwerte.

Abhängigkeitsprüfung, Software Bills of Materials, signierte Artefakte, reproduzierbare Builds und geschützte Pipelines sichern den Weg vom Quellcode bis zur Auslieferung. Ein kompromittiertes Paket wird als vollständiges Lieferkettenrisiko untersucht.

Eine reale Anforderung durchläuft Klärung, Entwurf, Implementierung, Review, Tests, Migration, Veröffentlichung, Beobachtung und Nachbereitung. Das Ergebnis ist ein betriebener Dienst mit Dokumentation, Rollback-Plan und messbaren Erfolgskriterien.

Batch-Pipelines, Datenbereinigung, Schemas, Orchestrierung, Data Warehouses und Data Lakes verwandeln Rohdaten in verlässliche Produkte. Qualität, Herkunft und Wiederholbarkeit werden als Teil der Pipeline gespeichert.

Partitionierte Ereignisprotokolle, Stream Processing, Fenster, Watermarks und zustandsbehaftete Verarbeitung ermöglichen laufende Auswertungen. Verspätete und doppelte Ereignisse werden ausdrücklich behandelt.

Speicherverwaltung, Zeiger, Binärschnittstellen, Systemaufrufe und speichersichere Sprachen ermöglichen hardwarenahe Programme. Ein kleines Kommandozeilenwerkzeug wird mit kontrolliertem Ressourcenverbrauch gebaut.

Tokenisierung, Parsing, abstrakte Syntaxbäume, Typprüfung, Interpretation und Codeerzeugung erklären den Weg vom Text zur Ausführung. Eine kleine Sprache erhält Parser, Fehlermeldungen und Interpreter.

GPU-Architekturen, Datenparallelität, Speicherübertragung und Compute-Kernel beschleunigen geeignete Aufgaben. Messungen zeigen, wann Parallelisierung den Overhead tatsächlich überwiegt.

Mikrocontroller, Register, Interrupts, Sensoren, Echtzeitanforderungen und knappe Ressourcen prägen eingebettete Software. Ein Gerät liest Eingaben, steuert Ausgaben und reagiert sicher auf Fehler.

WebAssembly führt kompilierten Code sicher und portabel in Browsern, Servern und Plugins aus. Module werden gebaut, eingebunden und über klar begrenzte Host-Schnittstellen ausgeführt.

Game Loops, Szenengraphen, Physik, Animation, Eingaben und Echtzeit-Rendering bilden interaktive Spiele. Ein spielbarer Prototyp wird profiliert und für gleichmäßige Bildraten optimiert.

Dezentrale Konsensmodelle, Transaktionen, Smart Contracts und unveränderliche Zustände schaffen besondere Sicherheits- und Kostenfragen. Ein kleiner Vertrag wird getestet, auf typische Schwachstellen geprüft und kritisch gegen eine zentrale Lösung abgewogen.

Regression, Klassifikation, Clustering, Merkmalsaufbereitung und Modellbewertung bilden den klassischen Werkzeugkasten des maschinellen Lernens. Ein Modell wird mit getrennten Trainings-, Validierungs- und Testdaten entwickelt.

Neuronale Netze, Backpropagation, Optimierung, Regularisierung und Convolutional Networks verarbeiten komplexe Muster. Trainingskurven und Fehlanalysen verhindern, dass reine Genauigkeitswerte das Modellverhalten verschleiern.

Attention, Selbstaufmerksamkeit, Positionsdarstellung und Encoder-Decoder-Strukturen erklären moderne Sequenzmodelle. Ein kleiner Transformer wird trainiert und hinsichtlich Rechen- sowie Speicherbedarf untersucht.

Tokenisierung, Vortraining, Kontextfenster, Inferenz und Prompting prägen große Sprach- und Foundation-Modelle. Anwendungen werden so gebaut, dass probabilistische Ausgaben geprüft und begrenzt werden.

Embeddings, semantische Suche, Chunking, Vektorspeicher, Quellenangaben und Evaluation verbinden Sprachmodelle mit eigenen Wissensbeständen. Eine RAG-Anwendung wird gegen Halluzinationen und schlechte Treffer getestet.

Supervised Fine-Tuning, Parameter-efficient Fine-Tuning, LoRA, Präferenzdaten und Evaluationssätze passen Modelle an konkrete Aufgaben an. Datenqualität, Kosten und Überanpassung entscheiden, ob Anpassung besser als Prompting oder RAG ist.

Diffusionsprozesse, Rauschvorhersage, latente Repräsentationen und Konditionierung erzeugen Bilder und andere Medien. Sampling-Schritte, Steuerung und Qualitätsmessung werden an einem kleinen Workflow verglichen.

Kollaboratives Filtern, inhaltsbasierte Verfahren, Ranking, implizites Feedback und Kaltstartprobleme bestimmen personalisierte Vorschläge. Ein Empfehlungssystem wird nicht nur auf Klicks, sondern auch auf Vielfalt und Verzerrungen geprüft.

Agenten, Zustände, Aktionen, Belohnungen, Wertfunktionen und Policy-Optimierung ermöglichen Lernen durch Interaktion. Kleine Umgebungen zeigen Exploration, verzögerte Belohnung und instabiles Training.

Codevervollständigung, Chat-Assistenten, automatisierte Tests und agentische Werkzeuge können Entwicklung beschleunigen, erzeugen aber neue Prüfpflichten. Vorschläge werden auf Korrektheit, Sicherheit, Lizenzen und Wartbarkeit kontrolliert.

Modellregistrierung, Datenversionierung, reproduzierbares Training, skalierbare Inferenz und Drift-Erkennung bringen ML-Systeme zuverlässig in Produktion. Änderungen an Daten, Code und Modellen bleiben gemeinsam nachvollziehbar.

Bias, Datenschutz, Erklärbarkeit, Prompt Injection, Datenvergiftung, Modellmissbrauch und menschliche Aufsicht verlangen eigene Kontrollen. Risikobewertungen und Red-Team-Tests werden in den Entwicklungs- und Freigabeprozess eingebaut.

Abhängigkeiten, veraltete Plattformen, fehlende Tests und institutionelles Wissen bestimmen die Arbeit an bestehenden Systemen. Charakterisierungstests, Strangler-Migrationen und schrittweise Datenänderungen ermöglichen sichere Modernisierung.

Ein größeres Abschlussprojekt verbindet Anforderungen, Architektur, Daten, Oberfläche, Sicherheit, Tests, Bereitstellung und Betrieb. Entscheidungen werden in einem Portfolio mit Quellcode, Demo, Dokumentation und Betriebsnachweisen belegt.

Rollen und Spezialisierungen reichen von Frontend, Backend und Mobile über Plattformbetrieb, Sicherheit, Daten und Embedded Systems bis zu technischer Leitung. Der Abschluss zeigt Einstiegswege, aussagekräftige Arbeitsproben, sinnvolle Zertifizierungen, Open-Source-Beiträge und verlässliche Wege, fachlich aktuell zu bleiben.