Tracing is a fundamental technique for analyzing the runtime behavior of software systems. By recording the start and end times of method executions together with contextual metadata, tracing enables detailed performance analysis, architecture reconstruction, and program comprehension. However, such instrumentation inevitably introduces runtime overhead that can distort performance measurements and increase variability. Quantifying and comparing this overhead across tracing frameworks and configurations is therefore essential for selecting suitable tools and ensuring reliable performance evaluations. The overhead of different tracing frameworks and their configuration can be measured by the MooBench microbenchmark. In this work, we extend the MooBench microbenchmark to support the established Java tracing frameworks Elastic APM Agent, inspectIT, Kieker, OpenTelemetry, Pinpoint, Scouter, and SkyWalking. By executing MooBench with these agents, we find (1) significant differences in performance overhead, whereby the industry standard implementation of OpenTelemetry is comparably slow, while the Kieker agent has the lowest overhead among the functionally correct frameworks, (2) the agents of Pinpoint and Scouter do not store all records, making their behavior not fulfill the functional requirements, and (3) that avoidable overhead of some of the frameworks is created by extensive metadata gathering and needless copying of data.

Software visualization tools assist developers in understanding programs by presenting static, dynamic, and evolutionary aspects of software. In this poster manuscript, we present our ongoing work on enabling snapshot-based visualizations of runtime behavior for debugging. Developers can manually create snapshots at breakpoints during a debugging session to precisely visualize execution traces within custom-defined intervals. This fine-grained approach is intended to reduce cognitive load and support program comprehension.

Software visualization tools can facilitate program comprehension by providing visual metaphors, or abstractions that reduce the amount of textual data that needs to be processed mentally. One way they do this is by enabling developers to build an internal representation of the visualized software and its architecture. However, as the amount of displayed data in the visualization increases, the visualization itself can become more difficult to comprehend. The ability to display small and large amounts of data in visualizations is called visual scalability.In this paper, we present two approaches to address the challenge of visual scalability in 3D software cities. First, we present an approach to semantic zoom, in which the graphical representation of the software landscape changes based on the virtual camera’s distance from visual objects. Second, we augment the visualization with a miniature two-dimensional top-view projection called mini-map. We demonstrate our approach using an open-source implementation in our software visualization tool ExplorViz. ExplorViz is web-based and uses the 3D city metaphor, focusing on live trace visualization.We evaluated our approaches in two separate user studies. The results indicate that semantic zoom and the mini-map are both useful additions. User feedback indicates that semantic zoom and mini-maps are especially useful for large software landscapes and collaborative software exploration. The studies indicate a good usability of our implemented approaches. However, some shortcomings in our implementations have also been discovered, to be addressed in future work.Video URL: https://youtu.be/LYtUeWvizjU

The Linux kernel is one of the largest and longest-maintained open-source projects in existence. With tens of thousands of source code files, understanding the program’s internal structure and behavior is a great challenge. In this paper, we present an approach to visualize the Linux kernel using our software visualization tool ExplorViz. We analyze commits from the Linux Git repository using srcML and our custom backend service for static analysis. We visualize the folder structure and included source code files using the city metaphor. Users can visually compare the structure of different commits to gain insight into the kernel’s software evolution.In addition to the visualization of the structure of the Linux kernel, ExplorViz processes traces that provide runtime information about the kernel’s behavior. Therefore, we employ the function tracer ftrace and convert the gathered traces to the OpenTelemetry format. The accumulated traces are displayed as arcs between communicating files.When combined with the numerous configuration options of ExplorViz for customizing its visualization, our approach offers new and versatile perspectives on the Linux kernel.Video URL: https://youtu.be/cBouE5eQOjE

Software visualization, which uses data from dynamic program analysis, can help to explore and understand the behavior of software systems. It is common that large software systems offer a web interface for user interaction. Usually, available web interfaces are not regarded in software visualization tools. This paper introduces additions to the web-based live tracing software visualization tool ExplorViz: We add an embedded web view for instrumented applications in the 3D visualization to ease interaction with the given applications and enable the exploration of the thereby displayed HTML content. Namely, the Document Object Model (DOM) is visualized via a three-dimensional representation of the HTML structure in same-origin contexts.Our visualization approach is evaluated in a preliminary user study. The study results give insights into the potential use cases, benefits, and shortcomings of our implemented approach. Based on our study results, we propose directions for further research to support the visual exploration of web interfaces and explore use cases for the combined visualization of software cities and HTML structure.Video URL: https://youtu.be/wBWKlbvzOOE

As software systems grow, environments that not only facilitate program comprehension through software visualization but also enable collaborative exploration of software systems become increasingly important. Most approaches to software visualization focus on a single monitor as a visual output device, which offers limited immersion and lacks in potential for collaboration. More recent approaches address augmented and virtual reality environments to increase immersion and enable collaboration to facilitate program comprehension. We present a novel approach to software visualization with software cities that fills a gap between existing approaches by using multiple displays or projectors. Thereby, an increase in screen real estate and new use case scenarios for co-located environments are enabled. Our web-based live trace visualization tool ExplorViz is extended with a service to synchronize the visualization across multiple browser instances. Multiple browser instances can then extend or complement each other's views with respect to a given configuration. The ARENA2, a spatially immersive visualization environment with five projectors, is used to showcase our approach. A preliminary study indicates that this environment can be useful for collaborative exploration of software cities. This publication is accompanied by a video. In addition, our implementation is open source and we invite other researchers to explore and adapt it for their use cases. Video URL: https://youtu.be/OiutBn3zIl8

