Analyse: “Optimierung der OZG-Umsetzung auf IT-Seite”

Die OZG-Umsetzung erfordert einen komplexen Wandel in Regulatorik, Kultur, Abläufen und IT.
Die OZG-Umsetzung erfordert einen komplexen Wandel.

Zusammenfassung: Hebel für die Optimierung

  • Empfehlenswerte methodischen Grundlagen für die Optimierung des OZG-Vorgehens
    • Nutzer-zentriertes Design
    • Bewährte Software Engineering Praktiken
  • Empfehlenswerte Optimierungs-Maßnahmen
    • Inkrementelles Vorgehen: Die Optimierung erfolgt in kurzen Inkrementen mit Feedback-Zyklen, ausgerichtet auf Risiko-Reduzierung und positives Kosten/Nutzen-Verhältnis.
    • Kanban: Durch eine Kanban-ähnliche Projektsteuerung ermöglicht sie eine sichere Navigation in volatilem Umfeld, Kosten-Nutzen-Optimierung und kontinuierliche Verbesserung.
    • MDD: Durch Model Driven Development fördert sie Skalierung und Nachnutzung.

Warum diese Analyse?

Die Umsetzung des Onlinezugangsgesetzes ist eine große Herausforderung für den Öffentlichen Bereich: Mehr als 6000 Leistungen von Bund, Ländern und Kommunen sollen bis Ende 2022 auch digital über Verwaltungsportale angeboten werden.

Angesichts einen hohen Zeitdrucks und knapper Mittel stellt sich bei diesem Großprojekt die Frage, wie die beteiligten Organisationen ihr Vorgehen schnell optimieren können. Denn klar ist: Ein Ad-hoc-Vorgehen ohne Rücksicht auf Größe und Komplexität des Vorhabens sowie die zu erwartende lange Lebensdauer der digitalisierten Leistungen wäre ziemlich riskant.

Mehrere Monate Einblick in das OZG-Vorgehen einiger vor allem bayerischer Großstädte haben mich alarmiert und dazu veranlasst, meine Erfahrungen mit der Entwicklung unternehmenskritischer IT-Systeme zu nutzen, um das praktizierte Ad-hoc-Vorgehen zu analysieren und Optimierungs-Maßnahmen auf IT-Seite vorzuschlagen.

Ergebnisse kurz gefasst

OZG-Optimierung_Kurzfassung.V1.0

Ergebnisse ausführlich

OZG-Optimierung_V1.0

Analyse: “Optimierung der OZG-Umsetzung auf IT-Seite” Read More »

PDF-Formulare analysieren mit Python

Wozu ist das gut?

Wenn der Öffentliche Sektor seine Leistungen online anbieten will, gibt es meist schon entsprechende Antragsformulare in Papierform oder als Datei zum Herunterladen. Gedruckte und heruntergeladene Variante basieren in der Regel auf einer Vorlage im Portable Document Format (PDF). PDF-Dateien sind daher häufig ein Ausgangspunkt beim Entwurf von digitalen Antragsstrecken.

Allerdings ist es mühsam, aus PDF-Dateien diejenigen Informationen herauszuklauben, die man für die Spezifikation einer Antragsstrecke braucht, z.B. :

  • Gliederung des Formulars in Abschnitte
  • Eingabefelder mit ihren Bezeichnungen und erlaubten Eingaben
  • Zusatzinformationen, die beim korrekten Ausfüllen helfen sollen

In diesem Beitrag beschreibe ich ein Python-Skript, das einem langweilige Routineaufgaben bei der Analyse von PDF-Dateien abnimmt.

Die Analyse erfolgt schrittweise

Die Analyse eines PDF-Formulars erfolgt in mehreren Schritten:

import json
from pathlib import Path

# Konfiguration einlesen
with open("config.json", "r") as f:
    config = json.load(f)

pdf_dateien = Path(config['input_dir']).glob('**/*.pdf')
for pdf_datei in pdf_dateien:
    
    print("Analysiere: ", pdf_datei)
    pages = Text_extrahieren(pdf_datei)
    data, columns = Text_zu_Tabelle(pages)
    df = Felder_identifizieren(data, columns)
    df = Abschnitte_identifizieren(df)
    df = Zeilen_klassifizieren(df)

    excel_datei = Path(f'{pdf_datei}.xlsx')
    print("Ergebnis:   ", excel_datei, "\n")
    Dataframe_schreiben(df, excel_datei)

Das Skript erwartet die zu analysierenden PDF-Dateien in einem Verzeichnis, das man in der Konfigurationsdatei config.json als Parameter input_dir angeben kann. Die Python-Bibliothek pathlib ermöglich es, unabhängig von den Konventionen des verwendeten Betriebssystems (Windows, Linux usw.) über die PDF-Dateien zu iterieren und sie in folgenden Schritten zu analysieren:

  1. Texte aus dem PDF-Formular extrahieren und in eine tabellarische Form bringen, wobei die Texte seitenweise von rechts oben nach links unten ausgewertet werden
  2. Bedeutung der Texte analysieren

Beim zweiten Schritt nutzt man aus, dass PDF-Formulare oft eine Struktur aufweisen, die etwas über die Bedeutung der extrahierten Texte aussagt:

  1. Überschriften von Formular-Abschnitten können durchnummeriert sein, entweder mit Ziffern oder mit Buchstaben
  2. Felder können ebenfalls fortlaufend nummeriert sein

Hier ein Beispiel, in dem man Überschriften und Eingabefelder an ihrer fortlaufenden Nummerierung erkennen kann:

Formular mit nummerierten Überschriften und Eingabefeldern

Je PDF-Formular speichert das Skript die Analyse-Ergebnisse in einer Excel-Datei, deren Name sich aus dem der PDF-Datei plus angehängtem Suffix “.xlsx” ergibt:

Excel-Datei mit Ergebnissen der PDF-Analyse

Die erste Spalte gibt an, wie das Skript den Text klassifiziert hat, der in der Spalte “Inhalt” steht:

  • Abschnitt: Überschrift eines Abschnitts
  • Eingabe: Bezeichnung eines Eingabefelds
  • Sonstiges: Text, der nicht genauer klassifiziert werden konnte

Die Spalte “Text” enthält zum Vergleich die originale Zeile, die aus dem PDF-Formular extrahiert wurde. Man kann sie ebenso wie die folgenden Spalten dazu verwenden, Fehlern bei Extraktion und Klassifikation auf die Spur zu kommen.

Beim Extrahieren aus PDF hilft ein Klempner

Für Python gibt es mehrere Bibliotheken zum Auswerten von PDF-Dateien. In diesem Skript habe ich pdfplumber verwendet. So kann man auch ohne PDF-Spezialwissen Text aus PDF-Dateien extrahieren. Dabei wird der extrahierte Text seitenweise ausgelesen, auch der Text, der in Tabellen enthalten ist:

from operator import itemgetter
import pdfplumber


def check_bboxes(word, table_bbox):
    """
    Prüft, ob word innerhalb von table_bbox liegt.
    table_bbox ist der Rahmen (bounding box) um die Tabelle.
    """
    l = word['x0'], word['top'], word['x1'], word['bottom']
    r = table_bbox
    return l[0] > r[0] and 
           l[1] > r[1] and 
           l[2] < r[2] and 
           l[3] < r[3]


