Incrementalization of analyses for next generation IDEs [Elektronische Ressource] / vorgelegt von Sven Kloppenburg

Sven Kloppenburg

Sujets

• Informatik

Informations

• Publié par: technischen_universitat_darmstadt
• Publié le: 01 janvier 2009
• Nombre de lectures: 15
• Langue: English
• Poids de l'ouvrage: 2 Mo

Extrait

Incrementalization of Analyses for
Next Generation IDEs
Vom Fachbereich Informatik der Technischen Universität Darmstadt genehmigte
Dissertation
zur Erlangung des akademischen Grades eines
Doktor–Ingenieurs (Dr.-Ing.)
vorgelegt von
Diplom Informatiker Sven Kloppenburg
geboren in Darmstadt
Referent: Prof. Dr.–Ing. Mira Mezini
Korreferent: Prof. Dr. rer. nat. Andy Schürr
Datum der Einreichung: 14.11.2008 der mündlichen Prüfung: 16.1.2009
Darmstadt 2009
D172Abstract
To support developers in their day–to–day work, Integrated Develoment En-
vironments (IDEs) incorporate more and more ways to help developers fo-
cus on the inherent complexities of developing increasingly larger software
systems. The complexity of developing large software systems can be cate-
gorized [24] into inherent complexity that stems from the complexity of the
problem domain and accidential complexity that stems from the shortcom-
ings of the tools and methods used to tackle the problem. For example: To
reduce the complexity of having to know exactly, which methods a certain
class provides, IDEs offer autocompletion. To alert developers to errors and
potential errors in their use of the programming language, IDEs connect the
lists of warnings and errors with their source locations. To ease navigation in
bigger projects, structural views of the program, such as the type hierarchy
are presented. Development environments thus enable developers to be more
productive and help them to find bugs earlier in the development cycle by
using codified expert knowledge.
In these environments, static anlyses are used to extract information from
the program under development. Static analyses detect properties of pro-
grams without running them. In the past, static analyses were mostly inte-
grated into compilers with the goal to check for errors and to produce faster
or smaller code. Integrating static analyses into the IDE opens up new ar-
eas of application. Among these are domain specific analyses, optional type
systems and checks for structural properties. Domain specific analyses check
properties specific to the program under development. For example, that the
use of a framework conforms to the specifications. Optional type systems [22]
are type systems that do not influence the runtime semantics. This allows
to have multiple type systems (e.g. confined types [135] and the builtin Java
type system) to coexist and to be checked by static analyses.
If these analyses are available to developers, a wider range of software
defects can be detected. By integrating the analyses into the IDE, faster and
better feedback can be delivered. This enables developers to incorporate the
analyses in their daily workflow, as it preserves the immediacy [24].
To gain full advantage of IDE integration, the analyses need to be inte-
grated into the incremental build process of the IDE and the rulebases should
bemodularlymodifiabletofittheprogramunderinspection [24]. Oneexam-
ple for an open, modular approach to achieve this is Magellan [55]. Magellan
is a build process integrated open static analysis platform that tackles the
problems of integrating static analyses with the IDE and in particular with
the incremental build process. To benefit from this integration, analyses
running on such platforms need to work in an incremental fashion.
3In this thesis, approaches for incrementalizing static analyses for inte-
grated open static analysis platforms are analyzed. Incrementalizing a static
analysis means, that the analyses uses the result from a previous build and
the changes made to the program as additional input to reconcile the result
from the previous build. The result is equal to an analysis of the full build.
The approaches can be categorized into manual incrementalization and
automatic incrementalization. Manual incrementalization uses a general pur-
pose language, such as Java, to implement a static analysis that achieves the
incrementalization using a special purpose algorithm. Automatic incremen-
talization means, that the analysis is written with the full build in mind,
and the underlying mechanisms of the language or framework has a builtin
mechanism to reconcile the results for the changed program.
Currently, incrementalanalysesaredevelopedinanadhocfashion, choos-
ing the approach the developer is most familiar with. If the appraoch taken
is not the best for the problem at hand, then either the development will
take longer or the analysis will run slower then necessary. To investigate
the properties of analyses that influence the recommended appraoches to
incrementalization, three static analyses have been selected. The analyses
were implemented twice; once using the manual approach and once using the
automatic approach.
The three selected analysis represent analyses that check for data flow
properties, control flow properties and structural properties of the inspected
program.
The analysis that checks for data flow properties searches for violations
of an optional type system for confined types.
The analysis that checks for control flow properties incrementally com-
putes the call graph using the rapid type analysis (RTA).
Finally, the static analysis that checks for structural properties searches
for violations of structural dependencies between concerns in the program.
The results indicate, that analyses incorporating query engines to be used
by the user of the analysis need to use automatic incrementalization at least
for this purpose. Analyses that can be configured only in narrow, predictable
ways lend themselves to manual incrementalization. Then the domain knowl-
edge allows for domainspecific optimizations that cannot easily be integrated
into the frameworks for automatic incrementalization.
4Zusammenfassung
Um Entwickler in ihrer täglichen Arbeit zu unterstützen, integrieren integri-
erte Entwicklungsumgebungen (IDEs) zunehmend mehr Hilfsmittel, die es
Entwicklern erlauben, sich auf die inhärente Komplexität der Entwicklung
zunehmend größerer Software Systeme zu konzentrieren.
Die Komplexität der Entwicklung dieser Systeme wird unterteilt [24] in
inhärente K die aus der Komplexität der Problemstellung stammt,
1sowie accidentielle Komplexität die von der Unzulänglichkeit der verwende-
ten Werkzeuge und Methoden kommt und daher durch bessere Werkzeuge
beseitigt werden kann. So bieten IDEs automatische Vervollständigung an,
damit Entwickler sich nicht die genaue Schreibweise von Methoden merken
müssen. Um Entwickler auf (potentielle) Fehler im Gebrauch der Program-
miersprachehinzuweisen,werdenFehlermeldungeninderIDEmitdemQuell-
text verknüpft. Um die Navigation in Projekten zu erleichtern bieten IDEs
strukturelle Ansichten des Programms, wie z.B. die Typhierarchie an. IDEs
ermöglichen Entwicklern, produktiver zu sein und Fehler früher zu finden, in
dem sie kodifiziertes Expertenwissen nutzen.
In IDEs werden statische Analysen benutzt, um Informationen aus dem
Programm in Entwicklung zu extrahieren. Statische Analysen entdecken
Eigenschaften von Programmen, ohne diese auszuführen. In der Vergan-
genheit waren statische Analysen meist in Compilern integriert, um Fehler
zu finden und kleineren oder schnelleren Code zu produzieren. Werden
statische Analysen in IDEs integriert, öffnen sich ihnen neue Anwendungsge-
biete. Unter diesen sind domainspezifische Analysen, optionale Typsysteme
und das Überprüfen struktureller Eigenschaften. Optionale Typsysteme [22]
sind Typsysteme die die Laufzeitsemantik nicht verändern. Das erlaubt es,
mehrere T (zum Beispiel confined types [135] und das Java Typ-
system) zu kombinieren und von statischen Analysen prüfen zu lassen.
Wenn diese Analysen Entwicklern zur Verfügung stehen, kann ein bre-
iterer Bereich von Softwaredefekten erkannt werden. Durch das Integrieren
der Analysen in die Entwicklungsumgebung kann dem Entwickler schneller
und besser Rückmeldung gegeben werden. Das erlaubt es den Entwicklern,
die Analysen in ihren alltäglichen Arbeitsablauf zu integrieren, da die Un-
mittelbarkeit der Rückmeldungen gewahrt bleibt [24].
Um den vollen Vorteil der IDE Integration zu erreichen, müssen die Ana-
lysenzumEinenindeninkrementellenÜbersetzungsvorgangeingebettetwer-
den und zum Anderen müssen die Analysen die ausgeführt werden an das
untersuchte Programm anpassbar sein [24]. Ein Beispiel für einen offenen,
1Das “accidentielle” ist [58] das Unwesentliche, Wechselende, Äussere, Zufällige
5modularen Ansatz um dies zu erreichen ist Magellan [55]. Magellan ist eine
offene statische Analyseplattform die in den inkrementellen Übersetzungs-
vorgang integriert ist und die es ermöglicht, statische Analysen in IDEs und
insbesondere in den inkrementellen Übersetzungsvorgang zu integrieren.
In dieser Arbeit werden Ansätze zur Inkrementalisierung statischer Ana-
lysen für integrierte, offene statische Analyseplattformen untersucht. Eine
statischeAnalysezuinkrementalisierenbedeutet, dassdieAnalysedieErgeb-
nisse eines vorhergenden Übersetzunsvorgangs und die Änderungen am Pro-
gramm nutzt, um das Analyseergebnis an den aktuellen Zustand des Pro-
gramms anzugleichen. Das ist dann