Reparatur von Programmen mithilfe der Object Constraint Language

Ulke, Bastian

Gängige Entwicklungsumgebungen (engl. Integrated Development Environments, IDEs) verfügen über ausgereifte Möglichkeiten, Fehler in Programmen einer Programmiersprache wie etwa Java (einer General Purpose Language, GPL) zu erkennen und zu korrigieren. Für viele Aufgaben, die unabhängig von einer spezifischen Anwendungsdomäne sind, liefern Frameworks heute jedoch standardisierte, wiederverwendbare Lösungen. Die Java Persistence API (JPA), die eine Schnittstelle zur Abbildung der Anwendungsobjekte auf Datensätze einer relationalen Datenbank definiert, ist hierfür ein typisches Beispiel. Während IDEs genaue Kenntnis der Wohlgeformtheitsregeln der GPL haben (sodass sie in einem Programm Fehler erkennen und Korrekturen vorschlagen können), sind ihnen die Regeln, an die das Programm bei Nutzung eines Frameworks gebunden ist, zumeist unbekannt. Bei der Implementierung werden Fehler daher schnell übersehen, sodass der Entwickler erst auf sie aufmerksam wird, wenn es zu einem Laufzeitfehler gekommen ist. Gleichwohl könnte eine statische Code-Analyse viele Fehler bereits während der Entwicklungszeit aufdecken, sodass man von einer IDE erwarten darf, dass sie ebenso bei der Einhaltung der Framework-spezifischen Regeln Unterstützung bietet, wie sie es bei denen der GPL tut. Dieser Dissertation liegt die Annahme zugrunde, dass sich an der eingeschränkten Unterstützung bei der Verwendung eines Frameworks nichts ändert, solange kein Weg gefunden wird, die Verantwortlichkeiten zur Definition der Wohlgeformtheitsregeln eines Frameworks (die dem Anbieter des Frameworks zukommt) und zur Implementierung der Algorithmen zur Validierung und Korrektur (die dem Anbieter der IDE zukommt) voneinander zu trennen. Diese Arbeit zeigt, dass Constraint-basierte Entwicklungswerkzeuge, die ein Problem der Softwareentwicklung auf den Formalismus eines Constraint Satisfaction Problems (CSP) abbilden, die Grundlage zu dieser Verteilung der Verantwortlichkeiten bilden können. Solche Werkzeuge basieren auf der deklarativen Definition einer bestimmten Programmeigenschaft (etwa der Wohlgeformtheit) sowie der Suche nach Programmtransformationen, die dieser genügen; zur Suche können hierbei Algorithmen der künstlichen Intelligenz zur Anwendung kommen. Diese Ausarbeitung präsentiert (a) einen Satz von Wohlgeformtheitsregeln für die Java Persistence API, die als Invarianten in der Object Constraint Language (OCL) angegeben werden; (b) ein Verfahren zur Übersetzung von OCL-Ausdrücken in Constraints eines CSP; (c) einen Algorithmus zur Bestimmung und Lokalisierung von Fehlern auf der Grundlage dieser Constraints; (d) eine Methode zur Bestimmung von Korrekturvorschlägen zu einem Fehler, das Shallow Fixing, bei dem ein Fehler in Isolation betrachtet wird und hiebei – wie es auch die Quick Fixes gängiger IDEs tun – die Gefahr birgt, neue Fehler in ein Programm einzubringen, und (e) drei Ansätze, die dieses Risiko eliminieren, indem sie weitere Constraints bei der Suche nach Korrekturvorschlägen mit einbeziehen, was Deep Fixing genannt wird. Schließlich werden diese Ansätze (f) auf der Grundlage von 14 Open-Source-Projekten evaluiert. Die Ergebnisse zeigen, dass der präsentierte Regelsatz ernsthafte Implementierungsfehler aufdecken kann und die präsentierten Lösungsansätze zu ihrer Reparatur geeignet sind.

Contemporary integrated development environments (IDEs) elaborate functionality with regard to error detection and error fixing for programs of general purpose languages (GPLs) such as Java. However, for many domain-independent concerns, frameworks nowadays deliver standardized, reusable solutions. The Java Persistence API (JPA) is a typical example of this, as it specifies a standardized API for the mapping of application objects to records of a relational database and vice versa. While the GPL’s rules of well-formedness are well-known to IDEs (enabling them to detect errors early and to suggest program transformations for their repair), the rules that the used frameworks impose on programs are not. Consequently, programmers experience costly interruptions as they easily overlook errors and do not become aware of them until the application fails at runtime. On the other hand, a static code analysis could reveal many errors at development time and one may expect that an IDE provides support for framework-specific well-formedness rules to the same extent as it does for the underlying GPL. This dissertation argues that the limitation of framework support cannot be overcome unless a way is found to separate the responsibility of defining the rules of a framework’s well-formedness (which is up to the framework provider) from that of implementing algorithms for their validation and fixing detected errors (which is up to the IDE provider). This work shows that constraint-based development tools, that is, mapping a software development problem to the well-understood formalism of a constraint satisfaction problem (CSP), can provide the fundamentals for that distribution of responsibilities. These tools are based on a declarative definition of a specific program property (e.g., well-formedness) and the search of program transformations satisfying it by using generic search algorithms from artificial intelligence. This thesis presents (a) a set of well-formedness rules for the Java Persistence API which is given as invariants in the Object Constraint Language (OCL); (b) a procedure translating OCL expressions into constraints of a CSP; (c) an algorithm for error identification and localization based on these constraints; (d) a method for the determination of repair suggestions for a given error, called shallow fixing, that considers an error in isolation and — just like quick fixes of typical IDEs do — risks introducing new errors into the program and (e) three different approaches eliminating that risk by including related constraints during the search for repair suggestions, which is called deep fixing. Finally, these approaches are (f) systematically evaluated on 14 open source projects. Results show that the presented ruleset for JPA reveals serious implementation errors and that the correction methods are well-suited for their repair.

Vorschau

Zitieren

Zitierform:

Ulke, Bastian: Reparatur von Programmen mithilfe der Object Constraint Language. Hagen 2017. FernUniversität in Hagen.

Zugriffsstatistik

Gesamt

Volltextzugriffe:
Metadatenansicht:

12 Monate

Volltextzugriffe:
Metadatenansicht:

Rechte

Nutzung und Vervielfältigung:
Alle Rechte vorbehalten

Export

powered by MyCoRe