Software visualization approaches for code reviews are often implemented as standalone applications, which use static code analysis. The goal is to visualize the structural changes introduced by a pull / merge request to facilitate the review process. In this way, for example, structural changes that hinder code evolution can be more easily identified, but understanding the changed program behavior is still mainly done by reading the code. For software visualization to be successful in code review, tools must be provided that go beyond an alternative representation of code changes and integrate well into the developers' daily workflow. In this paper, we report on the novel and in-progress design and implementation of a web-based approach capable of combining static and dynamic analysis data in software city visualizations. Our architectural tool design incorporates modern web technologies such as the integration into common Git hosting services. As a result, code reviewers can explore how the modified software evolves and execute its use cases, which is especially helpful for distributed software systems. In this context, developers can be directly linked from the Git hosting service's issue tracking system to the corresponding software city visualization. This approach eliminates the recurring action of manual data collection and setup. We implement our design by extending the web-based software visualization tool ExplorViz. We invite other researchers to extend our open source software and jointly research this approach. Video URL: https://youtu.be/DYxijdCEdrY

Developers usually use diagrams and source code to jointly discuss and plan software architecture changes. With this poster, we present our on-going work on a novel approach that enables developers to collaboratively use software city visualization to design and plan software architecture changes.

The combination of distributed stream processing with microservice architectures is an emerging pattern for building data-intensive software systems. In such systems, stream processing frameworks such as Apache Flink, Apache Kafka Streams, Apache Samza, Hazelcast Jet, or the Apache Beam SDK are used inside microservices to continuously process massive amounts of data in a distributed fashion. While all of these frameworks promote scalability as a core feature, there is only little empirical research evaluating and comparing their scalability. The goal of this study to obtain evidence about the scalability of state-of-the-art stream processing framework in different execution environments and regarding different scalability dimensions. We benchmark five modern stream processing frameworks regarding their scalability using a systematic method. We conduct over 740 h of experiments on Kubernetes clusters in the Google cloud and in a private cloud, where we deploy up to 110 simultaneously running microservice instances, which process up to one million messages per second. All benchmarked frameworks exhibit approximately linear scalability as long as sufficient cloud resources are provisioned. However, the frameworks show considerable differences in the rate at which resources have to be added to cope with increasing load. There is no clear superior framework, but the ranking of the frameworks depends on the use case. Using Apache Beam as an abstraction layer still comes at the cost of significantly higher resource requirements regardless of the use case. We observe our results regardless of scaling load on a microservice, scaling the computational work performed inside the microservice, and the selected cloud environment. Moreover, vertical scaling can be a complementary measure to achieve scalability of stream processing frameworks. While scalable microservices can be designed with all evaluated frameworks, the choice of a framework and its deployment has a considerable impact on the cost of operating it.

Software visualizations are usually realized as standalone and isolated tools that use embedded code viewers within the visualization. In the context of program comprehension, only few approaches integrate visualizations into code editors, such as integrated development environments. This is surprising since professional developers consider reading source code as one of the most important ways to understand software, therefore spend a lot of time with code editors. In this paper, we introduce the design and proof-of-concept implementation for a software visualization approach that can be embedded into code editors. Our contribution differs from related work in that we use dynamic analysis of a software system's runtime behavior. Additionally, we incorporate distributed tracing. This enables developers to understand how, for example, the currently handled source code behaves as a fully deployed, distributed software system. Our visualization approach enhances common remote pair programming tools and is collaboratively usable by employing shared code cities. As a result, user interactions are synchronized between code editor and visualization, as well as broadcasted to collaborators. To the best of our knowledge, this is the first approach that combines code editors with collaboratively usable code cities. Therefore, we conducted a user study to collect first-time feedback regarding the perceived usefulness and perceived usability of our approach. We additionally collected logging information to provide more data regarding time spent in code cities that are embedded in code editors. Seven teams with two students each participated in that study. The results show that the majority of participants find our approach useful and would employ it for their own use. We provide each participant's video recording, raw results, and all steps to reproduce our experiment as supplementary package. Furthermore, a live demo of our tool is available online.11https.//code.explorviz.dev We invite other researchers to extend our open-source software.22https://github.com/ExplorViz Video URL: https://youtu.be/3qZVSehnEug

Theodolite is a framework for benchmarking the scalability of cloud-native applications. It automates deployment and monitoring of a cloud-native application for different load intensities and provisioned cloud resources and assesses whether specified service level objectives (SLOs) are fulfilled. Provided as a Kubernetes Operator, Theodolite allows defining, sharing, and archiving benchmarks and experiment configurations in declarative files. We demonstrate Theodolite's benchmarking method and show how researchers and cloud engineers can execute existing scalability benchmarks or define new ones with Theodolite.

