In many enterprises, the number of deployed applications is constantly increasing. Those applications - often several hundreds - form large software landscapes. The comprehension of such landscapes is frequently impeded due to, for instance, architectural erosion, personnel turnover, or changing requirements. Furthermore, events such as performance anomalies can often only be understood in correlation with the states of the applications. Therefore, an efficient and effective way to comprehend such software landscapes in combination with the details of each application is required. In this thesis, we introduce a live trace visualization approach to support system and program comprehension in large software landscapes. It features two perspectives: a landscape-level perspective using UML elements and an application-level perspective following the 3D software city metaphor. Our main contributions are 1) an approach named ExplorViz for enabling live trace visualization of large software landscapes, 2) a monitoring and analysis approach capable of logging and processing the huge amount of conducted method calls in large software landscapes, and 3) display and interaction concepts for the software city metaphor beyond classical 2D displays and 2D pointing devices. Extensive lab experiments show that our monitoring and analysis approach elastically scales to large software landscapes while imposing only a low overhead on the productive systems. Furthermore, several controlled experiments demonstrate an increased efficiency and effectiveness for solving comprehension tasks when using our visualization. ExplorViz is available as open-source software on www.explorviz.net. Additionally, we provide extensive experimental packages of our evaluations to facilitate the verifiability and reproducibility of our results.
Ebooka przeczytasz w aplikacjach Legimi lub dowolnej aplikacji obsługującej format:
Liczba stron: 331
Dissertationzur Erlangung des akademischen GradesDoktor der Ingenieurwissenschaften(Dr.-Ing.)der Technischen Fakultätder Christian-Albrechts-Universität zu Kieleingereicht im Jahr 2015
The Kiel Computer Science Series (KCSS) covers dissertations, habilitation theses, lecture notes, textbooks, surveys, collections, handbooks, etc. written at the Department of Computer Science at Kiel University. It was initiated in 2011 to support authors in the dissemination of their work in electronic and printed form, without restricting their rights to their work. The series provides a unified appearance and aims at high-quality typography. The KCSS is an open access series; all series titles are electronically available free of charge at the department’s website. In addition, authors are encouraged to make printed copies available at a reasonable price, typically with a print-on-demand service.
Please visit http://www.informatik.uni-kiel.de/kcss for more information, for instructions how to publish in the KCSS, and for access to all existing publications.
Prof. Dr. Wilhelm HasselbringChristian-Albrechts-Universität zu Kiel
Prof. Dr. Michele LanzaUniversity of Lugano
Datum der mündlichen Prüfung: 30. November 2015
In vielen Unternehmen nimmt die Anzahl der eingesetzten Anwendungen stetig zu. Diese Anwendungen – meist mehrere hunderte – bilden große Softwarelandschaften. Das Verständnis dieser Softwarelandschaften wird häufig erschwert durch, beispielsweise, Erosion der Architektur, personelle Wechsel oder sich ändernde Anforderungen. Des Weiteren können Ereignisse wie Performance-Anomalien häufig nur in Verbindung mit den Anwendungszuständen verstanden werden. Deshalb wird ein möglichst effizienter und effektiver Weg zum Verständnis solcher Softwarelandschaften in Verbindung mit den Details jeder einzelnen Anwendung benötigt.
In dieser Arbeit führen wir einen Ansatz zur live Trace Visualisierung zur Unterstützung des System- und Programmverständnisses von großen Softwarelandschaften ein. Dieser verwendet zwei Perspektiven: eine Landschaftsperspektive mit UML Elementen und eine Applikationsperspektive, welche der 3D Softwarestadtmetapher folgt. Unsere Hauptbeiträge sind 1) ein Ansatz, genannt ExplorViz, um live Trace Visualisierung von großen Softwarelandschaften zu ermöglichen, 2) ein Überwachungs- und Analyseansatz, welcher in der Lage ist die große Anzahl an Methodenaufrufen in einer großen Softwarelandschaft aufzuzeichnen und zu verarbeiten und 3) Anzeige- und Interaktionskonzepte für die Softwarestadtmetapher, welche über klassische 2D Anzeige und 2D Eingabegeräten hinausgehen.
Umfassende Laborexperimente zeigen, dass unser Überwachungs- und Analyseansatz für große Softwarelandschaften elastisch skaliert und dabei nur einen geringen Overhead auf den Produktivsystemen erzeugt. Des Weiteren demonstrieren mehrere kontrollierte Experimente eine gesteigerte Effizienz und Effektivität beim Lösen von Verständnisaufgaben unter Verwendung unserer Visualisierung. ExplorViz ist als Open Source Anwendung verfügbar unter www.explorviz.net. Zusätzlich stellen wir umfangreiche Pakete für unsere Evaluierungen zur Verfügung um die Nachvollziehbarkeit und Wiederholbarkeit unserer Ergebnisse zu ermöglichen.
In many enterprises, the number of deployed applications is constantly increasing. Those applications – often several hundreds – form large software landscapes. The comprehension of such landscapes is frequently impeded due to, for instance, architectural erosion, personnel turnover, or changing requirements. Furthermore, events such as performance anomalies can often only be understood in correlation with the states of the applications. Therefore, an efficient and effective way to comprehend such software landscapes in combination with the details of each application is required.
In this thesis, we introduce a live trace visualization approach to support system and program comprehension in large software landscapes. It features two perspectives: a landscape-level perspective using UML elements and an application-level perspective following the 3D software city metaphor. Our main contributions are 1) an approach named ExplorViz for enabling live trace visualization of large software landscapes, 2) a monitoring and analysis approach capable of logging and processing the huge amount of conducted method calls in large software landscapes, and 3) display and interaction concepts for the software city metaphor beyond classical 2D displays and 2D pointing devices.
Extensive lab experiments show that our monitoring and analysis approach elastically scales to large software landscapes while imposing only a low overhead on the productive systems. Furthermore, several controlled experiments demonstrate an increased efficiency and effectiveness for solving comprehension tasks when using our visualization. ExplorViz is available as open-source software on www.explorviz.net. Additionally, we provide extensive experimental packages of our evaluations to facilitate the verifiability and reproducibility of our results.
by Prof. Dr. Wilhelm Hasselbring
Software visualization is a non-trivial research field, and with his thesis Florian Fittkau has made original contributions to it. Florian Fittkau investigates how “live trace visualization” can be leveraged for the analysis and comprehension of large software landscapes. Specific contributions are the ExplorViz method with its monitoring and trace processing for landscape model generation, as well its 3D visualization.
Highly innovative are the new techniques for printing such 3D visualizations into physical models for improved program comprehension in teams and the new techniques for immersion into these 3D visualizations via topical virtual reality equipment.
Besides the conceptual work, this work contains a significant experimental part and a multifaceted evaluation. This engineering dissertation has been extensively evaluated with advanced student and lab experiments, based on a high-quality implementation of the ExplorViz tools.
This thesis is a good read and I recommend it to anyone interested in recent software visualization research.
Wilhelm Hasselbring Kiel,December 2015
1.1 Motivation and Problem Statement
1.2 Scientific Contributions
1.3 Preliminary Work
1.4 Document Structure
2 Application Monitoring
2.2 Trace Concept
2.3 Live versus Offline Analysis
3 Software Visualization
3.1 Visualization Pipeline
3.2 Software City Metaphor
3.3 Trace Visualization
3.4 Remote-Procedure-Call Visualization
II The ExplorViz Approach
4 Research Design
4.1 Research Methods
4.2 Research Questions and Research Plan
5 The ExplorViz Method
5.1 Fundamental Approach
6 Monitoring and Trace Processing
6.1 Application-Level Monitoring
6.2 Remote-Procedure-Call Monitoring
6.3 Trace Processing
7 Landscape Model Generation
7.1 Landscape Meta-Model
7.2 Trace-to-Model Mapping
8 ExplorViz Visualization
8.1 Use Cases
8.2 Basic Concepts
8.3 Landscape-Level Perspective
8.4 Application-Level Perspective
8.5 Gesture-Controlled Virtual Reality Approach
8.6 Physical 3D-Printed City Models
9 ExplorViz Implementation
9.1 Overall Architecture
9.5 Visualization Provider
10 Monitoring and Trace Processing Evaluation: Lab Experiments
10.2 Monitoring Overhead Evaluation
10.3 Live Trace Processing Evaluation
10.4 Scalability and Elasticity Evaluation
11 Visualization Evaluation: Controlled Experiments
11.2 Application Perspective Evaluation
11.3 3D-Printed City Model Evaluation
11.4 Landscape Perspective Evaluation
12 Extensibility Evaluation: Integrating a Control Center Concept
12.2 Control Center Concept
12.3 Case Study
13 Related Work
13.1 Monitoring and Trace Processing
IV Conclusions and Future Work
14.1 Monitoring and Trace Processing
15 Future Work
15.1 Monitoring and Trace Processing
A Experimental Data for the Extensibility Evaluation
List of Figures
List of Tables
List of Listings
This chapter provides an introduction to this thesis. Chapter 1.1 describes the motivation for our research. Afterwards, Chapter 1.2 presents the scientific contributions. Preliminary work is discussed in Chapter 1.3. Finally, Chapter 1.4 lists the structure of this thesis.
Parts of this chapter are already published in the following works:
1. [Fittkau et al. 2013b] F. Fittkau, J. Waller, C. Wulf, and W. Hasselbring. Live trace visualization for comprehending large software landscapes: the ExplorViz approach. In:
Proceedings of the 1st IEEE International Working Conference on Software Visualization (VISSOFT 2013)
. IEEE, Sept. 2013
2. [Fittkau 2013] F. Fittkau. Live trace visualization for system and program comprehension in large software landscapes. Technical report 1310. Department of Computer Science, Kiel University, Germany, Nov. 2013
In many enterprises, the number of software systems is constantly increasing. This can be a result of changing requirements due to, e.g., changing laws or customers, which the company has to satisfy. Furthermore, the legacy systems often interact with each other through defined interfaces. For example, the database may be accessed by different programs. In the whole, the applications form a large, complex software landscape [Penny 1993] which can include several hundreds or even thousands of applications.
The knowledge of the communication, internals, and utilization of this software landscape often gets lost over the years [Moonen 2003; Vierhauser et al. 2013] due to, for instance, missing documentation. For those software landscapes, tools that support the program and system comprehension of the software landscape become important. For example, they can provide essential insights into the landscape in the maintenance phase [Lewerentz and Noack 2004]. A software engineer might need to create or adapt features in the landscape. Therefore, she often needs to know the communication between the existing programs and also the control flow inside the application is of interest to find the locations where she needs to do the adaptations [Koschke and Quante 2005]. In this context, the goal of DFG SPP1593 “Design For Future - Managed Software Evolution” is to invent approaches for so-called knowledge-carrying software to overcome the challenges of missing documentation [Goltz et al. 2015].
Another challenge concerning a large software landscape is the question which applications are actually used and to what extent they are used. The operation and support of software can cause substantial costs. These costs would not incur when the unused application gets removed from the software landscape. However, asking every user whether she uses each application is often not applicable and if it is, she might indirectly use applications such as a database, for instance.
Recent approaches in this field of software visualization, e.g., [Panas et al. 2003; Greevy et al. 2006; Wettel and Lanza 2007; Hamou-Lhadj 2007; Dugerdil and Alam 2008], focus on the visualization of a single application. A drawback of visualizing only one application is omitting the communication and linkage between the applications involved in a transaction.
Another drawback of current approaches is the possible lack of traces associated to a feature. For example, a software engineer might analyze a feature called add to cart. The investigation of this feature might lead to interest in the related feature checkout cart. However, this feature might not be available as a trace. Often the required trace can be generated manually for one application but this can become cumbersome in a large software landscape. In addition, one trace can only reveal information on its particular execution of operations, for instance, the response time of this single execution of a operation. If this response time is a statistical outlier, the user might draw false conclusions about the application.
Due to the huge amount of method calls conducted in a large software landscape – typically millions of method calls per second –, monitoring and creating the required traces of the executions for the visualization can become a further challenge [Vierhauser et al. 2013]. One server is not capable of processing such a huge amount of data in parallel to the actual execution of the software landscape.
This thesis makes the following three major scientific contributions (SC1 – SC3) including nine subcontributions:
SC1: An approach named ExplorViz for enabling live trace visualization of large software landscapes
SC1.1: A software landscape visualization featuring hierarchies to provide visual scalability
SC1.2: An interactive extension of the software city metaphor for exploring runtime information of the monitored application
SC1.3: A landscape meta-model representing gathered information about a software landscape
SC1.4: A proof-of-concept implementation used in three controlled experiments for comparing our visualization approach to the current state of the art in system and program comprehension scenarios
SC2: A monitoring and analysis approach capable of logging and processing the huge amount of conducted method calls in large software landscapes
SC2.1: A scalable, elastic, and live analysis architecture for processing the gathered monitoring data by using cloud computing
SC2.2: A proof-of-concept implementation used in three lab experiments showing the low overhead of the monitoring approach, and the scalability and elasticity of our analysis approach by monitoring up to 160 instances of a web application
SC3: Display and interaction concepts for the software city metaphor beyond classical 2D displays and 2D pointing devices
SC3.1: A gesture-controlled virtual reality approach for the software city metaphor
SC3.2: An approach to create physical 3D-printed models following the software city metaphor
SC3.3: Proof-of-concept implementations and a controlled experiment comparing physical 3D-printed models to using virtual models on the computer screen in a team-based program comprehension scenario
For all evaluations, we provide experimental packages to facilitate the verifiability, reproducibility, and further extensibility of our results. In the following, each contribution is described.
SC1: ExplorViz Approach For Enabling Live Trace Visualization of Large Software Landscapes
The first scientific contribution (SC1) of this thesis is an approach to enable live trace visualization for large software landscapes named ExplorViz which supports a software engineer during system and program comprehension tasks. Our live trace visualization for large software landscapes combines distributed and application traces. It contains a 2D visualization on the landscape level. In addition, it features a 3D visualization utilizing the software city metaphor on the application level. By application level, we refer to the issues concerning one application and only this application. Whereas the landscape level provides knowledge about the different applications and nodes in the software landscape.
Since a live visualization updates itself after a defined interval, we feature a time shift mode where the software engineer can view the history of old states of the software landscape. Furthermore, she is able to jump to an old state and pause the visualization to analyze a specific situation.
To cope with the high density of information which should be visualized, the major concept of ExplorViz is based on interactively revealing additional details, e.g., the communication on a deeper system level, on demand. The concept is motivated by the fact that the working memory capacity of humans is limited to a small amount of chunks [Ware 2013]. Miller  suggests seven, plus or minus two, chunks which is also referred to as Miller’s Law. The ExplorViz concept also follows Shneiderman’s Visual Information-Seeking Mantra: “Overview first, zoom and filter, then details on demand” [Shneiderman 1996].
This contribution contains four subcontributions (SC1.1 – SC1.4) which are briefly described in the following.
SC1.1: Software Landscape Visualization Featuring Hierarchies to Provide Visual Scalability Our landscape-level perspective shows the nodes and applications of a software landscape. In addition, it summarizes nodes running the same application configuration into node groups. These equal application configurations typically exist in cloud environments. However, to understand the overall architecture of the software landscape, the user is interested in the existing application configuration. Afterwards, the details about the concrete instances can be interactively accessed.
To provide further visual scalability, the nodes and node groups are visualized within their belonging systems which act as an organizational unit. Again, the details about a system can be accessed interactively and out-of-focus systems can be closed to show only details about relevant systems.
SC1.2: Interactive Extension of the Software City Metaphor for Exploring Runtime Information On the application level, we use the 3D software city metaphor to display the structure and runtime information of a monitored application. Again, the visual scalability is provided by interactivity. When accessing the perspective, the components are only opened at the toplevel, i.e., details are hidden. In our terms, components are organizational units provided by the programming language, e.g., packages in Java. By interactively opening and closing the components, the software engineer is able to explore the application and the gathered runtime information.
SC1.3: Landscape Meta-Model for Representing Information of a Software Landscape Furthermore, we provide a landscape meta-model for representing the gathered information of the software landscape. This model can be used as input for other tools. Thus, the gathered data is also reusable for other scenarios, e.g., automatically updating the configuration of an enterprise application landscape based on the monitoring data.
SC1.4: Proof-of-Concept Implementation Used in Three Controlled Experiments The full ExplorViz approach is implemented as open-source software and available from our website.1 To evaluate our live trace visualization approach, we conducted three controlled experiments.
The first controlled experiment compared the usage of ExplorViz to using the trace visualization tool EXTRAVIS [Cornelissen et al. 2007] in a program comprehension scenario of the quality tool PMD.2 The experiment showed that ExplorViz was more efficient and effective than EXTRAVIS in supporting the solving of the defined program comprehension tasks. The second experiment was a replication of this experiment design where we used a smaller object system named Babsi.3 In this replication, the used time difference was not significant. However, the correctness of the task solution was significantly increased in the ExplorViz group. The third experiment compared our hierarchical landscape-level perspective to a mix of flat state-of-the-art landscape visualizations found in Application Performance Management (APM) tools in a system comprehension scenario. Again, the time difference was not significantly different but the correctness of the solutions was significantly increased in the ExplorViz group.
SC2: Monitoring and Analysis Approach for Applications in Large Software Landscapes
In large software landscapes, several millions of method calls can be conducted each second. Therefore, the monitoring and the analysis approach requires to scale with the size of the software landscape. Furthermore, the approach should be elastic to avoid producing unnecessary costs. A further requirement for the approach is the low overhead of the monitoring to keep the impact on the production systems as low as possible. According to those requirements, we developed our monitoring and analysis approach which is outlined in the following.
SC2.1: Scalable, Elastic, and Live Analysis Architecture Using Cloud Computing To provide a scalable, elastic, and live monitored data analysis approach, we utilize cloud computing and an automatic capacity manager named CapMan.4 Our approach is similar to the MapReduce pattern [Dean and Ghemawat 2010] but we feature multiple dynamically inserted preprocessing levels. When the master analysis node impends to get overutilized, a new preprocessing worker level is automatically inserted between the master and the monitored applications and thus the CPU utilization of the master node is decreased. If it impends to get overutilized again, another level of workers is inserted. In theory, this happens every time the master impends to get overutilized. If a worker level is not utilized enough anymore, it is dynamically removed and thus resources are saved.
SC2.2: Proof-of-Concept Implementation Used in Three Lab Experiments We implemented our monitoring and analysis approach as proof-of-concept implementation and provide necessary additional components such as the capacity manager as open-source software on our website. For the evaluation of our monitoring and analysis approach, we conducted three lab experiments.
We evaluated the low overhead in the first lab experiment by comparing Kieker5 [van Hoorn et al. 2012], which was already shown to impose a low overhead [Eichelberger and Schmid 2014], to our monitoring component using the monitoring benchmark MooBench [Waller 2014].6 As a result, we achieved a speedup of about factor nine and a 89% overhead reduction.
The second lab experiment extended the first experiment by the live analysis of the generated monitoring data. This experiment showed that adding the analysis step only negligibly impacts the throughput and thus is capable of live analyzing the monitored data. Furthermore, we achieved a speedup of about 250 in comparison to Kieker.
We used our private cloud for the third lab experiment to evaluate the scalability and elasticity of our approach by monitoring elastically scaled JPetStore7 instances. In the peak, 160 JPetStore instances were monitored by our approach with two dynamically started worker levels resulting in about 20 million analyzed method calls per second.
SC3: Display and Interaction Concepts for the Software City Metaphor
In addition to providing a live trace visualization, we investigated new ways to display and interact with the software city metaphor [Knight and Munro 1999] beyond the display on classical 2D monitors and usage of classical 2D pointing devices. For a more immersive user experience, we provide a Virtual Reality (VR) approach featuring an Oculus Rift DK18 as display and a Microsoft Kinect v29 for gesture recognition. Furthermore, we construct physical 3D-printed software city models from our application- level perspective to enhance, for instance, the amount of conducted gestures in a team-based program comprehension scenario. Both approaches and an evaluation are described in the following.
SC3.1: Gesture-Controlled Virtual Reality Approach By using an Oculus Rift DK1 and Microsoft Kinect v2 for our VR approach, we achieve a more immersive user experience for exploring the software city metaphor. The Oculus Rift enables to perceive the model in 3D as if the user is flying above the city. To provide an even more immersive experience, we utilize gestures for interacting with the model.
SC3.2: Approach to Create Physical 3D-Printed Software City Models We construct physical 3D-printed models following the software city metaphor of our application-level perspective and detail four envisioned scenarios where physical models could provide benefits. These are team-based program comprehension, effort visualization in customer dialog, saving digital heritage, and educational visualization.
SC3.3: Proof-of-Concept Implementations and a Controlled Experiment for Physical 3D-Printed Models For both approaches, we provide proofof-concept implementations available in branches of our ExplorViz Git repository.10 Furthermore, we conducted a controlled experiment investigating the first envisioned usage scenario for the physical models in a team-based program comprehension scenario. Teams (pairs of two subjects) in the experimental group solved program comprehension tasks using only a 3D-printed model and the control group solved the tasks using a virtual model on the computer screen. Two discussion tasks were influenced positively by using the 3D-printed model and one task was influenced negatively. We attribute the positive influence to an observed increased amount of conducted gestures and the negative influence to less readable labels in the 3D-printed model.
This thesis builds on preliminary work which was already published in several research papers. Furthermore, it bases on various student theses which were co-supervised by the author. In the following, we first briefly describe and list our publications according to three categories: Approach, Evaluations, and Support Projects. Papers fall into the former two categories if they are closely related and explicitly contribute to those parts of this thesis. The latter category contains work that is related but only indirectly contributes to this thesis. Afterwards, the related student theses and their contributions to this thesis are briefly presented.
[Fittkau et al. 2013b] F. Fittkau, J. Waller, C. Wulf, and W. Hasselbring. Live trace visualization for comprehending large software landscapes: the ExplorViz approach. In:
Proceedings of the 1st IEEE International Working Conference on Software Visualization (VISSOFT 2013)
. IEEE, Sept. 2013
In this publication, we present our overall ExplorViz method and each of its steps. Furthermore, first sketches of the landscape-level and application-level perspective are shown.
[Fittkau et al. 2013c] F. Fittkau, J. Waller, P. C. Brauer, and W. Hasselbring. Scalable and live trace processing with Kieker utilizing cloud computing. In:
Proceedings of the Symposium on Software Performance: Joint Kieker/Palladio Days 2013 (KPDays 2013)
. Volume 1083. CEUR Workshop Proceedings, Nov. 2013
In this work, we describe the idea of multiple worker levels for analyzing the huge amount of generated monitoring records. Therefore, a worker and master concept and a scaling architecture are introduced. In addition, we show the MooBench benchmark results for comparing the analysis component of Kieker 1.8 and ExplorViz.
[Fittkau 2013] F. Fittkau. Live trace visualization for system and program comprehension in large software landscapes. Technical report 1310. Department of Computer Science, Kiel University, Germany, Nov. 2013
This technical report presents a plan of the contributions of this thesis and details an evaluation scenario for the application-level perspective.
[Fittkau et al. 2014a] F. Fittkau, P. Stelzer, and W. Hasselbring. Live visualization of large software landscapes for ensuring architecture conformance. In:
Proceedings of the 2nd International Workshop on Software Engineering for Systems-of-Systems (SESoS 2014)
. ACM, Aug. 2014
Architecture conformance checking is introduced as a further usage scenario beneath supporting system and program comprehension in this paper. Furthermore, we present a preliminary study of the scalability and thus applicability of our analysis approach.
[Fittkau et al. 2015g] F. Fittkau, S. Roth, and W. Hasselbring. ExplorViz: visual runtime behavior analysis of enterprise application landscapes. In:
Proceedings of the 23rd European Conference on Information Systems (ECIS 2015)
. AIS, May 2015
Performance analysis is a further usage scenario of our approach. Beneath introducing important aspects of the functionality for the performance analysis, we exemplify it on monitoring data gathered from the Perl-based application EPrints11 in this publication.
[Fittkau et al. 2015f] F. Fittkau, A. Krause, and W. Hasselbring. Exploring software cities in virtual reality. In:
Proceedings of the 3rd IEEE Working Conference on Software Visualization (VISSOFT 2015)
. IEEE, Sept. 2015
In this work, we present our approach to use VR for exploring the application-level perspective to provide an immersive experience. To enable VR, we use an Oculus Rift and provide further gesture-based interaction possibilities using a Microsoft Kinect.
[Fittkau et al. 2015i] F. Fittkau, E. Koppenhagen, and W. Hasselbring. Research perspective on supporting software engineering via physical 3D models. In:
Proceedings of the 3rd IEEE Working Conference on Software Visualization (VISSOFT 2015)
. IEEE, Sept. 2015
The approach of constructing physical 3D models of our application-level perspective is presented in this work. Additionally, four potential usage scenarios for these physical models are described.
[Fittkau et al. 2014b] F. Fittkau, A. van Hoorn, and W. Hasselbring. Towards a dependability control center for large software landscapes. In:
Proceedings of the 10th European Dependable Computing Conference (EDCC 2014)
. IEEE, May 2014
IT administrators often lack trust in automatic adaption approaches for their software landscapes. Therefore, we developed a semi-automatic control center concept which is presented in this publication. This control center concept is used as a target specification in our extensibility evaluation for the ExplorViz implementation.
[Waller et al. 2014a] J. Waller, F. Fittkau, and W. Hasselbring. Application performance monitoring: trade-off between overhead reduction and maintainability. In:
Proceedings of the Symposium on Software Performance 2014 (SOSP 2014)
. University of Stuttgart, Nov. 2014
In this publication, we present a structured benchmark-driven performance tuning approach exemplified on the basis of Kieker. The last performance tuning step is equal to our developed monitoring component of ExplorViz. Therefore, the paper contains a performance comparison between Kieker and the monitoring component of ExplorViz.
[Fittkau et al. 2015a] F. Fittkau, S. Finke, W. Hasselbring, and J. Waller. Comparing trace visualizations for program comprehension through controlled experiments. In:
Proceedings of the 23rd IEEE International Conference on Program Comprehension (ICPC 2015)
. IEEE, May 2015
Providing efficient and effective tools to gain program comprehension is essential. Therefore, we compare the application-level perspective of ExplorViz to the trace visualization tool EXTRAVIS in two controlled experiments to investigate which visualization is more efficient and effective in supporting the program comprehension process.
[Fittkau et al. 2015j] F. Fittkau, E. Koppenhagen, and W. Hasselbring. Research perspective on supporting software engineering via physical 3D models. Technical report 1507. Department of Computer Science, Kiel University, Germany, June 2015
Basing on the application-level visualization, we construct physical, solid 3D-printed models of the application. This publication presents the results of a controlled experiment comparing the usage of physical models to using virtual, on-screen models in a team-based program comprehension process.
[Fittkau and Hasselbring 2015b] F. Fittkau and W. Hasselbring. Elastic application-level monitoring for large software landscapes in the cloud. In:
Proceedings of the 4th European Conference on Service-Oriented and Cloud Computing (ESOCC 2015)
. Springer, Sept. 2015
In this publication, we present our scalable and elastic approach for processing the monitoring data. Furthermore, we describe an evaluation where we monitor 160 JPetStore instances and use dynamically inserted analysis worker levels.
[Fittkau et al. 2015h] F. Fittkau, A. Krause, and W. Hasselbring. Hierarchical software landscape visualization for system comprehension: a controlled experiment. In:
Proceedings of the 3rd IEEE Working Conference on Software Visualization (VISSOFT 2015)
. IEEE, Sept. 2015
This work describes a controlled experiment where we compare our landscape-level perspective with a landscape visualization derived from current APM tools. As demo landscape, we modeled the technical IT infrastructure of the Kiel University.
[Fittkau et al. 2012a] F. Fittkau, S. Frey, and W. Hasselbring. CDOSim: simulating cloud deployment options for software migration support. In:
Proceedings of the 6th IEEE International Workshop on the Maintenance and Evolution of Service-Oriented and Cloud-Based Systems (MESOCA 2012)
. IEEE, Sept. 2012
We developed a simulator to rate one Cloud Deployment Option (CDO) named CDOSim. After simulating one CDO, the simulator provides an overall rating of the option which is constructed from three metrics, i.e., response times, costs, and Service Level Agreement (SLA) violations.
[Fittkau et al. 2012b] F. Fittkau, S. Frey, and W. Hasselbring. Cloud user-centric enhancements of the simulator CloudSim to improve cloud deployment option analysis. In:
Proceedings of the 1st European Conference on Service-Oriented and Cloud Computing (ESOCC 2012)
. Springer, Sept. 2012
As basis for CDOSim, the cloud simulator CloudSim was used. Since CloudSim assumes that the user intends to simulate how her infrastructure performs as a cloud platform, we had to integrate the user-centric perspective of a cloud environment user. These enhancements are detailed in this work.
[Frey et al. 2013] S. Frey, F. Fittkau, and W. Hasselbring. Search-based genetic optimization for deployment and reconfiguration of software in the cloud. In:
Proceedings of the 35th International Conference on Software Engineering (ICSE 2013)
. IEEE, May 2013
CDOSim rates one CDO. However, a software engineer conducting a migration to a cloud environment intends to find the most suitable deployment for her context. Therefore, the tool CDOXplorer generates CDOs and rates them by calling CDOSim. Since often a huge amount of options exists, CDOXplorer uses genetic algorithms to generate promising CDOs.
[Waller et al. 2013] J. Waller, C. Wulf, F. Fittkau, P. Döhring, and W. Hasselbring. SynchroVis: 3D visualization of monitoring traces in the city metaphor for analyzing concurrency. In:
Proceedings of the 1st IEEE International Working Conference on Software Visualization (VISSOFT 2013)
. IEEE, Sept. 2013
SynchroVis uses the 3D city metaphor to display concurrency of one application. It requires to do a static analysis before the program traces can be loaded. Concurrency, e.g., acquiring and releasing a lock object, is displayed through a special lock building. The different threads are visualized through different colors.
S. Frey, F. Fittkau, and W. Hasselbring. CDOXplorer: Simulation-Based Genetic Optimization of Software Deployment and Reconfiguration in the Cloud. IEEE TSE, (submitted), (2014).
This submitted article is an extended version of [Frey et al. 2013] and provides details of the structure, functioning, and quality characteristics of CDOXplorer.
[Brauer et al. 2014] P. C. Brauer, F. Fittkau, and W. Hasselbring. The aspect-oriented architecture of the CAPS framework for capturing, analyzing and archiving provenance data. In:
Proceedings of the 5th International Provenance and Annotation Workshop (IPAW 2014)
. Springer, June
CAPS aims to simplify the instrumentation process of the monitored applications. For instrumentation, an application needs to be uploaded on a web interface and CAPS integrates the required probes to capture provenance data during the execution of the monitored applications.
[Frey et al. 2015] S. Frey, F. Fittkau, and W. Hasselbring. Optimizing the deployment of software in the cloud. In:
Proceedings of the Conference on Software Engineering & Management 2015
. Köllen Druck+Verlag, Mar. 2015
This is an abstract summarizing the results of [Frey et al. 2013].
[Zirkelbach et al. 2015] C. Zirkelbach, W. Hasselbring, F. Fittkau, and L. Carr. Performance analysis of legacy Perl software via batch and interactive trace visualization. Technical report 1509. Department of Computer Science, Kiel University, Germany, Aug. 2015
This work includes the presentation of a monitoring component for Perl-based systems using Kieker12 [van Hoorn et al. 2012]. Furthermore, a performance analysis using different visualizations is conducted for EPrints.
[Beye 2013] J. Beye. Technology evaluation for the communication between the monitoring and analysis component in Kieker. Bachelor’s thesis. Kiel University, Sept. 2013
In his bachelor’s thesis, Beye evaluated three communication technologies with respect to their performance in the context of transferring monitoring data. The evaluation resulted in identifying TCP as the fastest transportation technology for monitoring data. Therefore, we implemented our communication between monitoring and analysis component with a TCP connection.
[Koppenhagen 2013] E. Koppenhagen. Evaluation von Elastizitätsstrategien in der Cloud im Hinblick auf optimale Ressourcennutzung. (in German). Bachelor’s thesis. Kiel University, Sept. 2013
Koppenhagen investigated several cloud scaling approaches. For his evaluation, he implemented the three most promising scaling approaches and evaluated them with regard to performance and cost efficiency by means of a cloud simulator. These approaches can further enhance our elastic trace processing approach but the implementation remains as future work.
[Kosche 2013] M. Kosche. Tracking user actions for the web-based front end of ExplorViz. Bachelor’s thesis. Kiel University, Sept. 2013
The bachelor’s thesis of Kosche evaluated several concepts of user action tracking for our web-based visualization aiming to record user actions during an experiment run. Since the aspect-oriented frameworks were not compatible with current Google Web Toolkit (GWT) versions, she integrated a manual approach. The recorded data of the experiment runs is part of each experimental package of our controlled experiments.
[Matthiessen 2014] N. Matthiessen. Monitoring remote procedure calls – concepts and evaluation. Bachelor’s thesis. Kiel University, Mar. 2014
Matthiessen developed a general Remote Procedure Call (RPC) monitoring approach in cooperation with the master’s project at that time. This backpacking approach is still used in the current monitoring component. As proof-of-concept, he implemented and evaluated the concept for monitoring HTTP Servlet connections.
[Stelzer 2014] P. Stelzer. Scalable and live trace processing in the cloud. Bachelor’s thesis. Kiel University, Mar. 2014
In his bachelor’s thesis, Stelzer conducted a preliminary version of our elasticity evaluation for the live processing of monitoring data using cloud computing and thus tested our approach with multiple static worker levels in his study. In his experiment, there were up to nine monitored JPetStore instances.
[Weißenfels 2014] B. Weißenfels. Evaluation of trace reduction techniques for online trace visualization. Master’s thesis. Kiel University, May 2014
Weißenfels investigated several trace reduction techniques for their efficiency and effectiveness. The best trace reduction technique was trace summarization which is therefore also used by our analysis component.
[Barbie 2014] A. Barbie. Stable 3D city layout in ExplorViz. Bachelor’s thesis. Kiel University, Sept. 2014
The bachelor’s thesis of Barbie investigated a different layout algorithm for the 3D city metaphor and thus our application-level perspective. Targeting a stable and compact layout, he developed a layout algorithm using quad trees [Finkel and Bentley 1974]. His evaluations show that under certain circumstances the layout is stable. However, it uses a large amount of calculation time when the 3D city model grows and is not compact in most scenarios.
[Barzel 2014] M. Barzel. Evaluation von Clustering-Verfahren von Klassen für hierarchische Visualisierung in ExplorViz. (in German). Bachelor’s thesis. Kiel University, Sept. 2014
When no or inappropriate organizational units for classes are used by the monitored software, e.g., all classes are contained in one Java package, our interactive approach would not work as intended. Therefore, Barzel integrated a hierarchical clustering feature into ExplorViz basing on the relations between the classes and their names.
[Finke 2014] S. Finke. Automatische Anleitung einer Versuchsperson während eines kontrollierten Experiments in ExplorViz. (in German). Master’s thesis. Kiel University, Sept. 2014
Finke implemented the automatic tutorial mode into ExplorViz. Furthermore, she developed a configurable experimentation mode which shows generic linked question dialogs. Both modes were successfully used in our controlled experiments.
[Gill 2015] J. Gill. Integration von Kapazitätsmanagement in ein Kontrollzentrum für Softwarelandschaften. (in German). Bachelor’s thesis. Kiel University, Mar. 2015
In the context of the bachelor’s project “Control Center Integration”, Gill integrated the capacity management phase into ExplorViz. As foundation, we provided our capacity manager CapMan which is also used for scaling our trace analysis nodes in the cloud. Furthermore, he implemented the migration of applications from one node to a target node.
[Mannstedt 2015] K. C. Mannstedt. Integration von Anomalienerkennung in einem Kontrollzentrum für Softwarelandschaften. (in German). Bachelor’s thesis. Kiel University, Mar. 2015
Mannstedt integrated the anomaly detection phase into ExplorViz in the context of the bachelor’s project “Control Center Integration”. As basis for the anomaly detection, he used OPAD developed by Bielefeld . As evaluation, he compared different anomaly detection algorithms.
[Michaelis 2015] J. Michaelis. Integration von Ursachenerkennung in ein Kontrollzentrum für Softwarelandschaften. (in German). Bachelor’s thesis. Kiel University, Mar. 2015
Also in the context of the bachelor’s project “Control Center Integration”, Michaelis integrated the root cause detection phase into ExplorViz. He implemented four algorithms for root cause detection and evaluated them by a comparison.
[Zirkelbach 2015] C. Zirkelbach. Performance monitoring of database operations. Master’s thesis. Kiel University, July 2015
In his master’s thesis, Zirkelbach developed an AspectJ13 aspect for monitoring Java Database Connectivity (JDBC) calls and visualizes these information in a tool named Kieker Trace Diagnosis.14 The gathered information include the execution time of the query, its return values, and the Structured Query Language (SQL) statement. Furthermore, he can process prepared statements and relate each execution of the it to the actual SQL statement. Utilizing the developed AspectJ aspect, we are able to provide database monitoring of JDBC calls.
[Krause 2015] A. Krause. Erkundung von Softwarestädten mithilfe der virtuellen Realität. (in German, in progress). Bachelor’s thesis. Kiel University, Sept. 2015
Krause presents the implementation of our approach to utilize VR for exploring software visualizations which follow the city metaphor. The approach uses an Oculus Rift DK1 for virtually displaying the city model and utilizes a Microsoft Kinect v2 for gesture recognition. In this thesis, Krause implemented the gesture recognition as a C# program and developed the gestures in joint work with us. In his evaluation, he conducted eleven structured interviews to investigate the usability of the VR approach. In general, the participants liked the approach and see potential for using VR in program comprehension tasks.
[Simolka 2015] T. Simolka. Live architecture conformance checking in ExplorViz. (in German, in progress). Bachelor’s thesis. Kiel University, Sept. 2015
In the context of his bachelor’s thesis, Simolka implemented our live conformance checking approach presented in [Fittkau et al. 2014a]. The target architecture is modeled in a separate perspective and than the generated landscape model is checked against this target model. If differences between the two models are found, these are visualized by a color-coding.
This thesis consists of the following five parts:
describes the foundations for this thesis.
details the concepts behind application monitoring required for the thesis.
introduces the field of software visualization and the underlying concepts and existing visualizations with a focus on related topics to our thesis.
presents our approach for providing a live trace visualization of large software landscapes.
defines the research questions and our research methods.
describes our method, named ExplorViz, for enabling live trace visualization of large software landscapes.
details how we monitor applications and RPCs. Furthermore, our analysis and trace processing approach is presented.
provides a description of our software landscape metamodel and how we generate a landscape model from the analyzed traces.
introduces our live trace visualization approach and the developed two perspectives, i.e., the landscape-level perspective and the application-level perspective.
shows the conducted evaluations for our approach.
describes the implementation of our approach.
provides three evaluations related to our monitoring and analysis approach.
presents four controlled experiments for evaluating the developed visualization approach.
contains an evaluation where we evaluated the internal quality of our implementation by letting external developers extend the implementation by a prescribed control center concept.
discusses related work.
concludes the thesis.
summarizes the thesis and its results.
presents future work.
contains the appendix.
Chapter A presents the debriefing questionnaire used in the extensibility evaluation.
Finally, the back matter contains a list of figures, a list of tables, a list of listings, a list of used acronyms, and the bibliography.
Tysiące ebooków i audiobooków
Ich liczba ciągle rośnie, a Ty masz gwarancję niezmiennej ceny.
Napisali o nas:
Nowy sposób na e-księgarnię
Czytelnicy nie wierzą
Legimi idzie na całość
Projekt Legimi wielkim wydarzeniem
Spotify for ebooks