Software Engineering

KAPITEL 04 · PROGRAMMIERUNG

Software Engineering

Professionelle Softwareentwicklung – von Entwicklungsprozessen und Methodologien über Design-Prinzipien und Testing bis zu Best Practices für wartbaren, skalierbaren Code.

SDLC Agile & Scrum SOLID & DRY Testing

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernen Sie alles über professionelles Software Engineering:

  • Definition: Was ist Software Engineering?
  • SDLC: Software Development Life Cycle (6 Phasen)
  • Methodologien: Wasserfall, Agile, Scrum, Kanban, DevOps
  • Design-Prinzipien: SOLID, DRY, KISS, YAGNI
  • Testing: Unit, Integration, System, Acceptance
  • Best Practices: Code-Qualität, Dokumentation, Reviews
  • FAQ: Häufige Fragen zum Software Engineering

1. Was ist Software Engineering?

Definition

Software Engineering ist die systematische, disziplinierte und quantifizierbare Anwendung von Ingenieurprinzipien auf die Entwicklung, den Betrieb und die Wartung von Software. Es geht weit über das reine Programmieren hinaus und umfasst den gesamten Lebenszyklus einer Software – von der Anforderungsanalyse bis zur Außerbetriebnahme.

Im Gegensatz zum "Hobby-Programmieren" legt Software Engineering Wert auf Wartbarkeit, Skalierbarkeit, Zuverlässigkeit und Effizienz. Professionelle Softwareentwicklung folgt etablierten Prozessen, verwendet bewährte Methodologien und setzt auf Qualitätssicherung durch Testing und Code Reviews.

Die drei Säulen des Software Engineering: Prozesse (Methodologien wie Agile/Scrum), Prinzipien (Design-Patterns, SOLID) und Praktiken (Testing, CI/CD, Code Reviews).

Warum Software Engineering?

Ohne strukturiertes Vorgehen entstehen schnell:

  • Spaghetti-Code: Unverständlicher, nicht wartbarer Code
  • Bugs: Fehler, die erst in Produktion auffallen
  • Technische Schulden: Schnelle Lösungen, die später teuer werden
  • Scope Creep: Projekte wachsen uncontrolliert
  • Burnout: Entwickler arbeiten chaotisch und ineffizient

Software Engineering verhindert diese Probleme durch strukturierte Prozesse und bewährte Praktiken.

2. Software Development Life Cycle (SDLC)

Der SDLC definiert die Phasen, die jede Software durchläuft – von der Idee bis zur Außerbetriebnahme.

1

Anforderungsanalyse

Requirements Engineering

Was soll die Software können? Anforderungen werden gesammelt, dokumentiert und priorisiert.

  • Stakeholder-Interviews
  • User Stories erstellen
  • Use Cases definieren
  • Requirements-Dokumentation
  • Priorisierung (MoSCoW)
2

Design

Architektur & UI/UX

Wie wird die Software gebaut? Architektur, Datenmodelle und UI-Design werden erstellt.

  • Systemarchitektur entwerfen
  • Datenbank-Design (ER-Diagramme)
  • API-Design (REST/GraphQL)
  • UI/UX Wireframes & Mockups
  • Technologie-Stack wählen
3

Implementierung

Coding & Development

Die eigentliche Entwicklung – Code wird geschrieben, getestet und integriert.

  • Code schreiben (Clean Code)
  • Versionskontrolle (Git)
  • Unit Tests entwickeln
  • Code Reviews durchführen
  • Continuous Integration
4

Testing

Qualitätssicherung

Die Software wird umfassend getestet – funktional, nicht-funktional und benutzerfreundlich.

  • Unit Testing
  • Integration Testing
  • System Testing
  • User Acceptance Testing (UAT)
  • Performance & Security Testing
5

Deployment

Auslieferung & Go-Live

Die Software wird in die Produktionsumgebung ausgeliefert und für Benutzer verfügbar gemacht.

  • Staging-Umgebung testen
  • Deployment-Strategie wählen
  • Blue-Green / Canary Deployment
  • Monitoring einrichten
  • Rollback-Plan vorbereiten
6

Wartung

Operations & Support

Die Software wird betrieben, gewartet, aktualisiert und weiterentwickelt.

  • Bug-Fixes & Patches
  • Performance-Optimierung
  • Neue Features entwickeln
  • Security Updates
  • User Support & Dokumentation

3. Entwicklungs-Methodologien

Methodologien definieren, wie Teams zusammenarbeiten und Software entwickeln. Jede hat ihre Stärken und Einsatzgebiete.

Wasserfall-Modell

Sequentiell & Linear

