Home

Einführung in modernes Software Engineering im Zeitalter der generativen KI

October 2025 (1323 Words, 8 Minutes)

software-engineering ki automatisierung github vscode python astral tools

Software Engineering Kurs

Lernen wir uns kennen

Bevor wir in die Kursinhalte eintauchen, möchten wir Ihre aktuelle Erfahrung mit der Softwareentwicklung verstehen. Dies hilft uns, die Vorlesungen auf Ihre Bedürfnisse abzustimmen und unseren gemeinsamen Lernfortschritt während des Semesters zu verfolgen.

Bitte nehmen Sie sich 5 Minuten Zeit, um diese anonyme Umfrage auszufüllen:

📋 Zur Umfrage über Software-Entwicklungskenntnisse

Ihre Antworten sind vollständig anonym und helfen uns, das Grundwissen der Klasse in Bereichen wie Versionskontrolle, Programmiersprachen, Entwicklungswerkzeugen und KI-gestützter Programmierung zu verstehen.

Einführung

Die folgenden Ideen sind adaptiert aus dem Lehrbuch Software Engineering at Google (O’Reilly).
Sie verdeutlichen, wie Google die Unterscheidung zwischen Programmierung und Software Engineering rahmt
und führen Schlüsselprinzipien ein für das Denken über Software als etwas, das dauerhaft bestehen und sich über die Zeit entwickeln muss.

Programmierung vs. Software Engineering

Im alltäglichen Sprachgebrauch verwenden Menschen oft Programmierung und Software Engineering, als würden sie dasselbe bedeuten. Aber es gibt einen wichtigen Unterschied:

Das “echte Ding”, das Software-Ingenieure erschaffen, ist keine Brücke oder ein Flugzeug, sondern vielmehr Softwaresysteme, auf die Menschen angewiesen sind. Obwohl weniger greifbar, erfordern diese Systeme dennoch den gleichen disziplinierten Ansatz und die gleiche Verantwortung, die andere Ingenieursdisziplinen verlangen.

Software Engineering als Programmierung über die Zeit

Software Engineering ist mehr als nur Code schreiben—es geht um alles, was eine Organisation tut, um diesen Code über die Zeit zu erstellen, warten und weiterentwickeln. Die erste Version eines Programms zu schreiben ist oft der einfache Teil. Die echte Herausforderung kommt später: es nützlich, nachhaltig und anpassungsfähig zu halten, während sich Technologie und Anforderungen ändern.

Eine hilfreiche Art, über Software Engineering zu denken, ist als “Programmierung integriert über die Zeit.” Diese Perspektive erinnert uns daran, dass Software einen Lebenszyklus hat: von der ersten Konzeption über aktive Nutzung und Wartung bis hin zur eventuellen Einstellung. Die zentrale Frage wird: Welche Praktiken ermöglichen es Software, diesen Zyklus zu überleben und wertvoll zu bleiben?

Drei Leitprinzipien helfen dabei, diese Denkweise zu formen:

Durch die Fokussierung auf diese Prinzipien wird Software Engineering weniger zu schnellen Lösungen und mehr zur Schaffung von Systemen, die robust, anpassungsfähig und langfristig wartbar sind.

Das neue Paradigma: KI-unterstützte Entwicklung

Willkommen zu unserer ersten Vorlesung über modernes Software Engineering! Heute erkunden wir, wie die Landschaft der Softwareentwicklung durch generative KI und Automatisierungstools transformiert wurde und wie dies grundlegend verändert hat, wie wir Software entwickeln, testen und bereitstellen.

Das Software Engineering-Feld hat mit dem Aufkommen generativer KI eine revolutionäre Verschiebung erlebt. Wir schreiben nicht mehr nur Code; wir orchestrieren intelligente Systeme, die uns beim Denken, Entwerfen und Implementieren von Lösungen effektiver helfen.

Kernprinzipien des modernen Software Engineering

  1. KI-Mensch-Kollaboration: KI als Programmierpartner nutzen, nicht als Ersatz
  2. Automatisierung-First-Denkweise: Wiederholende Aufgaben von Anfang an automatisieren
  3. Schnelle Iteration: Schnellere Feedback-Zyklen durch intelligente Tooling
  4. Qualitätssicherung: KI-gestützte Tests und Code-Reviews
  5. Kontinuierliches Lernen: Tools, die sich anpassen und mit der Nutzung verbessern

Wesentliches modernes Tool-Ökosystem

Versionskontrolle & Zusammenarbeit: GitHub

GitHub hat sich weit über einfache Versionskontrolle hinaus entwickelt:

# Beispiel GitHub Action für Python-Projekt
name: CI/CD Pipeline
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: uv einrichten
        uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - name: Python einrichten
        run: uv python install 3.12
      - name: Dependencies installieren
        run: uv sync
      - name: Tests ausführen
        run: uv run pytest

Entwicklungsumgebung: VS Code + Extensions

Visual Studio Code ist zum De-facto-Standard geworden, erweitert durch:

Python-Entwicklung: Die Astral-Revolution

Das Python-Ökosystem wurde durch Astrals Tools revolutioniert:

uv - Ultraschneller Python Package Manager

# uv installieren
curl -LsSf https://astral.sh/uv/install.sh | sh

# Neues Projekt erstellen
uv init mein-projekt
cd mein-projekt

# Dependencies hinzufügen
uv add requests pandas numpy

# Skripte ausführen
uv run main.py

Ruff - Blitzschneller Python Linter und Formatter

# pyproject.toml
[tool.ruff]
line-length = 88
target-version = "py311"

[tool.ruff.lint]
select = ["E", "F", "UP", "B", "SIM", "I"]

Hauptvorteile der Astral-Tools

Moderner Entwicklungsworkflow

flowchart TD A[Idee] --> B[GitHub Issue] B --> C[VS Code + Copilot] C --> D[Lokale Entwicklung] D --> E[Ruff Linting] E --> F[Git Commit] F --> G[GitHub Push] G --> H[GitHub Actions] H --> I[Tests] I --> J[Deployment]

Automatisierungsbeispiele in der Praxis

Automatisierte Code-Qualität

# .github/workflows/quality.yml
name: Code-Qualität
on: [push, pull_request]
jobs:
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: uv einrichten
        uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - name: Linting mit Ruff
        run: uv run ruff check .
      - name: Format-Check
        run: uv run ruff format --check .
      - name: Type-Check mit Pyright
        run: uv run pyright

Automatisierte Dokumentation

# KI zur Generierung von Docstrings nutzen
def calculate_performance_metrics(data: pd.DataFrame) -> dict:
    """
    Berechne wichtige Leistungsmetriken aus Zeitreihendaten.
    
    Args:
        data: DataFrame mit Zeitstempel- und Wertspalten
        
    Returns:
        Dictionary mit berechneten Metriken inklusive Mittelwert, Standardabweichung, etc.
    """
    # Implementierung mit Copilot-Unterstützung
    pass

Der KI-First-Entwicklungsprozess

  1. Problemdefinition: KI zur Verfeinerung von Anforderungen und User Stories nutzen
  2. Architektur-Design: KI für Systemdesign-Vorschläge nutzen
  3. Code-Generierung: Copilot unterstützt bei der Implementierung
  4. Testing: KI-generierte Testfälle und Edge-Case-Identifikation
  5. Dokumentation: Automatisierte Dokumentationsgenerierung
  6. Deployment: KI-optimierte CI/CD-Pipelines
  7. Monitoring: Intelligente Alarmierung und Performance-Analyse

Best Practices für KI-unterstützte Entwicklung

Prompt Engineering für Entwickler

Tool-Integrationsstrategie

# Modernes Python-Projekt-Setup
uv init software-engineering-demo
cd software-engineering-demo

# Entwicklungsabhängigkeiten hinzufügen
uv add --dev pytest pyright ruff

# VS Code-Einstellungen konfigurieren
echo '{"python.defaultInterpreterPath": ".venv/bin/python"}' > .vscode/settings.json

Automatisierungs-Checkliste

Zukunftstrends

Praktische Übung

Für die nächste Stunde richten Sie eine moderne Python-Entwicklungsumgebung ein:

  1. uv installieren und ein neues Projekt einrichten
  2. VS Code mit GitHub Copilot konfigurieren
  3. Ein GitHub-Repository mit Actions einrichten
  4. Eine einfache Python-Anwendung mit automatisierten Tests erstellen
  5. Ruff für Code-Formatierung und Linting verwenden

Zusammenfassung

Modernes Software Engineering zeichnet sich aus durch:

Die Tools, die wir besprochen haben—GitHub, VS Code, Copilot und Astrals Python-Toolchain—repräsentieren den neuen Standard für professionelle Softwareentwicklung. Die Beherrschung dieser Tools und das Verständnis für die effektive Nutzung von KI-Unterstützung wird entscheidend für Ihren Erfolg als moderner Software-Ingenieur sein.

© 2026 Dominik Mueller   •  Powered by Soopr   •  Theme  Moonwalk