Fehler entdecken

Wir haben bisher die Grundlagen der Sprache wie Variablen, Bedingungen, Schleifen und Methoden geübt. Lassen Sie uns nun einige der Faktoren betrachten, die die Verständlichkeit von Programmen beeinflussen, und wie Fehler gefunden werden können.

Programmierende, die ihren eigenen Code nicht sehen

Programmierende werden oft blind für ihren eigenen Code. Lassen Sie uns dieses Phänomen anhand des kurzen Videos unten näher kennenlernen. Zählen Sie, wie oft die Spieler mit weißen Hemden den Ball hin- und herspielen. Das Video enthält Anweisungen auf Englisch.

Es gibt noch etwas anderes, das in dem Video passiert, das auf den ersten Blick möglicherweise unbemerkt bleibt. Dieser Effekt wird als "wahrnehmungsbedingte Blindheit" bezeichnet und erklärt sich dadurch, dass unser Gehirn, wenn wir uns auf eine bestimmte Aufgabe konzentrieren, dazu neigt, Informationen herauszufiltern, die für diese Aufgabe nicht relevant sind. Wir wissen jedoch nicht immer, welche Informationen tatsächlich wesentlich sind und welche nicht – ein Beispiel hierfür ist das Lernen. Das Fokussieren auf einen bestimmten Teil einer Lernaufgabe kann dazu führen, dass relevante Informationen herausgefiltert werden.

Glücklicherweise verringert sich die wahrnehmungsbedingte Blindheit mit der Übung bei einer bestimmten Aufgabe. Mit anderen Worten, durch Übung entwickelt man die Fähigkeit, zwischen relevanten und irrelevanten Informationen zu unterscheiden.

Eine Möglichkeit, wie sich die wahrnehmungsbedingte Blindheit in der Programmierung zeigt, ist, wenn das Konzentrieren auf einen bestimmten Teil eines Programms die Aufmerksamkeit von scheinbar korrekten, aber fehlerhaften Teilen ablenkt. Zum Beispiel könnte ein Programmierender beim Überprüfen der Korrektheit der Programmausgabe auf die Print-Anweisungen fixiert sein und versehentlich einige Aspekte der Logik übersehen.

Ebenso könnte ein Programmierender sich auf den kompliziertesten Aspekt eines Programms mit einer Schleife konzentrieren, obwohl der Fehler ganz woanders liegt. Ein Beispiel hierfür ist das untenstehende Programm, das verwendet wird, um den Durchschnitt von Benutzereingaben zu berechnen. Es enthält einen Fehler, und bei der Fehlersuche konzentriert man sich typischerweise zuerst auf die Schleife.

Scanner scanner = new Scanner(System.in);
int values = 0;
int sum = 0;

while (true) {
    System.out.println("Provide a value, a negative value ends the program");
    int value = Integer.valueOf(scanner.nextLine());
    if (value < 0) {
        break;
    }

    values = values + 1;
    sum = sum + value;
}

if (sum == 0) {
    System.out.println("The average of the values could not be calculated.");
} else {
    System.out.println("Average of values: " + (1.0 * sum / values));
}

Wahrnehmungsbedingte Blindheit kann nicht vollständig vermieden werden. Es gibt jedoch Möglichkeiten, wie Programmierende ihre Auswirkungen verringern können – die erste ist, Pausen einzulegen, was erfordert, dass die Arbeit rechtzeitig begonnen wird. Kommentare im Code, eine sinnvolle Benennung und "Debug"-Ausgaben sind weitere hilfreiche Methoden.

Kommentare im Quellcode

Kommentare haben viele Zwecke, einer davon ist, sich selbst zu erklären, wie der Code funktioniert, wenn man nach Fehlern sucht. Die Ausführung eines relativ einfachen Programms wird unten mit Kommentaren beschrieben.

/*
 Druckt die Zahlen von zehn bis eins.
Jede Zahl wird auf einer eigenen Zeile ausgegeben.
*/

// Wir erstellen eine Ganzzahlenvariable namens value,
// der wir den Wert 10 zuweisen.
int value = 10;

// Die Schleifen-Ausführung wird fortgesetzt, bis
// der Wert der Variablen value kleiner oder gleich null ist.
// Die Ausführung stoppt nicht _sofort_, wenn der Wert null
// der Variablen zugewiesen wird, sondern erst, wenn die Bedingung der
// Schleife das nächste Mal ausgewertet wird.
// Dies geschieht immer nach der Schleifenausführung
while (value > 0) {
    // wir geben den Wert der Variablen und eine neue Zeile aus
    System.out.println(value);
    // wir verringern den Wert um eins
    value = value - 1;
}