Phasen werden nacheinander durchlaufen – jede Phase muss abgeschlossen sein, bevor die nächste beginnt.

  • Klare Struktur & Dokumentation
  • Gute Planbarkeit
  • Für stabile Anforderungen
  • Unflexibel bei Änderungen
  • Spätes Feedback
Einsatz: Regulierte Branchen (Medizin, Luftfahrt), Projekte mit festen Anforderungen

Agile Entwicklung

Iterativ & Flexibel

Software wird in kurzen Zyklen (Sprints) entwickelt – kontinuierliche Verbesserung und Anpassung.

  • Schnelles Feedback
  • Flexibel bei Änderungen
  • Kundenorientiert
  • Selbstorganisierte Teams
  • Kontinuierliche Lieferung
Einsatz: Die meisten modernen Softwareprojekte, Startups, Produktentwicklung

Scrum

Agiles Framework

Agiles Framework mit festen Rollen (Product Owner, Scrum Master, Team), Events (Sprint, Daily, Review) und Artefakten (Backlog, Increment).

  • Time-boxed Sprints (2-4 Wochen)
  • Daily Standups (15 Min)
  • Sprint Planning & Review
  • Retrospektiven
  • Transparente Fortschrittsmessung
Einsatz: Produktentwicklung, komplexe Projekte, Teams mit 5-9 Mitgliedern

Kanban

Visualisierung & Flow

Visuelle Methode zur Workflow-Optimierung – Tasks werden auf einem Board von "To Do" zu "Done" bewegt.

  • Kanban-Board (Spalten für Status)
  • Work-in-Progress Limits
  • Continuous Flow
  • Keine festen Sprints
  • Fokus auf Durchlaufzeit
Einsatz: Support-Teams, Wartung, Projekte mit variabler Priorität

DevOps

Development + Operations

Kultur und Praktiken, die Development und Operations zusammenbringen – Automatisierung, CI/CD, Infrastructure as Code.

  • Continuous Integration (CI)
  • Continuous Deployment (CD)
  • Infrastructure as Code (IaC)
  • Monitoring & Logging
  • Automatisierung
Einsatz: Cloud-native Anwendungen, SaaS-Produkte, schnelle Releases

Welche Methodologie wählen?

  • Wasserfall: Wenn Anforderungen stabil und gut verstanden sind
  • Agile/Scrum: Für die meisten modernen Softwareprojekte – flexibel und kundenorientiert
  • Kanban: Für Support, Wartung oder Projekte ohne feste Deadlines
  • DevOps: Für Cloud-Anwendungen mit häufigen Releases
  • Hybrid: Oft werden Methodologien kombiniert (z.B. Scrum + Kanban = Scrumban)

4. Design-Prinzipien

Design-Prinzipien sind Richtlinien für sauberen, wartbaren Code. Sie helfen, technische Schulden zu vermeiden.

SOLID-Prinzipien

Fünf Prinzipien für objektorientiertes Design:

  • S – Single Responsibility (eine Aufgabe pro Klasse)
  • O – Open/Closed (erweiterbar, nicht veränderbar)
  • L – Liskov Substitution (Subtypen austauschbar)
  • I – Interface Segregation (viele kleine Interfaces)
  • D – Dependency Inversion (Abhängigkeiten abstrakt)

DRY – Don't Repeat Yourself

Jedes Wissen sollte eine einzige, autoritative Quelle im System haben. Duplikate vermeiden.

❌ Schlecht:
Gleicher Code in 5 Dateien

✅ Gut:
Funktion/Modul erstellen, überall wiederverwenden

KISS – Keep It Simple, Stupid

Einfachheit ist Trumpf. Komplexität nur, wenn sie wirklich nötig ist.

❌ Schlecht:
Über-engineerte Architektur

✅ Gut:
Einfachste Lösung, die funktioniert

YAGNI – You Aren't Gonna Need It

Implementiere nur, was jetzt gebraucht wird – nicht was "vielleicht später" nützlich sein könnte.

❌ Schlecht:
Features für hypothetische Use Cases

✅ Gut:
Nur aktuelle Anforderungen umsetzen

Separation of Concerns

Trenne verschiedene Verantwortlichkeiten in verschiedene Module/Klassen.

Beispiel:
UI-Logik ≠ Business-Logik ≠ Datenzugriff
Jede Schicht hat eine klare Aufgabe

5. Software Testing

Testing ist essenziell für Software-Qualität. Verschiedene Testarten decken unterschiedliche Aspekte ab.

Unit Testing

Komponenten-Test

