Kontrollflusssensible Quelltext-Umgestaltung mithilfe von Constraint-Programmierung
| dc.contributor.advisor | Jähnichen, Stefan | |
| dc.contributor.author | Mews, Marcus | |
| dc.contributor.grantor | Technische Universität Berlin | en |
| dc.contributor.referee | Jähnichen, Stefan | |
| dc.contributor.referee | Fischer, Bernd | |
| dc.contributor.referee | Pepper, Peter | |
| dc.date.accepted | 2016-06-06 | |
| dc.date.accessioned | 2016-08-23T11:10:42Z | |
| dc.date.available | 2016-08-23T11:10:42Z | |
| dc.date.issued | 2016 | |
| dc.description.abstract | Das Umgestalten von Quelltext ist ein essentieller Bestandteil beim Entwickeln, Erweitern und Warten von Programmen. Wird Quelltext umgestaltet, ändern sich lediglich seine Struktur oder Bezeichner, während seine Funktion unverändert bleibt. Das Umgestalten geht jedoch Hand in Hand mit dem Einführen von Funktionsänderungen. Denn häufig können Funktionsänderungen nur mit vorangegangener oder anschließender Umgestaltung durchgeführt werden, um Quelltexteigenschaften wie Lesbarkeit und Verständlichkeit nicht zu beeinträchtigen. Diese Eigenschaften sind im Kontext von langjährig eingesetzten Programmen mit häufigem Änderungs- und Anpassungsbedarf von großer Bedeutung. Beim Umgestalten von Programmen nutzen Entwickler automatische Funktionen der Entwicklungsumgebungen und vertrauen darauf, dass diese Funktionen verlässlich und fehlerfrei arbeiten. Ebenfalls sind diese Funktionen dann optimal einsetzbar, wenn sie flexibel auch in unübersichtlichen oder schwierigen Situationen angewendet werden können. Leider treffen beide Eigenschaften auf etablierte Entwicklungsumgebungen wie Eclipse nur eingeschränkt zu. Sie arbeiten nicht immer fehlerfrei und verweigern unter bestimmten Umständen die Quelltextumgestaltung. Ziel dieser Arbeit ist, einen Ansatz zum Durchführen kontrollflusssensibler Java- Umgestaltungen vorzustellen, damit diese fehlerfrei, flexibel und praxistauglich eingesetzt werden können. Hierzu werden fünf kontrollflusssensiblen Umgestaltungen vorgestellt, die von einer gemeinsamen Betrachtung profitieren, da die durch sie durchgeführten Änderungen in wechselseitiger Beziehung stehen. Die fünf Umgestaltungen Einfügen oder Extrahieren lokaler Variablen, Verschieben/ Vertauschen von Ausdrücken oder Anweisungen sowie das Verschieben von Argumenten werden in der Arbeit als Constraint-Problem interpretiert. Dazu wird das relevante Teilprogramm als Gleichungssystem abstrahiert und durch einen Constraint-Löser gelöst. Aus der Lösung wird eine Menge von Transformationen abgeleitet, die einerseits den Umgestaltungswunsch erfüllen und andererseits das Programmverhalten nicht ändern. Die Arbeit zeigt, dass der untersuchte Ansatz Umgestaltungen sowohl verhaltenserhaltend, flexibel als auch schnell genug durchführen kann. Im Rahmen zweier Untersuchungen wird der Ansatz zunächst anhand von Beispielen mit drei etablierten Entwicklungsumgebungen verglichen. Dabei kann gezeigt werden, dass der Ansatz in jedem Fall korrekt und flexibel arbeitet. In einer zweiten Untersuchung wird ermittelt, wie sich der Ansatz im Vergleich zu Eclipse an beliebigen Beispielen aus einer Reihe von quelloffenen Projekten verhält. Die Korrektheit wird dabei mithilfe einer Test-Suite festgestellt. Die Ergebnisse zeigen, dass der Ansatz im Vergleich zu Eclipse das Programmverhalten wesentlich seltener ändert und auch in schwierigen Situationen Umgestaltungen berechnen kann. Darüber hinaus wird gezeigt, dass in 90% aller Fälle Umgestaltungen in weniger als fünf Sekunden ermittelt werden können. | de |
| dc.description.abstract | The refactoring of source code is an essential part in the development, maintenance and extension of software. When refactoring source code, only its structure and symbol names may change but the original behavior of the program must remain the same. Nevertheless, refactoring is often accompanied by functional changes that change the program behavior during the development. This is due to the necessary to improve source code properties like readability, comprehensibility and maintainability before, during or after applying functional changes to the code. These source code properties are of great importance in long-term used software. When refactoring source code, developers use automatic built-in functions of integrated development environments and rely on their reliability and correctness. Also, the refactoring functions are optimal in terms of their benefit for the programmer, when they are flexible enough to give helpful result even in difficult and confusing source code situations. Unfortunately, both of these properties apply to established development environments like Eclipse only partially. They do not always work correctly and often refuse to return helpful results in difficult situations. The goal of this thesis is to present an approach to improve control flow sensitive refactorings in terms of correctness, benefits for the programmer and practicability. The approach is presented using five refactoring instances that benefit from being addressed together, since the changes they cause have a mutual impact on each other. In this thesis, the five refactoring instances, inline or extract of variables, move or switch expressions or statements, or move method arguments are mapped to a constraint problem. For that purpose, the relevant source code is abstracted to a system of equations and variables, which is solved using a common constraint solver. By comparing the initial variable values to the values of the solution, a set of transformations is retrieved. These transformations fulfill the refactoring intent of the developer and also keep the program behavior unchanged. This work shows that the examined approach is able to improve the benefits of the refactoring instances while keeping the program behavior unchanged in a tolerable computation time. The approach is evaluated in two manners. First, the results of the approach are compared to the refactoring results of three other established development environments using 15 handpicked examples. This evaluation shows that the approach computes helpful and correct results in every case. Second, the approach is massively tested and compared to Eclipse using several open source projects. The correctness is determined using the test suites that come along with the open source projects. The results show that the approach alters the program behavior only very rarely compared to Eclipse, and the approach also computes helpful refactoring instances in difficult situations. Moreover it is shown that it computes a refactoring solution in 90% of all cases in less than five seconds. | en |
| dc.identifier.uri | https://depositonce.tu-berlin.de/handle/11303/5845 | |
| dc.identifier.uri | http://dx.doi.org/10.14279/depositonce-5444 | |
| dc.language.iso | de | en |
| dc.rights.uri | https://creativecommons.org/licenses/by/4.0/ | en |
| dc.subject.ddc | 005 Computerprogrammierung, Programme, Daten | de |
| dc.subject.other | Refaktoring | de |
| dc.subject.other | Java | de |
| dc.subject.other | Kontrollfluss | de |
| dc.subject.other | refactoring | en |
| dc.subject.other | constraint-system | en |
| dc.subject.other | control-flow | en |
| dc.title | Kontrollflusssensible Quelltext-Umgestaltung mithilfe von Constraint-Programmierung | de |
| dc.title.translated | Control-flow sensible source code refactoring using constraint-programming | en |
| dc.type | Doctoral Thesis | en |
| dc.type.version | acceptedVersion | en |
| tub.accessrights.dnb | free | en |
| tub.affiliation | Fak. 4 Elektrotechnik und Informatik::Inst. Softwaretechnik und Theoretische Informatik | de |
| tub.affiliation.faculty | Fak. 4 Elektrotechnik und Informatik | de |
| tub.affiliation.institute | Inst. Softwaretechnik und Theoretische Informatik | de |
| tub.publisher.universityorinstitution | Technische Universität Berlin | en |