def Text_extrahieren(pdf_datei):
    """
    Extrahiert Text und Tabellen aus einem PDF-Formular.
    
    IN:
        pdf_datei    Pfad der zu analysierenden PDF-Datei

    RETURN:
        Liste von Seiten, die Listen von Zeilen enthalten
           'text'  = Zeile mit Text außerhalb von Tabellen
           'table' = Zeile mit Text innerhalb von Tabellen
    """

    with pdfplumber.open(pdf_datei) as pdf:
        
        # Seiteninhalte extrahieren
        pages = []
        for page in pdf.pages:

            # Tabellen mit ihren Begrenzungen extrahieren
            tables = page.find_tables()
            table_bboxes = [i.bbox for i in tables]
            tables = [{'table': i.extract(), 
                       'top': i.bbox[1]
                      } for i in tables
                     ]

            # Wörter außerhalb von Tabellen ermitteln
            non_table_words = [
                     word for word in page.extract_words() 
                     if not any([
                     check_bboxes(word, table_bbox) 
                     for table_bbox in table_bboxes])]

            # Zeilen der Seite in Liste zusammenstellen
            lines = []
            for cluster in pdfplumber.utils.cluster_objects(
                    non_table_words + tables, 
                    itemgetter('top'), 
                    tolerance = 5):
                     if 'text' in cluster[0]:
                       lines.append(' '.join(
                                    [i.get('text', '') 
                                     for i in cluster
                                    ]))
                     elif 'table' in cluster[0]:
                        lines.append(cluster[0]['table'])
            
            # Zeilen der neuen Seite hinzufügen
            # zur Liste der Seiten
            pages.append(lines)

    return(pages)

Das Ergebnis pages ist eine Liste von Seiten. Für jede Seite enthält es eine Liste der darin gefundenen Zeilen. Diese geschachtelte Liste wird später in eine Tabelle umgewandelt und bei der weiteren Analyse angereichert.

Das vollständige Skript findet man im folgenden Kapitel.

Quelldateien

Das Python-Skript wurde hier mit dem Suffix “.txt” statt “.py” bereitgestellt, um Berechtigungsprobleme zu vermeiden.

Hier requirements.txt mit den verwendeten Bibliotheken:

Die Konfigurationsdatei config.json hat folgenden Inhalt:

{
  "input_dir" : "./pdf_dir"
}

PDF-Formulare analysieren mit Python Read More »

Innovation: Efficient Text Blocks for Web Forms

Summary

After the subject matter expert has approved the text change, the new content appears automagically on the online service page as fast as the CI/CD pipeline allows. No programmer or tester involved.

How this can be achieved is explained here with a simple proof of concept applying basic principles of software engineering. While this proof of concept is based on Confluence and Angular because of their widespread use, the underlying approach can easily be implemented on other platforms due to its simplicity.

When Does Text Matter?

Text is a major part of online services such as applying for a consumer loan or for a resident parking permit. Texts describe what the service offers, what data the customer has to provide, how privacy will be protected and so on.

It may require a lot of time and effort to keep texts up to date, for example with laws and regulations, new customer insight and changing market conditions.

In particular an efficient handling of text does matter for text-intensive online services that

  • are important to the service provider: Major failures can cause severe reputational damage or large financial losses.
  • require a lot of effort to develop and maintain: The team usually consists of more than 10 people.
  • are planned to have a long lifespan, typically many years.

The following software engineering principles help to master the texts of such services:

  1. Avoid manual redundancy
  2. Capture the logical essence
  3. Automate boring tasks
  4. Take advantage of synergies

The subsequent sections explain each of these points.

Avoiding Manual Redundancy

Redundancy is harmful, if it is created and maintained manually. In this case it is only a matter of time until things will become inconsistent. Inconsistency is the highway to hell for large amounts of text.

In order to avoid manual redundancy,

  • specify a text only in one place in a format that is complete and clear enough for using this text in many different contexts (see Capturing the Logical Essence)
  • use tools to propagate text changes to specification documents, web site code, PDF output, test parameters etc. (see Automate Boring Tasks)

Capturing the Logical Essence

A text block is not just a bunch of words, it has

  • a unique identifier that allows you to reference the text block
  • a sharp boundary that separates the text from the rest of the world
  • a logical structure consisting of headings, paragraphs, lists, links and so on.

For readers as well as for tools it is important to not hide the logical structure in a prose similar to Victorian novels but to make it explicit. This can be achieved by using a markup language like Markdown or HTML. Whatever format you choose, it should be supported by

  • editors suited for subject matter experts
  • tools that make it easy to read, write and transform this format
Confluence page defining a text block with Page Properties (subject matter expert, reviewer, status), description and content (embedded into an Excerpt macro).
Confluence page defining a text block.

In the proof of concept each text block is a Confluence page (see screen shot above), since pages offer many features for handling text:

  • Confluence provides an editor that makes it easy to specify the logical text structure.
  • Internally Confluence stores the pages as HTML, so that you can use many tools for further text processing.
  • Meta data enable you to manage text blocks easily and to configure a Confluence workflow for text review and approval. The above screen shot shows some of the meta data within the Page Properties macro: SME (subject matter expert), reviewer and status of the text block. In addition the page is labeled as “textblock”.
  • Confluence macros are available to seamlessly include a text block into specification documents (Excerpt macro and Excerpt Include macro). So you can specify a text in a single place and reuse it across the specification while Confluence handles the dependencies for you.
  • Confluence offers a REST API and a Python package to access the text blocks with tools for the automation of boring tasks.
Specification of an introductory page for "Application for a Foreign Freelancer Permit" in tabular form containing text blocks as content components embedded via Excerpt Include macro.
Text block included into the specification of the introductory page of an online service. The cursor is placed inside the text block so that the text block content (embedded via the Excerpt Include macro) is highlighted and surrounded by a blue border line.
Confluence traces the usage of text blocks: The section “Incoming Links” of the text block’s “Page Information” lists all pages that reference the text block (in this case via the Excerpt Include macro). You can find the “Page Information” in the “Advanced Details” section of the page menu.

Automating Boring Tasks

Using a specified text in implementation or testing requires schematic routine tasks: extract the text from the specification, reformat it, integrate it into source code or test scripts, review and test your results.

While such schematic routine tasks are boring and error-prone for humans, they are well suited for computers. You just need to apply your programming skills not only to the services you build but also to the development process itself.

Python Script

A simple Python script extracts text blocks from Confluence using Atlassian’s Confluence package. The script is generously commented in order to make it comprehensible for programmers who are not proficient in Python.

The extraction script provides text blocks in several formats:

  • HTML for Angular component templates
  • Plain text for Angular tool tips
  • Excel for review

A programmer who wants to use a text block in his Angular code just needs to insert a macro at the right place with the text block id as parameter: The rest is done automatically by the Angular ahead-of-time (AOT) compiler.

Using Text Blocks in Web Pages

The next sceen shot shows a demo implementation of an online service’s introductory page. How all the text content of this page is provided from Confluence by using extraction script and macro is described in the following sections.

Sceen shot of demo implementation.
Demo implementation of the introductory page of an online service using text blocks. The Login button’s tooltip is displayed since the mouse hovered over the Login button when the screen shot was taken (mouse not visible on screen shot).

