##  Pfadnavigation

1. [ Startseite ](/)
2. [ Software Testing & Qualität - Testautomatisierung, KI & Agilität ](/podcast/software-testing-qualitaet-testautomatisierung-ki-agilitaet)
3. Softwarequalität durch formale Methoden mathematisch beweisen

# Softwarequalität durch formale Methoden mathematisch beweisen

            **Podcast:**

   [Software Testing & Qualität - Testautomatisierung, KI & Agilität](/podcast/software-testing-qualitaet-testautomatisierung-ki-agilitaet)

              **Erscheinungsdatum:**

   10. März 2026

            **Länge:**

   00:31:34

    [         Link zur Episode (extern)   ](https://www.richard-seidl.com/de/podcast/qualitaet-formale-methoden)

 ![Formale Methoden in der Softwarequalität - Michael Sperber, Markus Schlegel](https://www.botcaster.de/sites/default/files/styles/podcast_n_episode_metadata_image_1x/public/2026-08/2fff97e1-88a3-4e80-8c74-2137a9c0f132.jpg.webp?itok=f7oDPQ68)

###   Formale Methoden in der Softwarequalität - Michael Sperber, Markus Schlegel

   10. März 2026 · [Software Testing & Qualität - Testautomatisierung, KI & Agilität](/podcast/software-testing-qualitaet-testautomatisierung-ki-agilitaet)

Kann Software fehlerfrei sein? Und lässt sich das sogar mathematisch beweisen, statt es nur durch unzählige Tests zu vermuten? In der aktuellen Folge des Podcasts *Software Testing & Qualität* taucht Host Richard Seidl gemeinsam mit den Experten Michael Sperber und Markus Schlegel in die faszinierende Welt der formalen Methoden ein. Aufgezeichnet auf dem QS-Tag 2025 in Frankfurt, beleuchtet das Gespräch einen Ansatz, der Qualitätssicherung von Grund auf neu denkt. Statt Fehler zu suchen, zielt er darauf ab, die Korrektheit von Software nachzuweisen. Die Episode liefert eine fundierte Einführung, erklärt die enge Verbindung zur funktionalen Programmierung und zeigt, warum diese Techniken weit mehr als nur ein akademisches Nischenthema sind - insbesondere für alle, die an sicherheitskritischen und hochzuverlässigen Systemen arbeiten.

## Das Wichtigste auf einen Blick

- **Mathematischer Beweis statt Testen:** Formale Methoden nutzen mathematische Logik, um zu beweisen, dass eine Software eine gegebene Spezifikation für *alle* möglichen Eingaben erfüllt. Dies geht weit über beispielbasierte Tests hinaus, die immer nur einen kleinen Ausschnitt abdecken können.
- **Funktionale Programmierung als ideale Basis:** Funktionale Programmiersprachen wie Haskell oder F-Sharp sind besonders gut für formale Methoden geeignet. Ihr deklarativer Stil, der beschreibt, *was* ein Ergebnis ist (statt *wie* es berechnet wird), ist der mathematischen Denkweise sehr ähnlich und erleichtert Beweise erheblich.
- **Die Spezifikation ist der Schlüssel:** Der gesamte Prozess beginnt mit einer präzisen, formalen Spezifikation - oft in Form einer mathematischen Gleichung oder Ungleichung. Sie beschreibt das gewünschte Verhalten allgemeingültig, anstatt sich auf einzelne Beispiele zu beschränken.
- **Werkzeuge unterstützen den Beweisprozess:** Sogenannte Beweisasistenten wie das Werkzeug Isabelle helfen Entwickler:innen, die Beweise computergestützt zu führen. Diese Beweise sind selbst Code, der versioniert und in eine CI-Pipeline integriert werden kann, um die Korrektheit bei jeder Änderung zu überprüfen.
- **Property-Based Testing als praktischer Einstieg:** Ein zugänglicher erster Schritt in diese Denkweise ist das Property-Based Testing. Hier formuliert man allgemeingültige Eigenschaften des Codes, die das Test-Framework dann automatisch mit einer großen Menge zufälliger Daten überprüft.

## Was sind formale Methoden? Mehr als nur Testen

Der Kerngedanke formaler Methoden ist, Qualität nicht nur zu prüfen, sondern mathematisch zu garantieren. Michael Sperber verdeutlicht dies am Beispiel eines Auto-Tachometers. Eine typische Test-Spezifikation würde vielleicht vier oder fünf Geschwindigkeiten definieren und das erwartete Ergebnis prüfen. Eine formale Spezifikation hingegen, wie sie etwa eine EU-Norm vorgibt, ist eine allgemeingültige mathematische Formel. Sie beschreibt die erlaubte Abweichung für *jede beliebige* Geschwindigkeit. Das Ziel ist es, zu beweisen, dass der Softwarecode diese Formel unter allen Umständen einhält.

Dabei geht es, wie Michael erklärt, um die Herstellung von Redundanz und Vertrauen. Man entwickelt das System einmal (der Code) und beschreibt es ein zweites Mal unabhängig davon (die Spezifikation). Der mathematische Beweis stellt dann sicher, dass beide Darstellungen übereinstimmen. Auch wenn es theoretische Lücken geben kann - etwa ein Fehler im Beweis-Tool selbst -, ist die erreichte Zuverlässigkeit laut empirischen Untersuchungen um ein Vielfaches höher als bei traditionellen Testmethoden. Das Ergebnis ist eine Software, die die Experten als bomben-sicher bezeichnen.

## Funktionale Programmierung: Die Brücke zur Mathematik

Warum spielt die funktionale Programmierung eine so große Rolle? Markus Schlegel und Michael Sperber erklären den fundamentalen Unterschied zur weitverbreiteten imperativen Programmierung (wie in C oder Java). In der imperativen Welt beschreiben wir eine Abfolge von Anweisungen, die den Zustand des Computers verändern. Der Befehl `x = x + 1` ist dafür ein klassisches Beispiel. Mathematisch ist diese Aussage Unsinn, denn eine Zahl kann nicht gleich sie selbst plus eins sein. In der Programmierung funktioniert es, weil es eine Anweisung ist: Nimm den alten Wert von x, addiere eins und speichere das Ergebnis wieder in x. Diese Zustandsänderungen machen es extrem schwierig, allgemeingültige Aussagen über das Verhalten des Programms zu treffen.

Die funktionale Programmierung vermeidet diese veränderlichen Zustände. Hier werden Programme als eine Komposition von reinen Funktionen verstanden, die wie in der Mathematik für dieselbe Eingabe immer dieselbe Ausgabe liefern. Eine Funktion ist im Grunde eine Gleichung. Diese Nähe zur Mathematik macht es wesentlich einfacher, den Code in ein formales Modell zu übersetzen und darüber Beweise zu führen. Obwohl der Einstieg ein Umdenken erfordert - weg vom Wie der Computerabläufe hin zum Was der fachlichen Logik -, ist die Entwicklung laut Michael oft sogar effizienter, da von vornherein weniger Fehler entstehen und das Debugging einfacher wird.

## Der Beweisprozess in der Praxis: Von der Spezifikation zum Tool

Der Weg zur bewiesenen Korrektheit ist ein strukturierter Prozess, der von spezialisierten Werkzeugen unterstützt wird. Alles beginnt mit der formalen Spezifikation. Anschließend wird der Code - idealerweise in einer funktionalen Sprache - entwickelt. Die eigentliche Beweisführung ist keine rein manuelle Tätigkeit am Whiteboard, sondern wird durch Computerprogramme unterstützt.

Eine erste, oft unbewusst genutzte formale Methode sind bereits die **Typsysteme** von Programmiersprachen. Sie beweisen, dass bestimmte Fehlerklassen, wie die Addition einer Zahl zu einem Text, nicht auftreten können. Moderne funktionale Sprachen wie Haskell gehen mit sogenannten Dependent Types noch viel weiter und erlauben es, komplexe Spezifikationen direkt im Typsystem abzubilden, die der Compiler dann automatisch prüft.

Für komplexere Beweise kommen **Beweisasistenten** wie Isabelle zum Einsatz. Diese Tools ermöglichen es, Beweise interaktiv zu konstruieren. Der Mensch gibt die Strategie vor (z.B. führe einen Induktionsbeweis), und das Tool übernimmt die mühsamen, repetitiven Umformungsschritte und stellt sicher, dass jeder Schritt logisch korrekt ist. Das Ergebnis ist eine Beweisdatei, die wie Quellcode behandelt, versioniert und in die CI-Pipeline integriert werden kann. Ein fehlerhafter Beweis führt dann, genau wie ein fehlgeschlagener Unit-Test, zu einem Broken Build.

## Nischenthema oder Zukunft der Qualitätssicherung?

Trotz ihrer beeindruckenden Fähigkeiten sind formale Methoden bis heute ein Nischenthema geblieben. Michael beschreibt die Szene als eine Art Parallelwelt mit eigenen Sprachen, Werkzeugen und einer starken akademischen Verankerung. Der Grund dafür liegt vor allem im erforderlichen Umdenken und dem initialen Lernaufwand. Dennoch sickern die Konzepte langsam in den Mainstream durch: Viele moderne imperative Sprachen haben längst funktionale Elemente übernommen.

Die Experten sind sich einig, dass die Techniken universell nützlich sind und nicht nur für Raumfahrt oder Medizintechnik Relevanz haben. Überall dort, wo Zuverlässigkeit und Korrektheit entscheidend sind, bieten sie einen unschätzbaren Mehrwert. Für die Testing-Community eröffnet sich hier ein Feld, das eine völlig neue Perspektive auf Qualität ermöglicht - eine, die auf konstruktiver Sicherheit statt auf reaktiver Fehlersuche basiert.

## Praktische Schritte für den Einstieg

Wie kannst Du nun selbst erste Schritte in diese Welt wagen? Die Gäste geben konkrete Empfehlungen:

1. **Beginne mit der Spezifikation:** Der wichtigste erste Schritt ist ein mentales Umdenken. Versuche, das Verhalten deiner Software nicht nur in Beispielen, sondern in allgemeingültigen Eigenschaften und Regeln zu beschreiben. Allein diese Übung schärft das Verständnis für die fachlichen Anforderungen enorm.
2. **Probiere Property-Based Testing aus:** Dies ist der von Markus empfohlene Lifehack für den Einstieg. Fast jede Programmiersprache bietet heute Bibliotheken dafür. Du formulierst eine Eigenschaft (z.B. Das Umkehren einer Liste und anschließendes erneutes Umkehren ergibt wieder die ursprüngliche Liste) und das Framework generiert Hunderte von Testfällen, um Gegenbeispiele zu finden.
3. **Lerne eine funktionale Sprache:** Um das grundlegende Paradigma zu verstehen, lohnt sich ein Blick in eine funktionale Programmiersprache. Michael empfiehlt hierfür sein kostenloses Buch und die Lernplattform *deinprogramm.de*, die einen didaktisch aufbereiteten Zugang für Einsteiger bietet.
4. **Verschaffe Dir einen Überblick:** Für einen strukturierten Überblick über das gesamte Feld der formalen Methoden im Kontext der Softwarequalität verweisen die Experten auf das neu entwickelte Curriculum des International Software Architecture Quality Board (ISAQB).

---

 version="1.0" encoding="UTF-8"?
      .st0 {
        fill: #010101;
      }

      .st1 {
        fill: #b0c0b3;
      }

      .st2 {
        fill: #3b3a3b;
      }

      .st3 {
        fill: #3a3a3a;
      }

      .st4 {
        fill: #5e7185;
      }

      .st5 {
        fill: #f9eddd;
      }

      .st6 {
        fill: #000100;
      }

      .st7 {
        fill: #aebeb3;
      }

      .st8 {
        fill: #fefefe;
      }

      .st9 {
        fill: #7f93a8;
      }

      .st10 {
        fill: #f8f0df;
      }

      .st11 {
        fill: #fbf0df;
      }

      .st12 {
        fill: #afbfb2;
      }

      .st13 {
        fill: #f7eedd;
      }

      .st14 {
        fill: #fdfdfd;
      }
                                                                                   Botcaster

  **Zusammengefasst von Anja Schirwinski**

Ich beschäftige mich beruflich wie privat mit Künstlicher Intelligenz - von konkreten Tools im Arbeitsalltag bis zu den größeren Fragen, die dabei aufkommen. Viele der Themen, die in Podcasts besprochen werden, begegnen mir in Projekten immer wieder. Deshalb fasse ich hier die für mich interessantesten Podcastfolgen zusammen und ordne sie aus der Praxis ein.

[Mehr über das Projekt Botcaster](/ueber-uns)

##  Themen

 - [  Softwareentwicklung mit KI  ](/podcasts/themen/softwareentwicklung-mit-ki)
- [  Testen und Qualität  ](/podcasts/themen/testen-qualitaet)

**Hinweis:** *Diese Zusammenfassung wurde mit Hilfe von KI aus dem Transkript der Podcast-Episode generiert.*

Alle Inhalte auf Botcaster beruhen auf öffentlich zugänglichen Podcasts rund um Künstliche Intelligenz. Wir fassen die Episoden nach bestem Wissen zusammen, übernehmen jedoch keine Gewähr für Vollständigkeit, Aktualität oder Richtigkeit der Inhalte. Die Rechte an den Original-Podcasts und -Inhalten liegen ausschließlich bei den jeweiligen Urheber:innen.

         ## Shownotes

   In dieser Episode spreche ich mit Michael Sperber und Markus Schlegel über formale Methoden – die vielleicht unbekannteste und gleichzeitig mächtigste Technik, um Software wirklich korrekt zu machen. Während wir beim Testen oft nur ein paar Beispiele prüfen, ermöglichen formale Methoden Software mathematisch zu beweisen, dass sie für alle möglichen Eingaben das Richtige tut. Die beiden zeigen, warum funktionale Programmierung der Schlüssel dazu ist, wie Property Based Testing der erste praktische Schritt sein kann und weshalb dieser Ansatz nicht nur sicherer, sondern oft sogar effizienter ist als klassische Entwicklung.