Testet einzelne Funktionen/Methoden isoliert – schnell und granular.

  • Testet einzelne Code-Einheiten
  • Sehr schnell (Millisekunden)
  • Automatisierbar (CI/CD)
  • Mocking für Abhängigkeiten
Tools: Jest, JUnit, pytest, NUnit

Integration Testing

Modul-übergreifend

Testet das Zusammenspiel mehrerer Module/Komponenten.

  • Testet Schnittstellen
  • Datenbank-Interaktionen
  • API-Kommunikation
  • Langsamer als Unit Tests
Tools: Postman, REST Assured, TestContainers

System Testing

End-to-End

Testet das gesamte System unter realen Bedingungen – wie ein Benutzer es nutzen würde.

  • Vollständige Workflows
  • Performance-Tests
  • Security-Tests
  • Last-Tests (Load Testing)
Tools: Selenium, Cypress, JMeter, k6

Acceptance Testing

Benutzerabnahme

Der Kunde/Benutzer testet, ob die Software die Anforderungen erfüllt.

  • User Acceptance Testing (UAT)
  • Alpha/Beta-Testing
  • Real-World-Szenarien
  • Go/No-Go Entscheidung
Tools: Manual Testing, UserTesting.com, TestRail

Testing Best Practices

  • Test-Pyramide: Viele Unit Tests, weniger Integration Tests, wenige E2E Tests
  • Automatisierung: So viele Tests wie möglich automatisieren
  • CI/CD Integration: Tests bei jedem Commit ausführen
  • Test Coverage: Ziel: 80%+ Code Coverage (aber nicht blind)
  • TDD (Test-Driven Development): Erst Test schreiben, dann Code

6. Best Practices

Clean Code

  • Sprechende Variablen-/Funktionsnamen
  • Kleine Funktionen (eine Aufgabe)
  • Kommentare nur wo nötig
  • Konsistente Formatierung (Linter)
  • DRY-Prinzip beachten

Dokumentation

  • README.md für jedes Projekt
  • API-Dokumentation (Swagger/OpenAPI)
  • Architektur-Entscheidungen (ADRs)
  • Code-Kommentare (Warum, nicht Was)
  • Changelog für Releases

Testing

  • Unit Tests für alle Funktionen
  • Integration Tests für APIs
  • Test Coverage > 80%
  • Automated Testing in CI/CD
  • Test-First (TDD) wo möglich

Code Reviews

  • Pull Requests vor Merge
  • Mindestens 1-2 Reviewer
  • Konstruktives Feedback
  • Automated Checks (Linting)
  • Knowledge Sharing im Team

CI/CD Pipeline

  • Automated Builds bei jedem Commit
  • Automated Testing
  • Automated Deployment
  • Rollback-Fähigkeit
  • Infrastructure as Code

Security

  • Input Validation & Sanitization
  • Keine Hardcoded Secrets
  • Dependency Scanning
  • Regular Security Audits
  • OWASP Top 10 beachten

7. FAQ – Häufige Fragen & Antworten

Häufige Fragen zum Software Engineering

Was ist der Unterschied zwischen Programmieren und Software Engineering?

Programmieren ist das Schreiben von Code – die Umsetzung von Logik in eine Programmiersprache.

Software Engineering umfasst den gesamten Lebenszyklus: Anforderungsanalyse, Design, Implementierung, Testing, Deployment, Wartung. Es ist die systematische, ingenieurmäßige Herangehensweise an Softwareentwicklung.

Ein Programmierer schreibt Code, ein Software Engineer plant, entwirft, testet und wartet Software.

Warum sind Code Reviews wichtig?

Code Reviews sind essenziell für:

  • Qualitätssicherung: Fehler werden früh erkannt
  • Knowledge Sharing: Team lernt voneinander
  • Code-Konsistenz: Einheitlicher Stil im Projekt
  • Bug-Prävention: Vier Augen sehen mehr als zwei
  • Mentoring: Junior-Entwickler lernen von Seniors
Was ist technische Schuld?

Technische Schuld entsteht, wenn schnelle, suboptimale Lösungen implementiert werden – oft unter Zeitdruck.

Beispiele:

  • Code-Duplikate statt Refactoring
  • Fehlende Tests
  • Veraltete Dependencies
  • Workarounds statt sauberer Lösungen

Problem: Wie bei finanzieller Schuld fallen "Zinsen" an – der Code wird immer schwerer wartbar, neue Features dauern länger, Bugs häufen sich.

Lösung: Regelmäßig Refactoring betreiben, technische Schulden bewusst managen.

Was ist CI/CD und warum brauche ich das?

CI (Continuous Integration): Entwickler integrieren Code regelmäßig (mehrmals täglich) in ein gemeinsames Repository. Jeder Commit wird automatisch gebaut und getestet.