The code below defines the introduction page of the “Application for a Foreign Freelancer Permit” (app.component.html). Some of the specified text blocks can be found here as app-tbl* elements representing Angular components with the text block content as component template.

<div>
   <div>
      <h1>{{title}}</h1>
   </div>

   <app-tbl001002></app-tbl001002>
   <app-tbl001></app-tbl001>
   <app-tbl001001></app-tbl001001>
   <app-tbl002></app-tbl002>
   <app-tbl003></app-tbl003>

   <div class = "button-row">
      <button mat-raised-button
            color = "primary"
            matTooltip = {{loginTooltip}}
            matTooltipClass = "matTooltipLinebreak"
            aria-label = "Login button with tooltip">
         Login
      </button>
      <button mat-raised-button
            matTooltip = {{registerTooltip}}
            matTooltipClass = "matTooltipLinebreak"
            aria-label = "Register button with tooltip">
         Register
      </button>
   </div>
</div>

Here as an example the text block component tbl001002.component.ts defining the element app-tbl001002:

import { Component, OnInit } from '@angular/core';
import { includeText } from '../includeText';

@Component({
  selector: 'app-tbl001002',
  //templateUrl: './tbl001002.component.html',
  template:	includeText("TBL001002"),
  styleUrls: ['./tbl001002.component.css']
})
export class Tbl001002Component implements OnInit {

  constructor() { }

  ngOnInit(): void {
  }

}

The developer replaced the default template URL with a template filled by the includeText macro with the content of text block TBL001002.

IncludeText Macro

And here the definition of the includeText macro. All the work is done by the return statement:

// includeText.ts

import { texts } from '../../texts/texts'; // text definitions

/**
 * AOT macro for including reusable text blocks
 * @param	id 		Identifier of the text to include
 * @return	Text to include; unknown id returns 'undefined' value at build time
 */


export function includeText(id: string): string {
	return texts[id];
}

Actually at the time of writing, an AOT macro can consist only of a single statement – the return statement.

The includeText macro uses the dictionary “texts” defined in texts.ts. This file is generated by the above Python script:

// GENERATED CODE: DO NOT CHANGE MANUALLY!

export const texts: { [key: string]: string } =
{
"TBL001":
"<div tb_id=\"TBL001\" title=\"Privacy Statement\"><h2>We respect your privacy</h2><p>In this application form we will ask you only for personal data required to process your application. We strictly adhere to privacy laws and regulations. For further information, please see:</p></div>",

"TBL001001":
"<div tb_id=\"TBL001001\" title=\"Privacy Statement\"><ul><li><p>Specific <a href=\"https://www.to_be_defined.html\"><em>Privacy Statement for this Application</em></a></p></li></ul></div>",

"TBL001001_plain":
`- Specific Privacy Statement for this Application
`,

...

}

The includeText macro can be called wherever a string is allowed. In app.component.ts the text for login and register button are provided by calling the includeText macro with appropriate text block ids. Here the plain format of the text blocks is used instead of the html format:

/* Demo: reusable textblocks
*/

import { Component } from '@angular/core';
import { includeText } from './includeText';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',  
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  title = 'Application for a Foreign Freelancer Permit';
  loginTooltip = includeText("TBL004_plain");
  registerTooltip = includeText("TBL005_plain");
}

Taking Advantage of Synergies

Development and maintenance of online services is a complex task requiring close cooperation across many disciplines. This means that a small change like introducing text blocks as a means of specification can have the potential to improve many other aspects of your project, if you take advantage of synergies.

Here some examples:

  • Optimize testing
    • On the one hand the text block tools have to be tested to ensure they work as intended.
    • One the other hand such unit tests make it obsolet to test whether the texts displayed on the web site have exactly the same content as the specified texts.
    • It remains to be tested that a specific text block is shown at the right place under the right condition.
      • Usually these requirements are much less subject to change than the text block content.
      • With unique ids it is no longer necessary for a text script to know the text content to find out where a text is located. Instead it can look for the text block’s id. The exctraction script generates the text block id into the div element that encloses the text block content.
        Example:
        <div tb_id=\”TBL001\” title=\”Privacy Statement\”>
  • Tracing text usage
    • Since each text has a unique id you can trace the usage of a text throughout the system (specification documents, source code, text scripts and so on).
    • This makes it easier to analyse the impact of text changes: In what contexts do you use a particular text block? Will the intended text change be compatible with all the contexts where the text is currently used?
  • Reduce time to market for text changes
    • Texts blocks can be used to reduce the time to market for text changes drastically (provided that you adapt the tool chain of your project accordingly):
      • After subject matter experts have edited a text block and reviewed / approved the change, the tool chain automatically extracts the new version from the specification and integrates it into the source code.
      • Meanwhile developers and testers can spend their time with tasks that are more challenging and not prone to automation.

What next?

If you would like to apply this approach to your own project:

  • You should agree with the stakeholders on a text management process: triggers for text changes, standards for a customer friendly language, reviews, approvals etc.
  • Concerning the extraction of text blocks from your Content Management System, you can take the above script as a starting point. However you should add some exception handling for robustness and implement unit tests to make sure it works as intended.

Perhaps this little example has whetted your appetite for more efficiency through software engineering in your project? In case you need some advice please feel free to contact me. I would also be glad to receive any feedback on the approach presented here.

Innovation: Efficient Text Blocks for Web Forms Read More »

Analyse: Logistiker ohne Gehirn – Blob schlägt KI

Er fristet sein unscheinbares Dasein, indem er neue Ausläufer in Richtung frischer Nahrung voranschiebt, während er sich von bereits erschöpften Resten organischen Materials zurückzieht: der Schleimpilz Physarum polycephalum. Fremdartiger als dieser Blob könnte auch ein Alien auf einem Jupitermond kaum aussehen.