Software visualizations are used by software developers, for instance, for program comprehension. In this context, a less researched aspect is the collaborative use of online visual-ization services. This paper presents the conceptual design and a prototype implementation of our approach for a collaborative software visualization service for program comprehension. The central idea is an online available software-as-a-service application that analyzes, persists, and visualizes software applications which users intend to explore and comprehend via software visualization. The resulting implementation is a redevelopment of our live trace visualization tool Explor Viz. In comparison to other approaches, ExplorViz utilizes WebGL and other browser technologies instead of a game engine to render its visualizations. As a result, we achieve a platform-independent interoperability that is crucial for (remote) collaboration. Here, users can explore the same visualization via our collaboratively usable desktop, virtual reality, and also augmented reality modes. Our prototype follows the Twelve-Factor App methodology to build a cloud-native application that comprises multiple scalable microservices. Thanks to horizontal scaling, our implementation is capable to analyze a large amount of visualization data; thus, allowing multiple users to simultaneously use the software visualization service. We conducted a set of preliminary performance exper-iments to benchmark our prototype's scalability. Results show that the evaluated service scales linearly with increasing load.

In cloud event processing, data generated at the edge is processed in real-time by cloud resources. Both distributed stream processing (DSP) and Function-as-a-Service (FaaS) have been proposed to implement such event processing applications. FaaS emphasizes fast development and easy operation, while DSP emphasizes efficient handling of large data volumes. Despite their architectural differences, both can be used to model and implement loosely-coupled job graphs. In this paper, we consider the selection of FaaS and DSP from a cost perspective. We implement stateless and stateful workflows from the Theodolite benchmarking suite using cloud FaaS and DSP. In an extensive evaluation, we show how application type, cloud service provider, and runtime environment can influence the cost of application deployments and derive decision guidelines for cloud engineers.

To develop software with optimal performance, even small performance changes need to be identified. Identifying performance changes is challenging since the performance of software is influenced by non-deterministic factors. Therefore, not every performance change is measurable with reasonable effort. In this work, we discuss which performance changes are measurable at code level with reasonable measurement effort and how to identify them. We present (1) an analysis of the boundaries of measuring performance changes, (2) an approach for determining a configuration for reproducible performance change identification, and (3) an evaluation comparing of how well our approach is able to identify performance changes in the application server Jetty compared with the usage of Jetty’s own performance regression benchmarks.Thereby, we find (1) that small performance differences are only measurable by fine-grained measurement workloads, (2) that performance changes caused by the change of one operation can be identified using a unit-test-sized workload definition and a suitable configuration, and (3) that using our approach identifies small performance regressions more efficiently than using Jetty’s performance regression benchmarks.

In the context of program comprehension, learning and working in teams, e.g., via pair programming, shared documentation, and discussions, can facilitate the comprehension tasks. So far, team collaboration is a relatively unexplored aspect in software visualizations, in particular approaches which are designed and explored to enable collaborative program comprehension.In this paper, we introduce our collaboratively usable software visualization environment for program comprehension. Related approaches are often limited to single-user modes, therefore neglect the advantages of multi-user collaboration, or allow only the use of a single type of device. Our approach addresses this topic and allows users to collaboratively explore software visualizations in a device-heterogeneous environment. User events, e.g., sharable pop-up information windows, are synchronized between each session participant, regardless of the employed device.To the best of our knowledge, this is one of the first approaches that combines on-screen, virtual reality, and augmented reality modes in a single web-based SV tool for program comprehension. We conducted a user study to collect initial results regarding the perceived usefulness and enjoyment of co-explored software cities In that study, 20 participants collaboratively solved program comprehension tasks while using each mode consecutively. The results indicate that the majority of participants find our approach useful and enjoyable, with AR being the least favored mode. We provide each participant’s video recording, the study’s raw results, Jupyter Notebooks, and all steps to reproduce our evaluation as supplementary package. Furthermore, a live demo of our tool is available online.1We invite other researchers to extend our open-source software and jointly research this novel approach.Video URL: https://youtu.be/MYAkRMWLVD8

Abstract Cloud-native applications constitute a recent trend for designing large-scale software systems. However, even though several cloud-native tools and patterns have emerged to support scalability, there is no commonly accepted method to empirically benchmark their scalability. In this study, we present a benchmarking method, allowing researchers and practitioners to conduct empirical scalability evaluations of cloud-native applications, frameworks, and deployment options. Our benchmarking method consists of scalability metrics, measurement methods, and an architecture for a scalability benchmarking tool, particularly suited for cloud-native applications. Following fundamental scalability definitions and established benchmarking best practices, we propose to quantify scalability by performing isolated experiments for different load and resource combinations, which asses whether specified service level objectives (SLOs) are achieved. To balance usability and reproducibility, our benchmarking method provides configuration options, controlling the trade-off between overall execution time and statistical grounding. We perform an extensive experimental evaluation of our method’s configuration options for the special case of event-driven microservices. For this purpose, we use benchmark implementations of the two stream processing frameworks Kafka Streams and Flink and run our experiments in two public clouds and one private cloud. We find that, independent of the cloud platform, it only takes a few repetitions (≤ 5) and short execution times (≤ 5 minutes) to assess whether SLOs are achieved. Combined with our findings from evaluating different search strategies, we conclude that our method allows to benchmark scalability in reasonable time.