CD (Continuous Deployment/Delivery): Code wird automatisch in Produktionsumgebungen deployed.

Vorteile:

  • Schnelleres Feedback
  • Weniger Integrationsprobleme
  • Häufigere Releases
  • Höhere Code-Qualität
  • Weniger manuelle Arbeit

Tools: GitHub Actions, GitLab CI, Jenkins, CircleCI, Azure DevOps

Wie viel Testing ist genug?

Es gibt keine magische Zahl, aber bewährte Richtlinien:

  • Test-Pyramide: Viele Unit Tests (70%), weniger Integration Tests (20%), wenige E2E Tests (10%)
  • Code Coverage: Ziel 80%+ (aber nicht blind – 100% Coverage ≠ fehlerfrei)
  • Kritische Pfade: 100% Testabdeckung für sicherheitskritische Code
  • Business-Logik: Umfangreiche Tests für komplexe Logik

Wichtig: Tests sollten schnell, isoliert und wiederholbar sein. Schlechte Tests (langsam, flaky) sind schlimmer als keine Tests.

Was ist der Unterschied zwischen Agile und Scrum?

Agile ist ein Philosophie/Manifest – eine Denkweise für Softwareentwicklung (iterativ, kundenorientiert, flexibel).

Scrum ist ein Framework, das Agile implementiert – mit festen Rollen (Product Owner, Scrum Master, Team), Events (Sprint, Daily, Review) und Artefakten (Backlog, Increment).

Analogie: Agile ist wie "gesund essen", Scrum ist wie "die Paleo-Diät" – eine konkrete Methode, um Agile umzusetzen.

Andere Agile Frameworks: Kanban, XP (Extreme Programming), Lean.

Wie verhindere ich Spaghetti-Code?

Spaghetti-Code entsteht durch unstrukturierte Entwicklung. So vermeiden Sie ihn:

  • SOLID-Prinzipien: Klare Verantwortlichkeiten
  • DRY: Keine Code-Duplikate
  • Design Patterns: Bewährte Lösungen für häufige Probleme
  • Code Reviews: Feedback von Kollegen
  • Refactoring: Regelmäßig Code verbessern
  • Testing: Tests erzwingen saubere Architektur
Was sind Design Patterns?

Design Patterns (Entwurfsmuster) sind bewährte Lösungen für häufige Software-Design-Probleme.

Drei Kategorien:

  • Creational: Objekterzeugung (Singleton, Factory, Builder)
  • Structural: Objektkomposition (Adapter, Decorator, Facade)
  • Behavioral: Objektinteraktion (Observer, Strategy, Command)

Vorteile: Wiederverwendbarkeit, Wartbarkeit, Kommunikation im Team (gemeinsame Sprache).

Zusammenfassung

Die wichtigsten Punkte

  • Software Engineering: Systematische Entwicklung über den gesamten Lebenszyklus
  • SDLC: 6 Phasen – Anforderung, Design, Implementierung, Testing, Deployment, Wartung
  • Methodologien: Wasserfall (linear), Agile/Scrum (iterativ), Kanban (Flow), DevOps (CI/CD)
  • Design-Prinzipien: SOLID, DRY, KISS, YAGNI, Separation of Concerns
  • Testing: Unit (schnell), Integration (Module), System (E2E), Acceptance (User)
  • Best Practices: Clean Code, Dokumentation, Code Reviews, CI/CD, Security
  • FAQ: Technische Schuld, CI/CD, Test-Pyramide, Design Patterns

Enterprise-Tipps

  • Starten Sie mit Agile/Scrum: Für die meisten Projekte die beste Wahl
  • Investieren Sie in Testing: Automatische Tests sparen langfristig Zeit und Geld
  • CI/CD einführen: Automatisierung beschleunigt Releases und verbessert Qualität
  • Code Reviews etablieren: Vier Augen sehen mehr als zwei
  • Dokumentation pflegen: README, ADRs, API-Docs – Zukunftssicherung
  • Technische Schulden managen: Regelmäßig Refactoring betreiben

Weiterführende Themen

Programmiersprachen

Übersicht über Programmiersprachen – von Python bis Rust.

Zu Programmiersprachen
Algorithmen

Grundlegende Algorithmen – Sortieren, Suchen, Graphen.

Zu Algorithmen
Datenstrukturen

Arrays, Listen, Bäume, Graphen – wie Daten organisiert werden.

Zu Datenstrukturen
Design Patterns

Entwurfsmuster – bewährte Lösungen für häufige Probleme.

Zu Design Patterns