Kommentare haben keine Auswirkungen auf die Ausführung des Programms, d.h. das Programm funktioniert mit den Kommentaren genauso wie ohne sie.

Der oben gezeigte Kommentarstil, der für Lernzwecke gedacht ist, ist jedoch für die reale Entwicklung zu ausführlich. In der Softwareentwicklung sollte der Quellcode selbstdokumentierend sein. Das bedeutet, dass die Funktionalität des Programms aus der Benennung von Klassen, Methoden und Variablen ersichtlich sein sollte.

Das Beispiel kann „auskommentiert“ werden, indem der Code in eine sinnvoll benannte Methode gekapselt wird. Unten sind zwei Beispiele für Methoden, die dies tun – eine der Methoden ist allgemeiner im Vergleich zur anderen. Die allgemeinere Methode setzt jedoch voraus, dass die Benutzerin oder der Benutzer weiß, welcher der beiden Parameter den höheren Wert und welcher den niedrigeren Wert zugewiesen bekommt.

public static void printValuesFromTenToOne() {
    int value = 10;
    while (value > 0) {
        System.out.println(value);
        value = value - 1;
    }
}

public static void printValuesFromLargestToSmallest(int start, int end) {
    while (start >= end) {
        System.out.println(start);
        start = start - 1;
    }
}

Fehler suchen mit Print-Debugging

Eine erforderliche Fähigkeit in der Programmierung ist die Fähigkeit zu testen und zu debuggen, wenn nach Fehlern gesucht wird. Die einfachste Methode, um nach Fehlern zu suchen, ist das sogenannte Print-Debugging, das in der Praxis das Hinzufügen von Nachrichten zu bestimmten Codezeilen bedeutet. Diese Nachrichten werden verwendet, um den Ablauf der Programmausführung zu verfolgen, und können auch Werte von Variablen enthalten, die im Programm existieren.

Schauen wir uns das Programm an, das wir bereits aus der vorherigen Frage kennen und das verwendet wurde, um den Durchschnitt von nicht-negativen Werten zu berechnen.

Scanner scanner = new Scanner(System.in);
int values = 0;
int sum = 0;

while (true) {
    System.out.println("Provide a value, a negative value ends the program");
    int value = Integer.valueOf(scanner.nextLine());
    if (value < 0) {
        break;
    }

    values = values + 1;
    sum = sum + value;
}

if (sum == 0) {
    System.out.println("The average of the values could not be calculated.");
} else {
    System.out.println("Average of values: " + (1.0 * sum / values));
}

Hätte das Programm einen Fehler, könnte das Print-Debugging verwendet werden, um die Funktionalität des Programms zu analysieren, indem Print-Anweisungen an den entsprechenden Stellen hinzugefügt werden. Das untenstehende Beispiel enthält ein mögliches Beispiel für ein Programm mit Print-Debug-Anweisungen.

Scanner scanner = new Scanner(System.in);
int values = 0;
int sum = 0;

while (true) {
    System.out.println("-- values: " + values + ", sum: " + sum);

    System.out.println("Provide a value, a negative value ends the program");
    int value = Integer.valueOf(scanner.nextLine());
    if (value < 0) {
        System.out.println("-- value is negative, exiting loop");
        break;
    }

    values = values + 1;
    sum = sum + value;
}

System.out.println("-- loop exited");
System.out.println("-- values: " + values + ", sum: " + sum);

if (sum == 0) {
    System.out.println("The average of the values could not be calculated.");
} else {
    System.out.println("Average of values: " + (1.0 * sum / values));
}

Wenn ein Programm mehrfach mit geeigneten Eingaben ausgeführt wird, wird der versteckte Fehler oft gefunden. Das Entwickeln relevanter Eingaben ist eine Fähigkeit für sich. Es ist wichtig, die sogenannten Eckfälle (Corner Cases) zu testen, d.h. Situationen, in denen die Programmausführung außergewöhnlich sein könnte. Ein Beispiel wäre ein Szenario, in dem die Benutzerin oder der Benutzer keinen einzigen akzeptablen Wert eingibt oder Nullen oder sehr große Werte eingibt.