In software visualization research, various approaches strive to create immersive environments by employing extended reality devices. In that context, only few research has been conducted on the effect of collaborative, i.e., multi-user, extended reality environments. We present our journey toward a web-based approach to enable (location-independent) collaborative program comprehension using desktop, virtual reality, and mobile augmented reality devices. We designed and implemented three multi-user modes in our web-based live trace visualization tool ExplorViz. Users can employ desktop, mobile, and virtual reality devices to collaboratively explore software visualizations. We conducted two preliminary user studies in which subjects evaluated our VR and AR modes after solving common program comprehension tasks. The VR and AR environments can be suitable for collaborative work in the context of program comprehension. The analyzed feedback revealed problems regarding the usability, e.g., readability of visualized entities and performance issues. Nonetheless, our approach can be seen as a blueprint for other researchers to replicate or build upon these modes and results. ExplorViz’s multi-user modes are our approach to enable heterogeneous collaborative software visualizations. The preliminary results indicate the need for more research regarding effectiveness, usability, and acceptance. Unlike related work, we approach the latter by introducing a multi-user augmented reality environment for software visualizations based on off-the-shelf mobile devices.

In empirical software engineering, benchmarks can be used for comparing different methods, techniques and tools. However, the recent ACM SIGSOFT Empirical Standards for Software Engineering Research do not include an explicit checklist for benchmarking. In this paper, we discuss benchmarks for software performance and scalability evaluation as example research areas in software engineering, relate benchmarks to some other empirical research methods, and discuss the requirements on benchmarks that may constitute the basis for a checklist of a benchmarking standard for empirical software engineering research.

The ability to independently deploy parts of a software system is one of the cornerstones of modern software development, and allows for these parts to evolve independently and at different speeds.A major challenge of such independent deployment, however, is to ensure that despite their individual evolution, the interfaces between interacting parts remain compatible. This is especially important for enterprise software systems, which are often highly integrated and based on heterogenous IT infrastructures.Although several approaches for interface evolution have been proposed, many of these rely on the developer to adhere to certain rules, but provide little guidance for doing so. In this paper, we present an approach for interface evolution that is easy to use for developers, and also addresses typical challenges of heterogenous enterprise software, especially legacy system integration.

The 3D city metaphor in software visualization is a well-explored rendering method. Numerous tools use their custom variation to visualize offline-analyzed data. Heat map overlays are one of these variants. They introduce a separate information layer in addition to the software city’s own semantics. Results show that their usage facilitates program comprehension.In this paper, we present our heat map approach for the city metaphor visualization based on live trace analysis. In comparison to previous approaches, our implementation uses live dynamic analysis of a software system’s runtime behavior. At any time, users can toggle the heat map feature and choose which runtime-dependent metric the heat map should visualize. Our approach continuously and automatically renders both software cities and heat maps. It does not require a manual or semiautomatic generation of heat maps and seamlessly blends into the overall software visualization. We implemented this approach in our web-based tool ExplorViz, such that the heat map overlay is also available in our augmented reality environment. ExplorViz is developed as open source software and is continuously published via Docker images. A live demo of ExplorViz is publicly available.

Ever-increasing amounts of data and requirements to process them in real time lead to more and more analytics platforms and software systems being designed according to the concept of stream processing. A common area of application is the processing of continuous data streams from sensors, for example, IoT devices or performance monitoring tools. In addition to analyzing pure sensor data, analyses of data for groups of sensors often need to be performed as well. Therefore, data streams of the individual sensors have to be continuously aggregated to a data stream for a group. Motivated by a real-world application scenario, we propose that such a stream aggregation approach has to allow for aggregating sensors in hierarchical groups, support multiple such hierarchies in parallel, provide reconfiguration at runtime, and preserve the scalability and reliability qualities induced by applying stream processing techniques. We propose a stream processing architecture fulfilling these requirements, which can be integrated into existing big data architectures. We present a pilot implementation of such an extended architecture and show how it is used in industry. Furthermore, in experimental evaluations we show that our solution scales linearly with the amount of sensors and provides adequate reliability in the case of faults.

Supervised learning classification models use labeled data to train models on a discrete form for generating predictions. A major challenge addressed in this paper is training a machine learning model to the recognition of a pattern data perspective of the original datasets and privacy-preserving datasets to improve predictive models. The model training process, the training datasets, and validation datasets are mixed with data and privacy-preserving data cause overfitting from high variance in the machine learning algorithm. This paper addresses a k-Nearest Neighbor algorithm to build models, apply an automated hyperparameter tuning method to determine the optimal parameters based on the characteristics before the training process of a large volume datasets. Evaluating the model to achieve goals based on a high score of accuracy results on quality prediction and performance models. The experiments from our real datasets and the UCI machine learning repository show the best method for all of the training data and conduct difference experiments for improving accuracy, feasibility, correctness and reliability of the scheme.

