Code für andere Leute schreiben, Teil 7

Im letzten Teil haben wir erörtert, was man in der Psychologie unter dem Begriff Analogie versteht und auf welche Art und Weise wir Analogie auswählen. In diesem Teil wollen wir gängige Analogiemuster im Quellcode aufspüren.

Analogiemuster in Software

Die offensichtlichste Art Analogien in Software zu implementieren ist die Verwendung von Interfaces und abstrakten Klassen (siehe einfache Analogien und Regelanalogien in der Aufzählung unten im vorhergehenden Teil), allerdings kann man Analogien auch auf andere Art darstellen.

Bitte berücksichtigen Sie, dass die Codebeispiele in diesem Abschnitt Beispiele für die Strukturierung von Code darstellen. Sie zeigen, wie der Code aussehen könnte aber nicht notwendigerweise wie er aussehen sollte. Eine gute Richtlinie für das Identifizieren von Analogien ist, wenn man “erraten” kann, wie der Code logisch fortgesetzt werden kann, wenn das Verhalten um eine neue Variante erweitert werden soll.

Der folgende Code zeigt Beispielsweise das Kontotyp-Attribut für unterschiedliche Terminbörsen als Varianten (Eurex, Liffe, etc.).

public String getAccountType(String account) {
    if(exchange.equals("EUREX"))
        return getEurexAccountType(account);
    if(exchange.equals("LIFFE"))
        return getLiffeAccountType(account);
    if(exchange.equals("MONEP"))
        return getMonepAccountType(account);

Es ist hier einfach zu erraten, wie der Code für die Französische Terminbörse MATIF erweitert werden muss:

    if( exchange.equals("MATIF") )
        return getMatifAccountType(account);

Auf den ersten Blick sieht das Erraten dieser Erweiterung wie das Ergebnis von Erfahrung in der Softwareentwicklung aus. Tatsächlich ist es aber das Ergebnis von Erfahrung im Erkennen von Analogien und diese Fähigkeit erlernen wir bereits in unserer Kindheit! Die unbewusste Annahme, dass der Leser analoge Strukturen erkennen und erstellen kann (die die Anforderungen an die Anwendung widerspiegeln) ist zweifellos eine zentrale Fähigkeit, die auch von Softwareentwicklern verlangt wird, die den Code zum ersten Mal zu Gesicht bekommen (im vorletzten Teil haben wir diese Entwickler Neulinge genannt).

Im folgenden Abschnitt werden zahlreiche Sprachmittel von Java vorgestellt, die dazu verwendet werden können, Analogien darzustellen. Diese Sprachmittel sind natürlich auch in anderen Programmiersprachen vorhanden und abhängig von den Sprachmitteln ist in vielen Sprachen natürlich noch mehr möglich.

Attribute-Only-Analogien

Die einfachste Art einer Attribute-Only-Analogie ist eine Hashtabelle (Map). In diesem Beispiel werden die einzelnen Terminbörsen als direkte Analogien (siehe letzter Teil unten) gesehen. Das einzige Attribut von Interesse ist dabei das Land, in welchem sich die Börse befindet:

static Map exchangeCountry = new HashMap();

static {
    exchangeCountry.put("EUREX","Germany");
    exchangeCountry.put("CBOT","US");
    exchangeCountry.put("LIFFE","England");
    //can guess what to do
    //to extend for NYBOT......
}

//usage
public String logMessage(String exchangeName) {
    return "Exchange " + exchangeName +
           " is in " +
            exchangeCountry.get(exchangeName);
}

Statement-Formanalogien

In diesem Fall wird dieselbe Ausführung (Form) für unterschiedliche Felder oder Elemente verwendet, um das Verhalten zu implementieren. Die Ähnlichkeit in der Ausführung (Form) des Statements ist der Schlüssel, durch den der Leser die Analogie erkennt. In diesem Beispiel ist das Überprüfen des Feldes die Analogie und jedes Feld der Klasse benötigt seine Eigene Variante zur Überprüfung desselben.

private Date expirationDate;
private Long contractNumber;
private Double price;
private Double quantity;
private String description;

private boolean isValid()
{
    if(expirationDate == null ||
       !(expirationDate.getTime() > 0))
        return false;

    if(price == null ||
       !(price.doubleValue() > 0))
        return false;

    if(quantity == null ||
       !(quantity.doubleValue() > 0))
        return false;

    //can guess what the code line is
    //for the String parameter
    //"description" ......

    return true;
}

Switch-Analogie

Ähnlich wie bei der Statement-Formanalogie sind die Implementierungen zu Chunks gruppiert, allerdings mit einer formelleren Definition des Typs der Variante. Das Beispiel gibt das Ergebnis unterschiedlicher Operationen zurück, die auf zwei Zahlen angewendet werden sollen (Addition, Subtraktion, etc.)

private int operand;

public double calculate(double first, double second) {
    switch (operand) {
        case MULTIPLY:
            return first * second;
        case DIVIDE:
            return first / second;
        case ADD :
            return first + second;
        case SUBTRACT :
            return first - second;
    }
    return 0;
}

Methodennamen-Analogie

Entweder das Präfix oder das Suffix der Methode wird verwendet, um die Analogie auszudrücken. Das Präfix hat den Vorteil, dass die Gruppierung und damit die Analogie auch dann noch erhalten bleibt, wenn die Methoden alphabetisch sortiert werden. Als Beispiel für die Präfix-Variante dient das Besuchermuster. Im Beispiel für die Gruppierung mithilfe des Suffix wird ein Objekt des Typs Double in unterschiedliche Datentypen umgewandelt. Diese Form ist nützlich, wenn alle Varianten gemeinsame Abhängigkeiten haben, die in der Klasse zu Chunks zusammengefasst werden können.

//example 1 - prefix
public void visitExpression(Node a) {};
public void visitBlock(Node a) {};
public void visitFile(Node a) {};

//example 2 - suffix
Double doubleObj = new Double(0);
double a = doubleObj.doubleValue();
int b = doubleObj.intValue();
long c = doubleObj.longValue();
float d = doubleObj.floatValue();

Methodenparameter-Analogie

Der Typ des Parameters, der an eine Methode übergeben wird, kann die verwendete Variante bestimmen. Das folgende Beispiel berechnet das Maximum zweier zahlen:

float f = Math.max(1.0F, 2.0F);
int i = Math.max(1, 2);
long l = Math.max(1L, 2L);
double d = Math.max(1.0, 2.0);

Klassen-/Interface-Analogie

Die Klassen-/Interface-Analogie erlaubt es, mehrere Elemente (Felder) zu Chunks zusammenzufassen.

abstract class Shape {
    String name; //square, circle etc
    int numSides;
    abstract double area();
}

class Rectangle extends Shape {
    double length;
    double width;

    double area() {
        return (length * width);
    }
}

Anwendungsanalogie

Die Laufenden Instanzen einer Anwendung sind direkte Analogien voneinander. Konfigurationsdateien und Systemeinstellungen sind die Eigenschaften (Merkmale) dieser Analogie.

Multiparadigmen-Design

Die Technik, Analogien in den Anforderungen zu identifizieren und daraufhin die passenden Code-Strukturen auszuwählen wurde erstmals von James Coplien beschrieben (siehe Multi-Paradigm Design for C++). Coplien benutzt allerdings den Begriff Domain für Analogieen und Sub-Domains für Varianten. Solution Domains entsprechen den Analogiestrukturen im Code (auch wenn lediglich formale Strukturelemente wie Interface, Template [das mächtigere Pendant zu Generics in C++] etc. identifiziert werden). Die “commonality and variability analysis” ist der Prozess, mit dem die Analogien identifiziert werden. Beide, Coplien und Grady Booch (in Object-Oriented Analysis and Design with Applications) beschreiben objektorientiertes Design als “Aufteilen durch Zusammenfassen”. Strukturiertes Design ist die Disziplin des Zusammenfassens aber für Thomas Mullen ist objektorientiertes Design Identifizieren und Kodieren von Analogien. Das sind unterschiedliche aber komplementäre Fähigkeiten, die erworben werden müssen, um Software mit gutem Design zu erstellen.

Im achten und letzten Teil dieser Serie wird die fundamentale Regel des Softwareentwurfs beschrieben und Schlussfolgerungen aus all den Erkenntnissen, die in den vorangegangenen Teilen gewonnen wurden, gezogen.

Schlagwörter: agile softwareentwicklung, clean code, java, oop, software-sanierung, softwarearchitektur, softwareentwicklung