In dieser Weiterbildung lernst du Informatik mit Fokus auf Softwareentwicklung im Unternehmenskontext. Du lernst, Probleme und Ziele so zu klären, dass daraus umsetzbare Anforderungen entstehen. Du lernst Grundlagen des Programmierens sowie Vorgehensweisen, um Code verständlich, wartbar und veränderbar zu halten (z. B. Clean Code, Refactoring und Tests). Du lernst wichtige Konzepte zu Software-Design, Architektur, Datenstrukturen, Algorithmen, Datenbanken und Schnittstellen, damit du technische Entscheidungen besser einordnen und begründen kannst. Du lernst außerdem, KI pragmatisch einzuordnen: wann Regeln und saubere Daten ausreichen, und wann KI sinnvoll ist - einschließlich der Auswirkungen auf Stabilität und Betrieb.
Probleme schärfen, bevor du Code schreibst- Vom Symptom zum echten Problem: Du lernst, Ziele, Stakeholder und Grenzen zu klären, damit du nicht schneller das Falsche baust.
- Domänenwissen in Klartext: Du übersetzt Fachsprache in einfache Begriffe, die später im Code wieder auftauchen, damit alle über dasselbe reden.
- Systemdenken statt Featuredenken: Du zeichnest einfache Flüsse (Eingabe, Verarbeitung, Ausgabe), damit du Abhängigkeiten früh siehst.
- Risiken sichtbar machen: Du erkennst typische Tech-Risiken (Datenqualität, Latenz, Sicherheit), bevor sie dich im Go-live überraschen.
- Akzeptanzkriterien, die testen kann: Du formulierst Beispiele, die man automatisieren kann, statt schwammiger Wunschlisten.
- Entscheidungen dokumentieren ohne Roman: Du schreibst kurze Architektur-Notizen, damit später klar ist, warum etwas so gebaut wurde.
- Schätzen ohne Würfeln: Du nutzt Zerlegung und Unsicherheit, damit Planung ehrlich wird und nicht nach Theater aussieht.
- Konflikte produktiv machen: Du lernst, technische Einwände in Business-Sprache zu übersetzen, damit Diskussionen nicht eskalieren.
Programmieren als Handwerk
- Programmieren als Problemlösen: Du lernst, Probleme in kleine Schritte zu zerlegen, statt sofort nach einer Library zu suchen.
- Kontrollfluss verstehen: Bedingungen, Schleifen und Fehlerpfade so bauen, dass dein Code auch bei Sonderfällen nicht abstürzt.
- Datenstrukturen im Alltag: Listen, Maps und Sets wählen, damit Suche, Duplikate und Reihenfolgen nicht zum Dauerbug werden.
- Funktionen, die man testen kann: Kleine Funktionen mit klarer Aufgabe, damit Änderungen nicht alles kaputt machen.
- Debugging wie ein Detektiv: Reproduzieren, Eingrenzen, Fixen, Absichern, damit Bugs nicht wiederkommen.
- Saubere Fehlerbehandlung: Exceptions und Rückgabewerte so nutzen, dass Nutzer verständliche Fehler sehen und Logs brauchbar bleiben.
- Versionierung ohne Drama: Git-Grundideen, Commits und Branches, damit Zusammenarbeit nicht in Copy-Paste endet.
- Lesbarer Code statt cleverer Code: Benennung, Struktur, Einfachheit, damit du in 6 Monaten deinen Code noch verstehst.
- Refactoring als Alltag: Du verbesserst Schritt für Schritt, ohne Verhalten zu ändern, damit die Codebasis nicht verrottet.
- Tests als Sicherheitsnetz: Unit-Tests und kleine Integrations-Tests, damit du schneller ändern kannst ohne Angst.
- TDD als Denkwerkzeug: Du schreibst erst den Test, wenn das Problem unklar ist, damit du die Schnittstelle sauber findest.
- API denken lernen: Du baust Funktionen wie Produkte, mit klaren Inputs und Outputs, damit andere sie ohne Wissen über Interna nutzen.
- Grundlagen OOP: Objekte als Zustands-Container mit Verhalten, damit du Komplexität in sinnvolle Teile zerlegst.
- Nebenläufigkeit light: Threads oder Async verstehen, damit du nicht aus Versehen Race Conditions baust.
Daten, Persistenz und Schnittstellen
- Wenn Daten lügen: Du lernst Datenmodelle, damit Reports und Prozesse nicht auf widersprüchlichen Tabellen basieren.
- Relationale Modelle in Praxis: Tabellen, Schlüssel, Beziehungen so designen, dass Änderungen möglich bleiben.
- SQL für Problemlöser: Du fragst Daten ab, um Ursachen zu finden, nicht um schöne Queries zu sammeln.
- Normalisierung ohne Dogma: Du erkennst, wann Redundanz schadet und wann sie Performance rettet.
- Transaktionen verstehen: Du verhinderst Doppelbuchungen und halbe Zustände, wenn mehrere Nutzer gleichzeitig arbeiten.
- APIs als Verträge: Du definierst Requests und Responses, damit Systeme ohne direkte DB-Kopplung zusammenarbeiten.
- JSON, Events, Dateien: Du wählst das richtige Austauschformat, damit Integration stabil bleibt.
- Caching und Latenz: Du verstehst, warum schnell und korrekt oft Gegensätze sind und wie man Kompromisse baut.
- Datenqualität messen: Du baust Checks, damit fehlerhafte Eingaben nicht still und leise dein System vergiften.
- Einfaches Datenpipelines-Denken: Von Quelle bis Ziel, damit du Datenflüsse debuggen kannst.
Software-Design und Architektur, die Änderungen überlebt
- Clean Code als Kostenbremse: Du erkennst Code-Smells, damit Wartung nicht teurer wird als Neuentwicklung.
- Design-Prinzipien in Alltagssprache: Kohäsion, Kopplung und Verantwortung so nutzen, dass Änderungen lokal bleiben.
- SOLID ohne Religion: Du lernst, wann Regeln helfen und wann sie nur Bürokratie im Code sind.
- Refactoring Patterns: Du reparierst Struktur, ohne Features zu verlieren, damit du aus Chaos wieder Ordnung machst.
- Entwurfsmuster als Werkzeugkasten: Du nutzt Patterns, wenn das Problem wiederkehrt, nicht weil es schick klingt.
- Strategy und State: Du vermeidest if-else-Wüsten, indem Verhalten austauschbar wird.
- Factory und Dependency Injection: Du entkoppelst Erzeugung von Nutzung, damit Tests und Varianten einfach werden.
- Observer und Events: Du baust lose Kopplung, damit Änderungen nicht Kettenreaktionen auslösen.
- Adapter und Facade: Du kapselst Fremdsysteme, damit Integrationen austauschbar bleiben.
- Repository und Unit of Work: Du trennst Domäne von Datenzugriff, damit Geschäftslogik nicht in SQL versinkt.
- Hexagonal und Clean Architecture: Fachlogik in die Mitte, Technik nach außen, damit Framework-Wechsel kein Rebuild wird.
- Architektur-Schnitte finden: Du schneidest nach Domänen statt nach Technik, damit Teams unabhängig liefern können.
- API Design und Versionierung: Du planst Änderungen, damit du Kunden nicht mit Breaking Changes überfährst.
- Performance im Design: Du erkennst Hotspots und baust Messbarkeit ein, statt später blind zu optimieren.
Mathe und Algorithmen, die dir wirklich helfen
- Big-O ohne Angst: Du schätzt Laufzeit und Speicher, damit Performance-Probleme nicht erst im Betrieb auffallen.
- Sortieren und Suchen: Du wählst das passende Verfahren, damit Datenmengen nicht alles ausbremsen.
- Rekursion verstehen: Du baust rekursive Lösungen ohne Stack-Overflow und mit klaren Abbruchbedingungen.
- Hashing praktisch: Du nutzt Hashmaps richtig, damit Lookups schnell sind und Kollisionen dich nicht überraschen.
- Bäume und Heaps: Du modellierst Hierarchien und Prioritäten, damit Scheduling und Suche effizient werden.
- Graphen im Alltag: Du löst Routen, Abhängigkeiten und Netzwerkprobleme, ohne alles neu zu erfinden.
- Dijkstra, BFS, DFS: Du findest Wege und Strukturen, damit du in Systemlandschaften nicht im Nebel stehst.
- Dynamische Programmierung: Du löst Optimierung ohne Bruteforce, wenn Varianten explodieren.
- Wahrscheinlichkeit für Informatik: Du verstehst Risiken, Zufall und A/B-Tests, damit Entscheidungen nicht auf Bauchgefühl basieren.
- Lineare Algebra für KI: Vektoren, Matrizen und Skalarprodukte, damit du Embeddings und Modelle nicht mystisch findest.
- Diskrete Mathematik light: Mengen, Relationen, Funktionen, damit Datenmodelle und Logik sauber werden.
- Beweise als Debugging: Du nutzt Invarianten, um zu zeigen, warum…