We present PeASS (Performance Analysis of Software System versions), a tool for detecting performance changes at source code level that occur between different code versions. By using PeASS, it is possible to identify performance regressions that happened in the past to fix them. PeASS measures the performance of unit tests in different source code versions. To achieve statistic rigor, measurements are repeated and analyzed using an agnostic t-test. To execute a minimal amount of tests, PeASS uses a regression test selection. We evaluate PeASS on a selection of Apache Commons projects and show that 81% of all unit test covered performance changes can be found by PeASS. A video presentation is available at https://www.youtube.com/watch?v=RORFEGSCh6Y and PeASS can be downloaded from https://github.com/DaGeRe/peass.

The specification of workloads is required in order to evaluate performance characteristics of application systems using load testing and model-based performance prediction. Defining workload specifications that represent the real workload as accurately as possible is one of the biggest challenges in both areas. To overcome this challenge, this paper presents an approach that aims to automate the extraction and transformation of workload specifications for load testing and model-based performance prediction of session-based application systems. The approach (WESSBAS) comprises three main components. First, a system- and tool-agnostic domain-specific language (DSL) allows the layered modeling of workload specifications of session-based systems. Second, instances of this DSL are automatically extracted from recorded session logs of production systems. Third, these instances are transformed into executable workload specifications of load generation tools and model-based performance evaluation tools. We present transformations to the common load testing tool Apache JMeter and to the Palladio Component Model. Our approach is evaluated using the industry-standard benchmark SPECjEnterprise2010 and the World Cup 1998 access logs. Workload-specific characteristics (e.g., session lengths and arrival rates) and performance characteristics (e.g., response times and CPU utilizations) show that the extracted workloads match the measured workloads with high accuracy.

Context: The number of software applications deployed in organizations is constantly increasing. Those applications – often several hundreds – form large software landscapes. Objective: The comprehension of such landscapes and their applications is often impeded by, for instance, architectural erosion, personnel turnover, or changing requirements. Therefore, an efficient and effective way to comprehend such software landscapes is required. Method: In our ExplorViz visualization, we introduce hierarchical abstractions aiming at solving system comprehension tasks fast and accurately for large software landscapes. Besides hierarchical visualization on the landscape level, ExplorViz provides multi-level visualization from the landscape to the level of individual applications. The 3D application-level visualization is empirically evaluated with a comparison to the Extravis approach, with physical models and in virtual reality. To evaluate ExplorViz, we conducted four controlled experiments. We provide packages containing all our experimental data to facilitate the verifiability, reproducibility, and further extensibility of our results. Results: We observed a statistical significant increase in task correctness of the hierarchical visualization compared to the flat visualization. The time spent did not show any significant differences. For the comparison with Extravis, we observed that solving program comprehension tasks using ExplorViz leads to a significant increase in correctness and in less or similar time spent. The physical models improved the team-based program comprehension process for specific tasks by initiating gesture-based interaction, but not for all tasks. The participants of our virtual reality experiment with ExplorViz rated the realized gestures for translation, rotation, and selection as highly usable. However, our zooming gesture was less favored. Conclusion: The results backup our claim that our hierarchical and multi-level approach enhances the current state of the art in landscape and application visualization for better software system comprehension, including new forms of interaction with physical models and virtual reality.

Microservice architectures provide small services that may be deployed and scaled independently of each other, and may employ different middleware stacks for their implementation. Microservice architectures emphasize transaction-less coordination between services, with explicit acceptance of eventual consistency. Polyglott persistence in this context means that the individual microservices may employ multiple data storage technologies. Microservice architectures are "cloud native" allowing for automated and rapid elasticity. Fault-tolerance mechanisms achieve that failures of individual mircroservices do not affect other services thanks to container isolation. Since services can fail at any time, it is important to be able to detect the failures quickly and, if possible, automatically restore services. Essential for success in such a setting is advanced monitoring. In this keynote, I discuss how mircoservices support scalability for both, runtime performance and development performance, via polyglott persistence, eventual consistency, loose coupling, open source frameworks, and continuous monitoring for elastic capacity management.

For efficient and effective program comprehension, it is essential to provide software engineers with appropriate visualizations of the program's execution traces. Empirical studies, such as controlled experiments, are required to assess the effectiveness and efficiency of proposed visualization techniques. We present controlled experiments to compare the trace visualization tools Extravis and Explor Viz in typical program comprehension tasks. We replicate the first controlled experiment with a second one targeting a differently sized software system. In addition to a thorough analysis of the strategies chosen by the participants, we report on common challenges comparing trace visualization techniques. Besides our own replication of the first experiment, we provide a package containing all our experimental data to facilitate the verifiability, reproducibility and further extensibility of our presented results. Although subjects spent similar time on program comprehension tasks with both tools for a small-sized system, analyzing a larger software system resulted in a significant efficiency advantage of 28 percent less time spent by using Explor Viz. Concerning the effectiveness (correct solutions for program comprehension tasks), we observed a significant improvement of correctness for both object system sizes of 39 and 61 percent with Explor Viz.

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. Therefore, an efficient and effective way to comprehend such software landscapes is required. The current state of the art often visualizes software landscapes via flat graph-based representations of nodes, applications, and their communication. In our ExplorViz visualization, we introduce hierarchical abstractions aiming at solving typical system comprehension tasks fast and accurately for large software landscapes. To evaluate our hierarchical approach, we conduct a controlled experiment comparing our hierarchical landscape visualization to a flat, state-of-the-art visualization. In addition, we thoroughly analyze the strategies employed by the participants and provide a package containing all our experimental data to facilitate the verifiability, reproducibility, and further extensibility of our results. We observed a statistically significant increase of 14 % in task correctness of the hierarchical visualization group compared to the flat visualization group in our experiment. The time spent on the system comprehension tasks did not show any significant differences. The results backup our claim that our hierarchical concept enhances the current state of the art in landscape visualization.