Der Schleimpilz Physarum polycepalum überzieht einen verrottenden Ast mit seinem Geflecht.
Der Schleimpilz Physarum polycephalum überzieht einen verrottenden Ast mit seinem Geflecht. (Quelle: frankenstoen, CC BY 2.5 https://creativecommons.org/licenses/by/2.5, via Wikimedia Commons)

Unermüdlich sorgt er dafür, dass die Erde nicht in organischen Abfällen erstickt. Und geht dabei ziemlich raffiniert vor, obwohl er weder über ein Gehirn noch über Nervenzellen verfügt.

Davon kann sich jeder selbst überzeugen, der ihm ein paar Haferlocken als Nahrung anbietet, die er auf die Tokioter U-Bahn-Stationen verteilt, natürlich nicht in echt, sondern auf einem maßstabsgetreuen Stadtplan.

Sobald unser Miniatur-Logistiker die Haferflocken bemerkt, bildet er Ausläufer, um sie als Nahrungsquellen zu erschließen. Dabei entwickelt er allmählich ein Netzwerk, das verblüffend dem Tokioter Streckennetz ähnelt.

Wenn man die Haferflocken mehr oder weniger stark aufhäuft je nach der Passagierfrequenz einer Station, spiegelt die Dicke der Ausläufer sogar die Durchflussrate der Bahnstrecken wider.

Je genauer Wissenschaftler hinschauen, um so mehr Überraschungen hält Physarum polycephalum für sie bereit. So kann er z.B. mühelos den kürzesten Weg durch ein Labyrinth finden.

Physarum polycephalum ist also ein ausgefuchster Logistiker. Mehr noch: Dieser Einzeller schlägt unsere besten KI-Programme um viele Größenordnungen – nämlich in Punkto Nachhaltigkeit:

  • Er kommt ohne aufwändige Infrastrukturen aus, also ohne Stromnetz, Datenleitungen, Klimaanlagen, usw.
  • Er verbraucht fast keine Energie. Und wenn, stammt die ja aus organischen Abfällen.
  • Er ist vollständig biologisch abbaubar!

Wen Physarum polycephalum nun für die wunderbare Welt der Pilze entflammt hat, den muss ich als gelernter Diplom-Biologe leider enttäuschen: “Schleimpilze” sind gar keine Pilze, sondern gehören zu den Myxogastria-Amöben, von denen es rund 900 Arten gibt, vorwiegend in den Wäldern der gemäßigten Breiten. Diese winzigen Amöben können in bestimmten Entwicklungsphasen zu Syncytien verschmelzen, sodass man sie auch ohne Lupe sehen kann. Zur Vermehrung bilden sie Fruchtkörper (im Bild oben die gewölbte Zone rechts). Während die Fruchtkörper vieler echter Pilze auf dem menschlichen Speiseplan stehen, werden die Myxogastria nicht verzehrt – abgesehen von der Gelben Lohblüte, die man in Veracruz gegrillt als caca de luna genießt.

Analyse: Logistiker ohne Gehirn – Blob schlägt KI Read More »

Innovation: “Genom-Analyse” eines Fachkonzepts

Die Innovation

Verfahren aus der Genom-Analyse habe ich eingesetzt, um Redundanzen im komplexen Fachkonzept eines Großprojekts aufzuspüren. Die Analyse-Ergebnisse ermöglichten es dem Projekt, die Redundanzen zu priorisieren und ihre schrittweise Bereinigung zu planen. Diese Reduzierung hat dazu beigetragen, die Time-to-Market neuer fachlicher Anforderungen zu halbieren.

Das Problem

In diesem Projekt gab es viele Ursachen für eine lange Time-to-Market neuer Anforderungen. Mit der “Genom-Analyse” des Fachkonzepts wollte man die beiden folgenden Ursachen entschärfen

  • Beim Test neuer Releases tauchten oft so viele Fehler auf, dass das Team sich mächtig ins Zeug legen musste, um den Releasetermin nicht zu gefährden.
  • Auch kleine fachliche Änderungen konnten unverhältnismäßig aufwändig sein. Bei der Releaseplanung musste man entweder das System außerordentlich gut kennen oder die anstehende Änderung sehr sorgfältig analysieren, um nicht später bei der Umsetzung eine böse Überraschung zu erleben.

Eine Ursachenforschung ergab, dass diese beiden Probleme oft dieselbe Ursache hatten: Redundante Passagen im Fachkonzept wurden auf inkonsistente Weise geändert. Die Fachliche Chefdesignerin des Projekts vermutete, dass in den Hunderten von Seiten akribischer Fachkonzeptprosa noch viele verborgene Redundanzen auf ihre Chance lauerten, den Adrenalinspiegel des Teams in die Höhe zu treiben.

Sie bat mich daher um eine Redundanzanalyse des Fachkonzepts:

  • Welche Textblöcke sind redundant?
  • Welchen Text enthalten die verschiedenen Varianten?
  • An welchen Stellen kommt ein redundanter Textblock jeweils vor?
  • Wie ähnlich sind sich die verschiedenen Varianten eines Textblocks? Am besten wäre hier eine Kennzahl, die in die Priorisierung der Redundanzbereinigung einfließen kann.

Wir diskutierten diese Aufgabe eine Weile und erfuhr folgende Details über die Entstehung der gefürchteten Redundanzen:

  • Ein bestimmter Verarbeitungsschritt soll auch in einer weiteren Verarbeitung durchgeführt werden, z.B. wird eine Intervallberechnung für die Krankenversicherung auch für die Pflegeversicherung benötigt.
  • Nun kopiert man den betreffenden Abschnitt und passt die Kopie an die Besonderheiten der Pflegeversicherung an:
    • Vor allem tauscht man dabei die im Text referenzierten Attribute des fachlichen Datenmodells aus, denn die Daten zur Pflegeversicherung sind in speziellen Pflegeversicherungs-Attributen gespeichert.
    • Es kann aber auch sein, dass die Verarbeitung der Pflegeversicherung leicht derjenigen der Krankenversicherung abweicht und der kopierte Abschnitt entsprechend überarbeitet werden muss.
  • Wenn die Kopien eines redundanten Abschnitts geändert werden, z.B. wegen einer neuen fachlichen Anforderung, kann es vorkommen,
    • dass sich die überarbeiteten Kopien am Ende unterscheiden, etwa weil verschiedene Personen die Änderungen parallel durchgeführt haben, um sie schneller abschließen zu können oder
    • dass man Kopien übersieht, die daher auf dem alten Stand bleiben.

Die Lösung

Als Biologe ist mir eine Analogie ins Auge gesprungen zwischen dem redundanten Fachkonzept und dem Farbsehen beim Menschen. Und schon hatte ich den Schlüssel für die Lösung.

Spoiler alert: Im nächsten Absatz lüfte ich das Geheimnis. Wer den Zusammenhang selbst ausknobeln möchte, sollte daher nicht gleich weiterlesen.

Ein Mensch hat für das Farbsehen normalerweise drei Sehpigmente, deren Absoptionsmaximum im roten, grünen beziehungsweise blauen Bereich des Lichtspektrums liegt. Das rote und das grüne Sehpigment ähnlich einander stark: Tatsächlich zeigten genetische Analysen, dass zunächst das Gen für das grüne Sehpigment dupliziert wurde, genauer gesagt das Gen für den Proteinanteil des Pigments. Durch diese Mutation entstanden zwei identische Versionen desselben Pigments. Die beiden Kopien haben sich im Lauf einiger Jahrmillionen durch zusätzlich Mutationen immer weiter auseinander entwickelt. Also ähnlich wie die redundanten Abschnitte im Fachkonzept. Aufgeklärt hat man diese Evolutionsgeschichte durch die Analyse der Genome verschiedener Tierarten, insbesondere von Primaten. Ich brauchte also “nur” eine Art von “Genom-Analyse” für das Fachkonzept zu machen.

Wahl des Werkzeugs

Welches Werkzeug ich für die Redundanzanalyse am besten verwenden sollte, lag also auf der Hand:

  • Bei Genomanalysen werden vor allem Python und seine mächtigen wissenschaftlichen Bibliotheken eingesetzt.
  • Python verwendet man auch gern für Textanalysen.
  • Python kann gut mit regulären Ausdrücken umgehen, wie ich sie brauchen würde, um irrelevante Teile des Fachkonzepts auszublenden und Datenmodell-Referenzen zu normalisieren (mehr dazu gleich).
  • Python eignet sich als Interpreter-Sprache prima für Projekte, bei denen man zwar die grobe Zielrichtung kennt, sich aber den genauen Weg erst explorativ erarbeiten muss.

Python gehörte auch zur Infrastruktur meines Kunden und so konnte es losgehen. In den folgenden Abschnitten beschreiben ich Schritt für Schritt den Weg bis zur fertigen Redundanzanalyse.

Ausblenden irrelevanter Teile

Für die Redundanzanalyse musste man zunächst den Spezifikationstext aus dem UML-Modellierungswerkzeug exportieren, damit sich Python darüber hermachen konnte. Zuerst versuchte ich, aus dem Text die eigentliche fachlichen Verarbeitung zu extrahieren. Die Spezifikation war in purem Text ohne Formatierung verfasst und enthielt über die Beschreibung der fachliche Verarbeitung hinaus auch einführende Absätze als Einstiegshilfe für die Leser. Diese Absätze waren durch bestimmte Schlüsselwörter gekennzeichnet, sodass mein Python-Skript sie leicht von der weiteren Analyse ausschließen konnte.

Normalisierung der Datenmodell-Referenzen

Den restlichen Text spaltete das Skript in Absätze auf. In jedem Absatz suchte es nach Datenmodell-Referenzen, die durch typische Sonderzeichen zu erkennen waren, z.B. “#” als Trenner zwischen Klassen- und Attribut-Bezeichner. Diese Referenzen normalisierte das Skript, indem es die tatsächlichen Bezeichner durch die Standard-Bezeichner “Klassenname” und “Attributname” ersetzte.

Suche nach einem Maß für die Ähnlichkeit

Um redundante Abschnitte zu erkennen, musste das Skript Abschnitte paarweise vergleichen und ihre Ähnlichkeit mit einer normalisierten Maßzahl beziffern, die unabhängig vom Umfang der Abschnitte nur Werte zwischen 0 und 1 annimmt, wobei 1 für perfekte Übereinstimmung und 0 für kompletten Unterschied steht.

Ich stöberte in den Python-Bibliotheken und stieß schließlich auf eine Funktion zur Berechnung der “Levenshtein distance”, die auf der Anzahl von Einfügungen, Löschungen und Ersetzungen einzelner Buchstaben basiert, die man mindestens braucht, um den einen Partner des Vergleichspaars in den anderen umzuwandeln. Mit ähnlichen Abstandsmaßen ermittelt man in der Genom-Analyse, wie nahe zwei Individuen miteinander verwandt sind.

Experimente mit einem kleinen Ausschnitt des Fachkonzept lieferten vielversprechende Ergebnisse: Je höher die berechnete Ähnlichkeitszahl, um so ähnlicher war auch die fachliche Bedeutung.

Feinabstimmung der Ähnlichkeitsmessung

Umgekehrt traf das aber nicht immer zu: Manche Paare mit kleiner Ähnlichkeitszahl lagen inhaltlich näher beeinander als andere Paare mit hoher Ähnlichkeitszahl. Man sah auch sofort, dass es dafür zwei Ursachen gab:

  • Synonyme
    Zum einen wurden zwar unterschiedliche Wörter verwendet, diese hatten aber dieselbe Bedeutung. Ich ergänzte das Skript also durch eine Konfigurationsliste mit Synonymen und eine Vorverarbeitung, die verschiedene Wortvarianten durch eine Standard-Bezeichnung für den gemeinten Begriff ersetzte.
  • Füllwörter
    Manche Vergleichspartner unterschieden sich in der Verwendung von Füllwörtern, die den Text mehr oder weniger weitschweifig machen, sich aber nicht auf den fachlichen Sinn auswirken. Daher löschte das Skript nun auch solche Füllwörter in einer weiteren Vorverarbeitung.

Nach diesen Ergänzungen lieferte das Skript beim paarweisen Vergleich einiger handverlesener Abschnitte plausible Ähnlichkeitszahlen, sodass einem flächendeckenden Vergleich nichts mehr im Wege stand.

Ermittlung maximal großer Ähnlichkeitsbereiche

Der erste große Analyse-Lauf lieferte eine riesige Menge von Ähnlichkeitszahlen, denn die Abschnitte waren oft sehr kurz – viele bestanden nur aus einer einzigen Zeile, manchen nur aus einem einzigen Wort.

Solche Mini-Abschnitte sind für die Suche nach fachlichen Redundanzen nicht zu gebrauchen. Daher erweiterte ich das Skript so, dass es direkt aufeinander folgende Abschnitte, die ein bestimmtes Maß an Ähnlichkeit überschritten, zu einem einzigen längeren Abschnitt zusammenfasste.

Nach ein paar Probeläufen mit verschiedenen Schwellwerten für das “Maß an Ähnlichkeiten” bekam ich schließlich vernünftige Ergebnisse und lies das Skript dann wieder auf das gesamte Fachkonzept los. Am Ende lieferte es eine große Tabelle (in Python ein dataframe mit paarweisen Vergleichen.

Redundanzcluster

Jetzt musste ich noch eine Möglichkeit finden, die Vergleichspaare übersichtlich aufzubereiten. Das Fachkonzept-Team wollte ja sehen, welche Redundanzen besonders “schlimm” waren, sodass man sie möglichst bald bereinigen konnte. Dazu musste man die paarweisen Vergleiche zu Redundanz-Clustern zusammenfassen. Mit einem zweiten Skript wurden aus den paarweisen Vergleichen Cluster von untereinander sehr ähnlichen Abschnitten extrahiert (mithilfe eines weiteren Schwellwert-Parameters). Für jeden dieser Cluster lieferte das Skript folgende Informationen:

  • Eine eindeutige Cluster-Kennung
  • Einen zufällig herausgepickten Vertreter mit dem Textinhalt, sodass man den fachlichen Sinn erkennen konnte
  • Die Anzahl der Elemente des Clusters
  • Eine mittlere Ähnlichkeitszahl, die als Mittelwert aus den Ähnlichkeitszahlen der paarweisen Vergleiche zwischen den Elementen der Clusters berechnet wurde
  • Eine Kennzahl für die Redundanzbereinigung: je mehr Kopien und je umfangreicher die Abschnitte, um so größer die Kennzahl

Außerdem wurde eine Liste der Abschnitte erzeugt mit folgenden Informationen:

  • Eine eindeutige Kennung für den Abschnitt
  • Wo sich dieser Abschnitt im Fachkonzept befindet
  • Der Text des Abschnitts
  • Die Kennung des Clusters, zu dem der Abschnitt gehört

Manuelle Prüfung auf echte fachliche Redundanz

Beide Listen wurden dann in Excel geladen und dem Fachkonzept-Team zur Verfügung gestellt. Nun konnte die eigentliche Suche nach fachlichen Redundanzen beginnen. Dazu mussten Fachexperten prüfen,

  • ob sich die Varianten eines Abschnitts nur zufällig ähnelten: das kam vor allem bei Clustern mit kürzeren Abschnitten vor,
  • oder ob die Varianten eines Abschnitts aus fachlichen Gründen identisch sein sollten: nur in diesem Fall handelt es sich um eine echte fachliche Redundanz.

Hier ist eine weitere Analogie zur Genomanalyse interessant: In der Genetik bezeichnet man Gene als homolog, wenn sie wahrscheinlich einen gemeinsamen Ursprung haben, so wie die Gene für den roten und grünen Sehfarbstoff. Als homolog gelten Gene, die in mehr als 30 % ihrer Nukleotide übereinstimmen (Nukleotide sind quasi die Buchstaben des genetischen Texts).

Die fachlich redundanten Varianten eines Abschnitts könnte man also als “homolog” bezeichnen, während sonstige Ähnlichkeiten purer Zufall sind – oder handelt es sich vielleicht manchmal um einen Fall von “konvergenter Evolution”? Dabei entwickeln sich ähnliche Strukturen aus völlig verschiedenen Ursprüngen, z.B.

  • unsere Linsenaugen und
  • die Linsenaugen von Tintenfischen wie dem Octopus.

Die letzten gemeinsamen Vorfahren von uns und den Tintenfischen hatten nämlich kein Linsenaugen, höchstens ein paar lichtempfindliche Zellen.

Fazit

Dass ich bei der Redunanzanalyse des Fachkonzepts auf Analogien zur Genom-Analyse zurückgreifen konnte, hat mir Umwege erspart und die Analyse enorm beschleunigt, denn ich konnte mich aus einem wohlgefüllten Werkzeugkasten bedienen. Auf den Schultern von Riesen kann man eben weiter sehen, welche Art von Linsenaugen man hat.

Innovation: “Genom-Analyse” eines Fachkonzepts Read More »

Werkzeuge: Zero-Knowledge Proof

Geht das: Jemanden davon überzeugen, dass man ein Geheimnis kennt, ohne dieses Geheimnis zu verraten?

Ja, das geht tatsächlich, so unmöglich es auf den ersten Blick erscheint. Und zwar mit einem kryptographischen Verfahren, das Mitte der 1980er-Jahre als “Zero-Knowledge Proof” erstmals publiziert wurde und von dem es inzwischen zahlreiche Varianten gibt, nicht nur in der Theorie, sondern auch in der Praxis.

So bietet die ING ein Login-Verfahren für ihr Online-Banking an, bei dem man dazu aufgefordert wird, zwei Ziffern seines sechsstelligen DiBa-Keys einzutippen (den man natürlich geheim halten soll). Welche Ziffern man eingeben soll, würfelt der Login-Prozess bei jeder Anmeldung neu aus.

Weil der DiBa-Key nicht über die Leitung zwischen Kunde und Bank fließt, kann ein Angreifer den Key nicht ermitteln, selbst wenn er in der Lage wäre, die verschlüsselte Kommunikation zu knacken, z.B. mithilfe eines geheimdienstlichen Rechnerparks oder eines gekaperten Botnetzes. (Weil der DiBa-Key über eine virtuelle Tastatur eingegeben wird, hat auch ein Angreifer mit Keylogger keine Chance, die Eingabe mitzulesen.)

Es handelt sich also um ein statistisches Verfahren, denn die Bank kann nur mit einer gewissen Wahrscheinlichkeit darauf schließen, dass der Kunde den DiBa-Key wirklich kennt – schließlich wäre es ja denkbar, dass ein Angreifer mit einer gehörigen Portion Glück zufällig auf die beiden richtigen Ziffern tippt, ohne den vollständigen DiBa-Key zu kennen. Natürlich muss die Bank verhindern, dass man so lange herumprobiert, bis man irgendwann die richtigen Ziffern erwischt.

Es wurden viele Szenarien entwickelt, die das Potential des Zero-Knowledge Proof veranschaulichen, ohne die Wissbegierigen durch verzwickte Theorie abzuschrecken. Mein Lieblings-Szenario geht so:

Angenommen Sie haben zwei Tennisbälle, die bis auf die Farbe völlig gleich sind: Der eine ist rot, der andere grün. Und Sie haben einen Freund, der farbenblind ist, also Rot und Grün nicht unterscheiden kann. Mit dem Zero-Knowledge Proof können Sie Ihren Freund nun davon überzeugen, dass Sie die beiden Bälle unterscheiden können, ohne zu verraten, wie Sie das machen.

Wie geht das?

Sie bitten Ihren Freund, die beiden Bälle hinter seinem Rücken zu vertauschen oder nicht zu vertauschen und dann wieder vorzuzeigen. Sie entscheiden sich für eine der beiden Farben, z.B. für Rot, und zeigen dann auf den roten Ball.

Ihr Freund soll nun die Bälle so oft hinter seinem Rücken vertauschen und Sie zeigen jedes Mal wieder auf den roten Ball, bis Ihr Freund davon überzeugt ist, dass Sie die Bälle unterscheiden können, auch wenn ihm ein Rätsel bleibt, wie zum Teufel Sie das anstellen.

Fazit: Ein Geheimnis verschlüsselt auszutauschen, ist gut. Es nicht zu verraten, aber trotzdem nachzuweisen, dass man es kennt, ist besser. Genau das leistet der Zero-Knowledge Proof.

Werkzeuge: Zero-Knowledge Proof Read More »

Analyse: Gibt es ein Geheimnis guter Lösungen?

Ob die Lösung eines bestimmten Problems gut ist, hängt oft von vielen Eigenschaften der Lösung ab. Wenn ich nur drei Eigenschaften nennen dürfte, wären es die folgenden.

Gute Lösungen sind stets …

… einfach

Everything should be made as simple as possible, but not simpler.
Albert Einstein

… klar

Alles was überhaupt gedacht werden kann, kann klar gedacht werden. Alles, was sich aussprechen lässt, lässt sich klar aussprechen.
Ludwig Wittgenstein

… schlank

Weniger ist mehr.
Ludwig Mies van der Rohe

Das Einstein-Zitat habe ich leider nur in der englischen Fassung gefunden – vielleicht war das auch die Original-Sprache?

Was die Forderung nach Klarheit betrifft, so ist sie nicht nur für Dokumente wie Konzepte und Spezifikationen wichtig, sondern mindestens ebenso für Quellcode. Klar heißt dabei stets: verständlich für die Zielgruppen.

Die Forderung nach einer schlanken Lösung hat natürlich einen Haken: Es kostet Aufwand, eine Lösung auf das Wesentliche zu reduzieren. Wie Blaise Pascal im Postskriptum eines in der Tat sehr langen Briefes vom 4. Dezember 1656 schreibt

Ich habe den gegenwärtigen Brief aus keiner andern Ursach so lang gemacht, als weil ich nicht Zeit hatte, ihn kürzer zu machen.
Je n’ai fait celle-ci plus longue que parce que je n’ai pas eu le loisir de la faire plus courte.

Aber bei langlebigen Lösungen zahlt sich der anfängliche Mehraufwand für die Verschlankung meist in kurzer Zeit aus, weil eine schlanke Lösung weniger schnell degeneriert als eine unnötig aufgeblähte.

Analyse: Gibt es ein Geheimnis guter Lösungen? Read More »

Buchtipp: “Business Analysis Agility”

Von James Robertson und Suzanne Robertson; Addison-Wesley 2019.

Die beiden Autoren, Veteranen der legendären Atlantic Systems Guild, greifen in diesem Buch erneut ein Thema auf, das sie schon lange mit großem Erfolg bearbeiten: Wie man durch eine geschickte und schlanke Business Analyse den Grundstein für exzellente Lösungen legt.

Ihr jüngstes Buch konzentriert sich laut Untertitel auf zwei Kernaspekte der Business Analyse:

Solve the real problem, deliver real value

An einem konkreten Beispiel entwickeln sie Schritt für Schritt, was das konkret heißt. Dass sie zunächst die zentrale Bedeutung der Problem-Analyse für alles Weitere herausarbeiten, hat einen guten Grund: Nur allzu oft erlebt man als Business Analyst oder Projektleiter, dass Auftraggeber, Fachbereiche und Projektteam schnurstacks zum Lösungsentwurf übergehen wollen, ohne dass klar wäre, worin das das zu lösende Problem genau besteht.

Zweifellos kann es bei der Problemanalyse hilfreich sein, mithilfe von Lösungsskizzen zu überprüfen, welche Lücken und Missverständnisse sich noch im aktuellen Problemverständnis verbergen und so die Analyse inkrementell voranzutreiben. Aber viele Teams erliegen der Versuchung, dabei die Analyse sträflich zu vernachlässigen zugunsten einer schnellen Lösungsfindung, die dann wenig überraschend zu halbgaren Ergebnissen führt: Wenn man nicht genau weiß, was das Problem ist, wird es zur Glückssache, ob die Lösung wirklich passt.

Der “real value”, den ein Projekt liefern soll, ist nichts anderes als der Nutzen der Lösung für ihre Stakeholder. Es ist kritisch für den Projekterfolg, die oft wolkigen Nutzenvorstellungen der Stakeholder soweit zu präzisieren, dass sie im wahrsten Sinne des Wortes “zielführend” werden. Worin der Nutzen genau bestehen soll und wie man überprüfen kann, ob man ihm am Ende auch erreicht, ist also ein wesentlicher Teil der Problemanalyse. Je nach Stakeholder kann der Nutzen eher in qualitativen Verbesserungen bestehen oder in quantitativen bzw. monetären wie etwa Kosteneinsparungen.

Viele glauben, das Ziel eines IT-Projekts sei die Entwicklung oder Verbesserung eines IT-Systems. Dabei geht es in Wirklichkeit darum, die Welt zu verbessern, indem man einen bestimmten Nutzen erzielt, den man ohne das IT-System nicht erzielen könnte. So gesehen ist ein IT-System nur ein Baustein einer umfassenderen Lösung,

  • zu der auch die Geschäftsprozesse gehören, in welche das IT-System eingepasst wird,
  • und die Menschen, deren Leben das IT-System verändert, hoffentlich zum Besseren.

Das Buch bietet eine Fülle von praxiserprobten Tipps, wie man

  • den Raum der potentiellen Lösungen erkundet, als Voraussetzung dafür, sich einer optimalen Lösung anzunähern,
  • diverse agile Methoden geschickt einsetzt, insbesondere Stories,
  • und schließlich den gesamten Analyseprozess flink und zielstrebig durchläuft, um möglichst schnell den angestrebten Nutzen einfahren zu können.

Insgesamt ein schlankes Buch (reichlich 200 Seiten), das die Grundprinzipien agiler Business Analyse sehr klar und mit einer Prise Humor auf den Punkt bringt.

Buchtipp: “Business Analysis Agility” Read More »

Analyse: Das Gesetz der kleinen Zahl

Oder: “Je kleiner eine Stichprobe, um so unsicherer das Ergebnis.” Und welche üblen Folgen es haben kann, auch für Projektleiter und Business Analysten, wenn man dieses Gesetz ignoriert.

In seinem Bestseller Thinking, Fast and Slow schildert Daniel Kahnemann wie er am Anfang seiner wissenschaftlichen Laufbahn am “Gesetz der kleinen Zahl” schier verzweifelt ist: Er konnte in seinen Experimenten nicht reproduzieren, dass sechsjährige Mädchen im Durchschnitt einen größeren Wortschatz haben als gleichaltrigen Jungen. Mal waren die Mädchen deutlich überlegen, mal die Jungen, mal waren beiden Gruppen gleichauf. Erst als er seine Versuche mit größeren Teilnehmerzahlen durchführte, verschwanden diese statistischen Verzerrungen und er konnte die Überlegenheit der Mädchen bestätigen.

Zu kleine Stichproben verführen nicht nur Biowissenschaftler immer wieder zu Behauptungen, die ihre Kollegen nicht reproduzieren können, auch in den Sozialwissenschaften treiben sie schon lange ihr Unwesen. So hatten die Republikaner bei den US-Präsidentschaftwahlen von 2016 den größten Vorsprung in dünn besiedelten Wahlkreisen mit relative wenigen Wählern. Na klar, das sind ländliche Gebiete mit abgehängten “weißen Männern” (und Frauen), die in ihrer Frustration dem Populismus von Donald Trump erliegen. Aber das Gegenteil war auch richtig: Die Demokraten ihrerseits hatten den größten Vorsprung vor den Republikanern ebenfalls in Wahlkreisen mit wenigen Wählern, nicht in den bevölkerungsreichen.

Diese scheinbare Paradoxie kann man durch “langsames Denken” im Sinn von Kahnemann auflösen: Angenommen, in einer Urne liegen zahlreiche Kugeln, die entweder schwarz oder weiß sind. Man zieht nun blind Kugeln aus der Urne und möchte aus dieser Stichprobe darauf schließen, wie häufig die weißen Kugeln in der Urne sind. Wie viele Kugeln muss man ziehen, damit man den Anteil der weißen Kugeln mit genügender Sicherheit schätzen kann, sagen wir mit 95-prozentiger Sicherheit?

Betrachten wir zunächst die beiden Extremfälle:

  • Wenn man überhaupt keine Kugeln aus der Urne zieht, weiß man auch überhaupt nichts über deren Farbverteilung.
  • Zieht man aber alle Kugeln aus der Urne und zählt die Farben aus, weiß man mit hundertprozentiger Sicherheit, wie hoch der Anteil der weißen Kugeln ist.

Wie die Sicherheit mit dem Stichprobenumfang wächst, kann man mit statistischen Methoden berechnen (siehe z.B. “Statistik für Wirtschaftswissenschaftler” von Josef Bleymüller; Verlag Franz Vahlen; 16. Auflage 2012). Das ist zwar mühsam, aber unumgänglich für die Versuchsplanung, denn sonst weiß man nicht, wie weit man sich auf die Versuchsergebnisse verlassen kann.

Aber auch als Projektleiter oder Business Analyst sollte man sich jetzt nicht grinsend zurücklehnen, denn man ist nur allzu oft selbst in Gefahr, am “Gesetz der kleinen Zahl” Schiffbruch zu erleiden.

Beispiel Test: Wie oft ist es schon vorgekommen, dass ein System alle Tests bestanden hat und trotzdem verheerende Fehler aufgetreten sind, wenn man es produktiv nutzt? Man hat hier wieder das “Gesetz der kleinen Zahl” zu spüren bekommen, diesmal in Form einer zu kleinen Zahl von Testfällen. Die Stichprobe der durchgeführten Tests war so klein, dass man die schweren Fehler nicht bemerkt hat, die sich als wenige schwarze Kugeln in der Massen der weißen Kugeln, also der korrekten Funktionen, versteckt haben. Zwar hätte man auch mit wenigen Tests zufällig auf solche Fehler stoßen können, aber die Wahrscheinlichkeit dafür war wegen der geringen Zahl von Tests nicht hoch genug, um den positiven Testergebnissen zu vertrauen.

Analyse: Das Gesetz der kleinen Zahl Read More »

Buchtipp: “Thinking, Fast and Slow”

Von Daniel Kahnemann; Penguin Books; 2012

Daniel Kahnemann erhielt 2002 den Wirtschaftsnobelpreis für seine Forschungen zur Verhaltensökonomik, die er seit den 1970er-Jahren vor allem zusammen mit Amos Tversky durchgeführt hat. Im Zentrum dieser Forschungen steht ein Modell der menschlichen Entscheidungsfindung, das nicht nur auf einer kühlen Abwägung von Kosten und Nutzen nach Art eines völlig rationalen Home oeconomicus basiert, sondern auch zahlreiche kognitive Verzerrungen berücksichtigt, welche die Forscher bei echten Menschen in sorgfältig durchgeführten Experimenten beobachtet und nach Art der Wirtschaftswissenschaftler in mathematische Modelle gefasst haben.

Kahnemanns Buch “Thinking, Fast and Slow”, das sich rasch zu einem internationalen Bestseller entwickelt hat, beschreibt nicht nur die revolutionären Ergebnisse dieses Forschungszweigs, sondern schildert auch die Wege und Irrwege, auf denen diese Ergebnisse erzielt wurden. Das ist an sich schon sehr interessant, um so mehr aber, als man den beschriebenen kognitiven Verzerrungen nur allzu leicht selbst unterliegt und hofft, ein besseres Verständnis dieser Denkfehler könne vielleicht helfen, sie künftig zu vermeiden.

Das ist allerdings leichter gesagt als getan, wenn Kahnemann recht hat und die kognitiven Verzerrungen das Produkt weitgehend automatisierter Vorgänge sind, die uns schnelle Entscheidungen unter Ungewissheit ermöglichen und die eine lange Evolutionsgeschichte tief in uns verankert hat.

Wenn wir kognitive Verzerrungen vermeiden oder überhaupt erst einmal bemerken wollen, müssen wir dagegen die Mühsal des “langsamen Denkens” auf uns nehmen, das durch Logik, Wahrscheinlichkeitsrechnung und ähnliche Zumutungen einen ungetrübteren Blick auf die Entscheidungssituation und die verfügbaren Alternativen ermöglicht. Kahnemann illustriert das zum Beispiel am Gesetz der kleinen Zahl.

Wem das Buch von Kahnemann zu umfangreich ist, der kann viele der darin beschriebenen Denkfallen auch im kurzweiligen Buch von Rolf Dobelli finden: “Die Kunst des klaren Denkens. 52 Denkfehler, die sie besser anderen überlassen” (Hanser Verlag 2011).

Und wem das Buch von Kahnemann nicht reicht, dem sei “Rationality for Mortals” empfohlen mit dem Untertitel “How People Cope with Uncertainty” (Oxford University Press, 2008). Darin setzt sich Gerd Gigerenzer, Kognitionspsychologe und Direktor des Harding-Zentrums für Risikokompetenz an der Universität Potsdam, kritisch mit den Hypothesen Kahnemanns auseinander, indem er den adaptiven Vorteil des “schnellen Denkens” betont: Außerhalb des Labors erweisen sich laut Gigerenzer viele kognitiven Verzerrungen des “schnellen Denkens” als erstaunlich nützlich oder waren es zumindest lange Zeit während der Evolutionsgeschichte des Menschen. Auch Gigerenzer ist aber davon überzeugt, dass wir kognitive Verzerrungen möglichst vermeiden sollten, wenn wir verantwortungsbewusst Entscheidungen treffen wollen in unserer heutigen unübersichtlichen Welt.

Buchtipp: “Thinking, Fast and Slow” Read More »

Buchtipp: “Rebooting AI – Building Artificial Intelligence We Can Trust”

Von Gary Marcus und Ernest Davis; Vintage Books; August 2020.

In diesem Buch zeigen zwei renommierte KI-Experten an zahlreichen Beispielen, wie schlecht die heutige KI mit der Welt abseits von Go-Brettern und Videospielen zurecht kommt und entwickeln Vorschläge, die man diese Beschränkungen überwinden könnte.

So haben neuronale Netze, die zurzeit so überraschende Erfolge feiern, auf der anderen Seite

  • einen umgekippten Schulbus als Schneepflug klassifiziert und
  • ein Stoppschild, das Scherzbolde mit Aufklebern verziert hatten, plötzlich für eine Geschwindigkeitsbegrenzung gehalten.

Den erstaunlichen Fähigkeiten moderner KI-Algorithmen steht also oft ein mindestens ebenso erstaunliches Versagen in der realen Welt gegenüber, wo sie mitunter an Aufgaben scheitern, die selbst kleine Kinder spielend bewältigen.

Warum das so ist, untersuchen die Autoren, indem sie die Arbeitsweise von KI mit unseren kognitiven Fähigkeiten vergleichen. Wenn z.B. eine KI einen Text übersetzt, nutzt sie statistische Zusammenhänge, die sie zuvor aus ungeheuren zweisprachigen Textmassen extrahiert hat. Beim Übersetzen tauscht sie also Zeichenketten der Quellsprache aus durch statistisch passende Zeichenketten der Zielsprache. Das ist alles, und intelligent wirkt das nicht gerade.

Eine menschliche Übersetzerin muss zwar zunächst auch den Quelltext lesen, aber dann tut sie etwas Unerhörtes, jedenfalls für KI-Begriffe: Während des Lesens versucht sie, den Text zu verstehen! Sie übersetzt also nicht den Text an sich, sondern ein Stück Welt, das sie in ihrem Geist erschaffen hat aus den dürren Stichworten im Text und einer Fülle von Wissen, Erfahrungen, Gefühlen usw., über die sie als menschliches Wesen verfügt.

Die Autoren gehen natürlich etwas nüchterner an dieses Thema heran, als ich mir das hier als begeisterter Bücherwurm erlaubt habe, und tragen eine stattliche Liste von kognitiven Fähigkeiten zusammen, die wir den heutigen KI-Algorithmen voraus haben und die es uns ermöglichen, in einer Welt zu überleben, in der wir immer wieder mit Neuem konfontiert werden.

Diese Liste von kognitiven Fähigkeiten inspiriert die Autoren dazu, ein Forschungsprogramm zu skizzieren, von dem sie überzeugt sind,

  • dass es einen Weg aus der Sackgasse weist, in der die KI ihrer Ansicht nach heute steckt,
  • und das die KI nach und nach mit “common sense” und am Ende sogar einer “general intelligence” ausstatten soll,
    • der man eher vertrauen kann als den heutigen fachidotenhaften KI-Algorithmen, die beim geringsten Überschreiten ihrer Grenzen so spektakulär und überraschend scheitern können, dass man sich besser nicht blindlings auf sie verläßt.

Ob die Vorschläge der Autoren für einen Neustart der KI-Forschung am Ende zu besseren und vertrauenswürdigeren KI-Anwendungen beitragen werden, kann ich als KI-Laie nicht beurteilen. Aber lesenswert ist dieses Buch allemal für jeden, der mehr über Grenzen und Potential von KI erfahren möchte.

Buchtipp: “Rebooting AI – Building Artificial Intelligence We Can Trust” Read More »