Building architects, but also civil or mechanical engineers often build from their designs physical 3D models for a better presentation, comprehension, and communication among stakeholders. Software engineers usually create visualizations of their software designs as digital objects to be presented on a screen only. 3D software visualization metaphors, such as the software city metaphor, provide a basis for exporting those on-screen software visualizations into physical models. This can be achieved by 3D-printers to transfer the advantages of real, physical, tangible architecture models from traditional engineering disciplines to software engineering. We present a new research perspective of using physical models to support software engineering. Furthermore, we describe four envisioned usage scenarios for physical models which provide a plethora of new research topics. To examine the benefits of our concept, we investigate the first usage scenario by evaluating the impact of using physical models on program comprehension in teams through a first controlled experiment. Since the usage of physical models had a diverging influence for our chosen task set, we report on the qualitative results in this paper. We observed that the physical models improved the team-based program comprehension process for specific tasks by initiating gesture-based interaction.

Software visualizations, such as the software city metaphor, are usually displayed on 2D screens and controlled by means of a mouse and thus often do not take advantage of more natural interaction techniques. Virtual reality (VR) approaches aim to improve the user experience. Emerging new technologies, like the Oculus Rift, dramatically enhance the VR experience at an affordable price. Therefore, new technologies have the potential to provide even higher immersion - and thus benefits - than previous VR approaches.

Migrating existing enterprise software to cloud platforms involves the comparison of competing cloud deployment options (CDOs). A CDO comprises a combination of a specific cloud environment, deployment architecture, and runtime reconfiguration rules for dynamic resource scaling. Our simulator CDOSim can evaluate CDOs, e.g., regarding response times and costs. However, the design space to be searched for well-suited solutions is extremely huge. In this paper, we approach this optimization problem with the novel genetic algorithm CDOXplorer. It uses techniques of the search-based software engineering field and CDOSim to assess the fitness of CDOs. An experimental evaluation that employs, among others, the cloud environments Amazon EC2 and Microsoft Windows Azure, shows that CDOXplorer can find solutions that surpass those of other state-of-the-art techniques by up to 60%. Our experiment code and data and an implementation of CDOXplorer are available as open source software.

The increasing code complexity in modern enterprise software systems exceeds the capabilities of most software engineers to understand the system's behavior by just looking at its program code. Large software landscapes, e.g., applications in a cloud infrastructure, further increase this complexity. A solution to these problems is visualizing the applications of the software landscape to ease program comprehension and to understand the respective communication. An established visualization concept is the 3D city metaphor. It utilizes the familiarity with navigating a city to improve program comprehension. Dynamic analysis, e.g., monitoring, can provide the required program traces of the communication. In this paper, we present our live visualization approach of monitoring traces for large software landscapes. It combines a landscape and a system level perspective. The landscape level perspective provides an overview of the software landscape utilizing the viewer's familiarity with UML. The system level perspective provides a visualization utilizing the city metaphor for each software system.

The increasing code complexity in modern software systems exceeds the capabilities of most software engineers to understand the system's behavior by just looking at its program code. The addition of concurrency issues through the advent of multi-core processors in the consumer market further escalates this complexity. A solution to these problems is visualizing a model of the system to ease program comprehension. Especially for the comprehension of concurrency issues, static information is often not sufficient. For this purpose, profiling and monitoring can provide additional information on the actual behavior of a system. An established visualization approach is the 3D city metaphor. It utilizes the familiarity with navigating a city to improve program comprehension. In this paper, we present our trace-based SynchroVis 3D visualization approach for concurrency. It employs the city metaphor to visualize both static and dynamic properties of software systems with a focus on illustrating the concurrent behavior. To evaluate our approach, we provide an open source implementation of our concepts and present an exemplary dining philosophers scenario showing its feasibility.

SUMMARY The migration of software systems to IaaS (infrastructure as a service)‐ or PaaS (platform as a service)‐based cloud environments enables SaaS providers to benefit from the cloud's merits, such as smoothly scaling up and down existing applications. Our approach, CloudMIG, aims at supporting SaaS providers to perform those migrations. Here, validating the specific constraints that are imposed by a cloud environment constitutes an important early‐phase activity. For example, the access to the file system, number of files, or calls to specific methods may be restricted by cloud providers. Those constraints have to be considered when evaluating the suitability of competing cloud environment candidates. In this paper, we describe CloudMIG's corresponding parts: a generic cloud environment model that incorporates these constraints and appropriate violation detection mechanisms. A software system's conformance can be examined with the assistance of constraint validators. They operate on extracted Knowledge Discovery Meta‐Model‐based system models and can, among others, apply metrics formulated with the Software Metrics Meta‐Model through our metrics execution engine. Additional constraint validators can be plugged into the validation process as needed. In this context, we implemented a prototype and modeled the PaaS environment Google App Engine for Java. We report on a quantitative evaluation regarding the detected constraint violations of five open‐source systems. Copyright © 2012 John Wiley & Sons, Ltd.

Xtext is an open-source framework for implementing external, textual domain-specific languages (DSLs). So far, most DSLs implemented with Xtext and similar tools focus on structural aspects such as service specifications and entities. Because behavioral aspects are significantly more complicated to implement, they are often delegated to general-purpose programming languages. This approach introduces complex integration patterns and the DSL's high level of abstraction is compromised.

Kieker is an extensible framework for monitoring and analyzing the runtime behavior of concurrent or distributed software systems. It provides measurement probes for application performance monitoring and control-flow tracing. Analysis plugins extract and visualize architectural models, augmented by quantitative observations. Configurable readers and writers allow Kieker to be used for online and offline analysis. This paper reviews the Kieker framework focusing on its features, its provided extension points for custom components, as well the imposed monitoring overhead.

This paper introduces the PeerSE experiment environment (EE) including concepts for a simulation-based analysis and implementation of P2P systems. The PeerSE EE supports a comparative analysis of P2P system models to identify models fulfilling given requirements. In a next step, model components are reused for implementing laboratory and real-world P2P systems. The integrated visualization for simulation and laboratory experiment results helps developers to compare the behavior of simulation models and laboratory systems. Thus, the PeerSE EE allows a controlled transition of model components to laboratory components. The applicability of the PeerSE EE is demonstrated by exemplarily analyzing and implementing a P2P system.

Dependability models of distributed systems are often parameterised by the failure characteristics of the nodes that form a system. For realistic results, these parameters must be estimated accurately, for example, based on evaluations of real-world systems. We empirically evaluate over 400 globally distributed nodes of the PlanetLab research cluster and estimate the popular parameters mean-time-to-failure, mean-time-to-repair, availability, and failure correlation coefficients. We fit the resulting empirical distributions by simple theoretical distributions and find that the mean-time-to-failure, the availability, and the failure correlation coefficient correlate with the geographical distance between nodes.

Exception handling mechanisms were invented in 1970s to support structured programming methods for hierarchically organised software systems. The need to increase reusability and flexibility led to the development of new programming paradigms that do not emphasise hierarchical design. Event-driven systemsnwhich objects communicate using notifications about changed states - are a prime example. Unfortunately, this style of communication makes exception handling more difficult than in hierarchical systems. We contribute an analysis of the factors which influence exception handling in event-driven systems. The main focus of our discussion lies on the challenge of appropriate exception propagation. We provide results from an empirical case study performed on the source code of the Eclipse IDE that support our analysis

In the process of developing P2P systems simulation has proved to be an essential tool for the evaluation of existing and conceived P2P systems. So far, in practice there has been a clear separation between a simulation model of a P2P system and a real P2P system that operates on a real physical network. This separation hinders the transition of models to real systems and the evaluation of already deployed systems by means of simulation. This work tries to bridge this gap by proposing a methodology and a framework for the simulation-based development of P2P systems. In this approach, an initial model of a P2P system is iteratively transformed into the intended real P2P system. The presented framework effectively supports a developer in modelling, simulating and ultimately developing P2P systems. The authors demonstrate the validity of the approach and the framework by constructing an example P2P application. This application is simulated in a series of experiments as well as deployed in a large-scale Internet based P2P system

The MID ARCH method is a software design method for exploring software architecture alternatives that use different middleware platforms. First, candidate architectures are modelled based on different architectural styles that are induced by the respective middleware platforms. Candidate styles are chosen using a taxonomy of such styles. The goal is the evaluation of candidate architectures with respect to a goal/question/metric quality model. We illustrate the modelling approach using the Apache Cocoon Web component framework and related technologies, and a taxonomy of their associated styles.

Our energy production increasingly depends on renewable energy sources, which impose new challenges for distributed and decentralized systems. One problem is that the availability of renewable energy sources such as wind and solar is not continuous as it is affected by meteorological factors. The challenge is to develop forecast methods capable of determining the level of power generation in near real-time in order to control power plants for optimal energy production. Another scenario is the identification of optimal locations for such power plants. In our collaborative project, these tasks are investigated in the domain of energy meteorology. For that purpose large data sources from many different sensors (e.g., satellites and ground stations) are the base for complex computations. The idea is to parallelize these computations in order to obtain significant speedup. This paper reports on an ongoing project employing Grid technologies in that context. Our approach to processing large data sets from a variety of heterogeneous data sources as well as ideas for parallel and distributed computing in energy meteorology are presented. Preliminary experience with several Grid middleware systems in our application scenario is discussed.

Failure models characterise the expected component failures in fault-tolerant computing. In the context of distributed systems, a failure model usually consists of two parts: a functional part specifying in what way individual processing entities may fail and a structural part specifying the potential scope of failures within the system. Such models must be expressive enough to cover all relevant practical situations, but must also be simple enough to allow uncomplicated reasoning about fault-tolerant algorithms. Usually, an increase in expressiveness complicates formal reasoning, but enables more accurate models that allow to improve the assumption coverage and resilience of solutions. In this paper, we introduce the structural failure model class DiDep that allows to specify directed dependent failures, which, for example, occur in the area of intrusion tolerance and security. DiDep is a generalisation of previous classes for undirected dependent failures, namely the general adversary structures, the fail-prone systems, and the core and survivor sets, which we show to be equivalent. We show that the increase in expressiveness of DiDep does not significantly penalise the simplicity of corresponding models by giving an algorithm that transforms any consensus algorithm for undirected dependent failures into a consensus algorithm for a DiDep model. We characterise the improved resilience obtained with DiDep and show that certain models even allow to circumvent the famous FLP impossibility result

While the importance of multi-tier architectures for enterprise information systems is widely accepted and their benefits are well published, the systematic migration from monolithic legacy systems toward multi-tier architectures is known to a much lesser extent. In this paper we present a pattern on how to re-use elements of legacy systems within multi-tier architectures, which also allows for a smooth migration path. We report on experience we made with migrating existing municipal information systems towards a multitier architecture. The experience is generalized by describing the underlying pattern such that it can be re-used for similar architectural migration tasks. The emerged Dublo pattern is based on the partial duplication of business logic among legacy system and newly deployed application server. While this somehow contradicts the separation-of-concerns principle, it offers a high degree of flexibility in the migration process and allows for a smooth transition. Experience with the combination of outdated database technology with modern server-side component and Web services technologies is discussed. In this context, we also report on technology and architecture selection processes.

S. Conrad, W. Hasselbring, A. James, D. Kambur, R.-D. Kutsche, P. Thiran; Report on the EFIS 2001 Workshop, The Computer Journal, Volume 45, Issue 2, 1 January

Abstract Learning to work with enterprise frameworks requires considerable effort, because of the inherent complexity of all the knowledge that is needed. However, different roles in project teams need to learn different knowledge components according to the different tasks to be performed. A role‐based guide that has been developed for new developers in the California projects at the software house International Business Systems, Inc. (IBS) Consist is presented. The California projects develop financial applications based on the IBM SanFrancisco enterprise framework. The requirement for this guide originates in the need to guide (new) project members in learning the required skills for being able to work productively after focused training for the California projects. The starting point for this guide is the IBS development process. The individual tasks during the different phases in the process are specified by means of the Unified Modeling Language (UML) use case diagrams. An important property is that the guide is role‐based to allow new project members to focus on their roles in the project, while learning to work with the framework. For each role, a UML activity diagram guides one to find the right paths for learning the required skills (which we call knowledge components) for the particular project role. The knowledge components are related to the tasks in the development process and to the roles. For all roles, at least some basic knowledge of the UML is required. Therefore, it is reasonable to specify this learning guide by means of the UML. This paper illustrates the use of the UML for specifying such a guide in a specific setting, namely the California projects of IBS Consist. Copyright © 2002 John Wiley & Sons, Ltd.

A main problem for electronic commerce, particularly for business-to-business applications, lies in the need for the involved information systems to meaningfully exchange information. Domain-specific standards may be used to define the semantics of common terms. However, in practice it is not easy to find those domain-specific standards that are detailed and stable enough to allow for real interoperability. Therefore, we propose an architecture that allows for incremental construction of a shared repository including a multilingual thesaurus, which is used in a business communication language. Communicating information systems then refer to the common thesaurus while exchanging messages. Our emphasis is be on separating semantics (in the thesaurus) and syntax (in XML). Therefore, our extensibility is not only that of XML, but also the extensibility of the semantics that is modeled in the shared repository. The business communication language XLBC is presented and how it can be used in electronic commerce applications. XLBC message patterns and conversation protocols are stored in the shared repository as well.

Parallel and distributed programming is conceptually harder to undertake and to understand than sequential programming, because a programmer often has to manage the coexistence and coordination of multiple concurrent activities. The model of 'Generative Communication' in Linda-a paradigm that has been developed for parallel computing-emphasizes the decoupling of cooperating parallel processes; thus, relieving the programmer from the burden of having to consider all process inter-relations explicitly. In many application areas, data is distributed over a multitude of heterogeneous, autonomous information systems. These systems are often isolated and an exchange of data among them is not easy. On the other hand, support for dynamic exchange of data is required to improve the business processes. Cooperative information systems enable such autonomous systems to interoperate. They are complex systems of systems which require a well designed and flexible software architecture. The Linda model had a great influence on research in parallel programming languages. Stimulated by this success, a Generative Communication Service, which offers a very flexible associative addressing mechanism based on metadata matching, has been developed for supporting interoperability of cooperative information systems. Some design patterns guided the construction of the resulting communication service that has been implemented on top of CORBA for an ODMG canonical data model.

The prototyping language ProSET (Prototyping with Sets) for experimental and evolutionary prototyping is discussed, with emphasis on algorithm design. Its features include generative communication, flexible exception handling, and the integration of persistence. Issues pertaining to the compiler and the programming environment are discussed.>