Home | Sitemap | Index | Contact | Legals | KIT

Publications of Ralf H. Reussner

Books/Book Chapters and edited Proceedings

[1] Ralf H. Reussner, Steffen Becker, Jens Happe, Robert Heinrich, Anne Koziolek, Heiko Koziolek, Max Kramer, and Klaus Krogmann. Modeling and Simulating Software Architectures - The Palladio Approach. MIT Press, Cambridge, MA, October 2016. to appear. [ bib | http | Abstract ]
Too often, software designers lack an understanding of the effect of design decisions on such quality attributes as performance and reliability. This necessitates costly trial-and-error testing cycles, delaying or complicating rollout. This book presents a new, quantitative architecture simulation approach to software design, which allows software engineers to model quality of service in early design stages. It presents the first simulator for software architectures, Palladio, and shows students and professionals how to model reusable, parametrized components and configured, deployed systems in order to analyze service attributes. The text details the key concepts of Palladio's domain-specific modeling language for software architecture quality and presents the corresponding development stage. It describes how quality information can be used to calibrate architecture models from which detailed simulation models are automatically derived for quality predictions. Readers will learn how to approach systematically questions about scalability, hardware resources, and efficiency. The text features a running example to illustrate tasks and methods as well as three case studies from industry. Each chapter ends with exercises, suggestions for further reading, and "takeaways" that summarize the key points of the chapter. The simulator can be downloaded from a companion website, which offers additional material. The book can be used in graduate courses on software architecture, quality engineering, or performance engineering. It will also be an essential resource for software architects and software engineers and for practitioners who want to apply Palladio in industrial settings.
[2] Ralf Reussner, Steffen Becker, Anne Koziolek, and Heiko Koziolek. Perspectives on the Future of Software Engineering, chapter An Empirical Investigation of the Component-Based Performance Prediction Method Palladio, pages 191-207. Springer Berlin Heidelberg, 2013. [ bib | DOI | http | .pdf ]
[3] Ralf H. Reussner and Wilhelm Hasselbring. Handbuch der Software-Architektur. dPunkt.verlag Heidelberg, 2 edition, December 2008. [ bib ]
[4] Rainer Böhme and Ralf Reussner. Validation of Predictions with Measurements. In Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter 3, pages 14-18. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf | Abstract ]
This chapter discusses ways to validate metrics and raises awareness for possible caveats if metrics are used in a social environment.
[5] Rainer Böhme and Ralf Reussner. On metrics and measurements. In Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter 2, pages 7-13. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf | Abstract ]
The following chapter attempts to define the notions of metric and measurement which underlie this book. It further elaborates on general properties of metrics and introduces useful terms and concepts from measurement theory, without being overly formal.
[6] Sebastian Herold, Holger Klus, Yannick Welsch, Constanze Deiters, Andreas Rausch, Ralf Reussner, Klaus Krogmann, Heiko Koziolek, Raffaela Mirandola, Benjamin Hummel, Michael Meisinger, and Christian Pfaller. The Common Component Modeling Example, volume 5153 of Lecture Notes in Computer Science, chapter CoCoME - The Common Component Modeling Example, pages 16-53. Springer-Verlag Berlin Heidelberg, 2008. [ bib | http | Abstract ]
The example of use which was chosen as the Common Component Modeling Example (CoCoME) and on which the several methods presented in this book should be applied was designed according to the example described by Larman in [1]. The description of this example and its use cases in the current chapter shall be considered under the assumption that this information was delivered by a business company as it could be in the reality. Therefore the specified requirements are potentially incomplete or imprecise.
[7] Klaus Krogmann and Ralf H. Reussner. The Common Component Modeling Example, volume 5153 of Lecture Notes in Computer Science, chapter Palladio: Prediction of Performance Properties, pages 297-326. Springer-Verlag Berlin Heidelberg, 2008. [ bib | http | Abstract ]
Palladio is a component modelling approach with a focus on performance (i.e. response time, throughput, resource utilisation) analysis to enable early design-time evaluation of software architectures. It targets modelling business information systems. The Palladio approach includes a meta-model called Palladio Component Model for structural views, component behaviour specifications, resource environment, component allocation and the modelling of system usage and multiple analysis techniques ranging from process algebra analysis to discrete event simulation. Additionally, the Palladio approach is aligned with a development process model tailored for component-based software systems. Early design-time predictions avoid costly redesigns and reimplementation. Palladio enables software architects to analyse different architectural design alternatives supporting their design decisions with quantitative performance predictions, provided with the Palladio approach.
[8] Ralf Reussner and Viktoria Firus. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Basic and Dependent Metrics, pages 37-38. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf ]
[9] Ralf Reussner and Viktoria Firus. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Introduction to Overlapping Attributes, pages 243-244. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf ]
[10] Irene Eusgeld, Felix C. Freiling, and Ralf Reussner, editors. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science. Springer-Verlag Berlin Heidelberg, 2008. [ bib | DOI | http ]
[11] Andreas Rausch, Ralf Reussner, Raffaela Mirandola, and FrantisekPlasil, editors. The Common Component Modeling Example: Comparing Software Component Models, volume 5153 of Lecture Notes in Computer Science. Springer-Verlag Berlin Heidelberg, 2008. [ bib | http ]
[12] Ralf H. Reussner and Wilhelm Hasselbring. Handbuch der Software-Architektur. dPunkt.verlag Heidelberg, 1 edition, March 2006. [ bib ]
[13] Heiko Koziolek, Viktoria Firus, Steffen Becker, and Ralf H. Reussner. Handbuch der Software-Architektur, chapter Bewertungstechniken für die Performanz, pages 311-326. dPunkt.verlag Heidelberg, 2006. [ bib ]
[14] Ralf H. Reussner. Parametrisierte Verträge zur Protokolladaption bei Software-Komponenten. Logos Verlag, Berlin, 2001. [ bib ]

Refereed journal articles

[1] Georg Hinkel, Henning Groenda, Sebastian Krach, Lorenzo Vannucci, Oliver Denninger, Nino Cauli, Stefan Ulbrich, Arne Roennau, Egidio Falotico, Marc-Oliver Gewaltig, Alois Knoll, Rüdiger Dillmann, Cecilia Laschi, and Ralf Reussner. A Framework for Coupled Simulations of Robots and Spiking Neuronal Networks. Journal of Intelligent & Robotics Systems, 2016. [ bib | .pdf | Abstract ]
Bio-inspired robots still rely on classic robot control although advances in neurophysiology allow adaptation to control as well. However, the connection of a robot to spiking neuronal networks needs adjustments for each purpose and requires frequent adaptation during an iterative development. Existing approaches cannot bridge the gap between robotics and neuroscience or do not account for frequent adaptations. The contribution of this paper is an architecture and domain-specific language (DSL) for connecting robots to spiking neuronal networks for iterative testing in simulations, allowing neuroscientists to abstract from implementation details. The framework is implemented in a web-based platform. We validate the applicability of our approach with a case study based on image processing for controlling a four-wheeled robot in an experiment setting inspired by Braitenberg vehicles.
[2] Matthias Budde, Sarah Grebing, Erik Burger, Max E. Kramer, Bernhard Beckert, Michael Beigl, and Ralf Reussner. Praxis der Forschung - Eine Lehrveranstaltung des forschungsnahen Lehrens und Lernens in der Informatik am KIT. Neues Handbuch Hochschullehre, 74(A 3.19), 2016, DUZ Verlags- und Medienhaus GmbH. [ bib | Abstract ]
Der neue Lehrveranstaltungstyp Praxis der Forschung wurde 2012 im Master-Studiengang Informatik des Karlsruher Instituts für Technologie (KIT) eingeführt. Zentrales Konzept dieser Veranstaltung ist das forschungsnahe Lehren und Lernen: Studierende erwerben im Rahmen eines eigenen Forschungsprojekts sowohl Fachwissen als auch methodische Kompetenz zu wissenschaftlicher Arbeit. Die konkrete Ausgestaltung folgt den Grundsätzen der Forschungsnähe und der integrierten Vermittlung methodischer Kompetenzen. Die Studierenden sollen insbesondere auch erfahren, dass es ein wesentlicher Aspekt der wissenschaftlichen Arbeit ist, Forschungsergebnisse sicht- und wahrnehmbar zu machen.
[3] Robert Heinrich, Stefan Gärtner, Tom-Michael Hesse, Thomas Ruhroth, Ralf Reussner, Kurt Schneider, Barbara Paech, and Jan Jürjens. The CoCoME platform: A research note on empirical studies in information system evolution. International Journal of Software Engineering and Knowledge Engineering, 25(09&10):1715-1720, 2015. [ bib | DOI | arXiv | http ]
[4] Steffen Becker, Wilhelm Hasselbring, Andre van Hoorn, Samuel Kounev, Ralf Reussner, et al. Proceedings of the 2014 symposium on software performance (sosp'14): Joint descartes/kieker/palladio days. 2014, Stuttgart, Germany, Universität Stuttgart. [ bib ]
[5] Catia Trubiani, Anne Koziolek, Vittorio Cortellessa, and Ralf Reussner. Guilt-based handling of software performance antipatterns in Palladio architectural models. Journal of Systems and Software, 95:141 - 165, 2014. [ bib | DOI | http | .pdf | Abstract ]
Antipatterns are conceptually similar to patterns in that they document recurring solutions to common design problems. Software Performance Antipatterns document common performance problems in the design as well as their solutions. The definition of performance antipatterns concerns software properties that can include static, dynamic, and deployment aspects. To make use of such knowledge, we propose an approach that helps software architects to identify and solve performance antipatterns. Our approach provides software performance feedback to architects, since it suggests the design alternatives that allow overcoming the detected performance problems. The feedback process may be quite complex since architects may have to assess several design options before achieving the architectural model that best fits the end-user expectations. In order to optimise such process we introduce a ranking methodology that identifies, among a set of detected antipatterns, the “guilty” ones, i.e. the antipatterns that more likely contribute to the violation of specific performance requirements. The introduction of our ranking process leads the system to converge towards the desired performance improvement by discarding a consistent part of design alternatives. Four case studies in different application domains have been used to assess the validity of the approach.
[6] Lucia Happe, Barbora Buhnova, and Ralf Reussner. Stateful component-based performance models. Software & Systems Modeling, 13(4):1319-1343, 2013, Springer-Verlag. [ bib | DOI | http | Abstract ]
The accuracy of performance-prediction models is crucial for widespread adoption of performance prediction in industry. One of the essential accuracy-influencing aspects of software systems is the dependence of system behaviour on a configuration, context or history related state of the system, typically reflected with a (persistent) system attribute. Even in the domain of component-based software engineering, the presence of state-reflecting attributes (the so-called internal states) is a natural ingredient of the systems, implying the existence of stateful services, stateful components and stateful systems as such. Currently, there is no consensus on the definition or method to include state-related information in component-based prediction models. Besides the task to identify and localise different types of stateful information across component-based software architecture, the issue is to balance the expressiveness and complexity of prediction models via an effective abstraction of state modelling. In this paper, we identify and classify stateful information in component-based software systems, study the performance impact of the individual state categories, and discuss the costs of their modelling in terms of the increased model size. The observations are formulated into a set of heuristics-guiding software engineers in state modelling. Finally, practical effect of state modelling on software performance is evaluated on a real-world case study, the SPECjms2007 Benchmark. The observed deviation of measurements and predictions was significantly decreased by more precise models of stateful dependencies.
[7] Michael Hauck, Michael Kuperberg, Nikolaus Huber, and Ralf Reussner. Deriving performance-relevant infrastructure properties through model-based experiments with ginpex. Software & Systems Modeling, pages 1-21, 2013, Springer-Verlag. [ bib | DOI | http | Abstract ]
To predict the performance of an application, it is crucial to consider the performance of the underlying infrastructure. Thus, to yield accurate prediction results, performance-relevant properties and behaviour of the infrastructure have to be integrated into performance models. However, capturing these properties is a cumbersome and error-prone task, as it requires carefully engineered measurements and experiments. Existing approaches for creating infrastructure performance models require manual coding of these experiments, or ignore the detailed properties in the models. The contribution of this paper is the Ginpex approach, which introduces goal-oriented and model-based specification and generation of executable performance experiments for automatically detecting and quantifying performance-relevant infrastructure properties. Ginpex provides a metamodel for experiment specification and comes with predefined experiment templates that provide automated experiment execution on the target platform and also automate the evaluation of the experiment results. We evaluate Ginpex using three case studies, where experiments are executed to quantify various infrastructure properties.
[8] Franz Brosch, Heiko Koziolek, Barbora Buhnova, and Ralf Reussner. Architecture-based reliability prediction with the palladio component model. IEEE Transactions on Software Engineering, 38(6):1319-1339, Nov 2012, IEEE Computer Society. [ bib | DOI | Abstract ]
With the increasing importance of reliability in business and industrial software systems, new techniques of architecture-based reliability engineering are becoming an integral part of the development process. These techniques can assist system architects in evaluating the reliability impact of their design decisions. Architecture-based reliability engineering is only effective if the involved reliability models reflect the interaction and usage of software components and their deployment to potentially unreliable hardware. However, existing approaches either neglect individual impact factors on reliability or hard-code them into formal models, which limits their applicability in component-based development processes. This paper introduces a reliability modelling and prediction technique that considers the relevant architectural factors of software systems by explicitly modelling the system usage profile and execution environment and automatically deriving component usage profiles. The technique offers a UML-like modelling notation, whose models are automatically transformed into a formal analytical model. Our work builds upon the Palladio Component Model, employing novel techniques of information propagation and reliability assessment. We validate our technique with sensitivity analyses and simulation in two case studies. The case studies demonstrate effective support of usage profile analysis and architectural configuration ranking, together with the employment of reliability-improving architecture tactics.
[9] Jens Happe, Heiko Koziolek, and Ralf Reussner. Facilitating performance predictions using software components. Software, IEEE, 28(3):27 -33, June 2011. [ bib | DOI ]
[10] Anne Martens, Heiko Koziolek, Lutz Prechelt, and Ralf Reussner. From monolithic to component-based performance evaluation of software architectures. Empirical Software Engineering, 16(5):587-622, 2011, Springer Netherlands. [ bib | DOI | http | .pdf | Abstract ]
Background: Model-based performance evaluation methods for software architectures can help architects to assess design alternatives and save costs for late life-cycle performance fixes. A recent trend is component-based performance modelling, which aims at creating reusable performance models; a number of such methods have been proposed during the last decade. Their accuracy and the needed effort for modelling are heavily influenced by human factors, which are so far hardly understood empirically.

Objective: Do component-based methods allow to make performance predictions with a comparable accuracy while saving effort in a reuse scenario? We examined three monolithic methods (SPE, umlPSI, Capacity Planning (CP)) and one component-based performance evaluation method (PCM) with regard to their accuracy and effort from the viewpoint of method users.

Methods: We conducted a series of three experiments (with different levels of control) involving 47 computer science students. In the first experiment, we compared the applicability of the monolithic methods in order to choose one of them for comparison. In the second experiment, we compared the accuracy and effort of this monolithic and the component-based method for the model creation case. In the third, we studied the effort reduction from reusing component-based models. Data were collected based on the resulting artefacts, questionnaires and screen recording. They were analysed using hypothesis testing, linear models, and analysis of variance.

Results: For the monolithic methods, we found that using SPE and CP resulted in accurate predictions, while umlPSI produced over-estimates. Comparing the component-based method PCM with SPE, we found that creating reusable models using PCM takes more (but not drastically more) time than using SPE and that participants can create accurate models with both techniques. Finally, we found that reusing PCM models can save time, because effort to reuse can be explained by a model that is independent of the inner complexity of a component.

Limitations: The tasks performed in our experiments reflect only a subset of the actual activities when applying model-based performance evaluation methods in a software development process.

Conclusions: Our results indicate that sufficient prediction accuracy can be achieved with both monolithic and component-based methods, and that the higher effort for component-based performance modelling will indeed pay off when the component models incorporate and hide a sufficient amount of complexity.

[11] Jens Happe, Steffen Becker, Christoph Rathfelder, Holger Friedrich, and Ralf H. Reussner. Parametric Performance Completions for Model-Driven Performance Prediction. Performance Evaluation (PE), 67(8):694-716, August 2010, Elsevier. [ bib | DOI | http | .pdf | Abstract ]
Performance prediction methods can help software architects to identify potential performance problems, such as bottlenecks, in their software systems during the design phase. In such early stages of the software life-cycle, only a little information is available about the system�s implementation and execution environment. However, these details are crucial for accurate performance predictions. Performance completions close the gap between available high-level models and required low-level details. Using model-driven technologies, transformations can include details of the implementation and execution environment into abstract performance models. However, existing approaches do not consider the relation of actual implementations and performance models used for prediction. Furthermore, they neglect the broad variety of possible implementations and middleware platforms, possible configurations, and possible usage scenarios. In this paper, we (i) establish a formal relation between generated performance models and generated code, (ii) introduce a design and application process for parametric performance completions, and (iii) develop a parametric performance completion for Message-oriented Middleware according to our method. Parametric performance completions are independent of a specific platform, reflect performance-relevant software configurations, and capture the influence of different usage scenarios. To evaluate the prediction accuracy of the completion for Message-oriented Middleware, we conducted a real-world case study with the SPECjms2007 Benchmark [http://www.spec.org/jms2007/]. The observed deviation of measurements and predictions was below 10% to 15%
[12] Manfred Broy and Ralf Reussner. Architectural concepts in programming languages. Computer, 43:88-91, 2010, IEEE Computer Society, Los Alamitos, CA, USA. [ bib | DOI | .pdf ]
[13] Klaus Krogmann, Michael Kuperberg, and Ralf Reussner. Using Genetic Search for Reverse Engineering of Parametric Behaviour Models for Performance Prediction. IEEE Transactions on Software Engineering, 36(6):865-877, 2010, IEEE. [ bib | DOI | .pdf | Abstract ]
In component-based software engineering, existing components are often re-used in new applications. Correspondingly, the response time of an entire component-based application can be predicted from the execution durations of individual component services. These execution durations depend on the runtime behaviour of a component, which itself is influenced by three factors: the execution platform, the usage profile, and the component wiring. To cover all relevant combinations of these influencing factors, conventional prediction of response times requires repeated deployment and measurements of component services for all such combinations, incurring a substantial effort. This paper presents a novel comprehensive approach for reverse engineering and performance prediction of components. In it, genetic programming is utilised for reconstructing a behaviour model from monitoring data, runtime bytecode counts and static bytecode analysis. The resulting behaviour model is parametrised over all three performance-influencing factors, which are specified separately. This results in significantly fewer measurements: the behaviour model is reconstructed only once per component service, and one application-independent bytecode benchmark run is sufficient to characterise an execution platform. To predict the execution durations for a concrete platform, our approach combines the behaviour model with platform-specific benchmarking results. We validate our approach by predicting the performance of a file sharing application.
[14] Engels Gregor, Goedicke Michael, Goltz Ursula, Rausch Andreas, and Reussner Ralf. Design for future - legacy-probleme von morgen vermeidbar? Informatik-Spektrum, 32(5):393-397, October 2009. [ bib ]
[15] Klaus Krogmann and Ralf Reussner. Reverse Engineering von Software-Komponentenverhalten mittels Genetischer Programmierung. Softwaretechnik-Trends, 29(2):22-24, May 2009. [ bib | .pdf | Abstract ]
Die Verwendung von Komponenten ist ein anerkanntes Prinzip in der Software-Entwicklung. Dabei werden Software-Komponenten zumeist als Black-Boxes aufgefasst, deren Interna vor einem Komponenten-Verwender verborgen sind. Architektur-Analyse- Verfahren zur Vorhersage nicht-funktionaler Eigenschaften erlauben bspw. auf der Architekturebene Dimensionierungsfragestellungen fuer Hardware- / Software-Umgebungen zu beantworten, sowie Skalierbarkeitsanalysen und Was-Waere-Wenn-Szenarien fuer die Erweiterung von Altsystemen durchzufuehren. Dazu benoetigen sie jedoch Informationen ueber Interna (bspw. die Anzahl abgearbeiteter Schleifen oder Aufrufe externer Dienste) von Komponenten. Um an solche Informationen zu gelangen muessen existierende Software-Komponenten analysiert werden. Die benoetigten Informationen ueber das Innere der Komponenten muessen dabei derart rekonstruiert werden, dass sie fuer anschließende Analyseverfahren nicht-funktionaler Eigenschaften genutzt werden koennen. Eine haendische Rekonstruktion solcher Modelle scheitert haeufig an der Groeße der Systeme und ist sehr fehleranfaellig, da konsistente Abstraktionen ueber potentiell tausende Zeilen von Code gefunden werden muessen. Bestehende Verfahren liefern dabei nicht die notwendigen Daten- und Kontrollflussabstraktionen die fuer Analysen und Simulationen benoetigt werden. Der Beitrag dieses Papiers ist ein Reverse Engineering Verfahren fuer Komponentenverhalten. Die daraus resultierenden Modelle (Palladio Komponentenmodell) eignen sich zur Vorhersage von Performanz-Eigenschaften (Antwortzeit, Durchsatz) und damit fuer die oben angefuehrten Fragestellungen. Die aus Quellcode rekonstruierten Modelle umfassen parametrisierten Kontroll- und Datenfluss fuer Software-Komponenten und stellen eine Abstraktion realer Zusammenhänge im Quellcode dar. Das Reverse Engineering Verfahren kombiniert dabei ueber Genetische Programmierung (einer Form von Maschinen Lernen) statische und dynamische Analyseverfahren.
[16] Steffen Becker, Heiko Koziolek, and Ralf Reussner. The Palladio component model for model-driven performance prediction. Journal of Systems and Software, 82:3-22, 2009, Elsevier Science Inc. [ bib | DOI | http | Abstract ]
One aim of component-based software engineering (CBSE) is to enable the prediction of extra-functional properties, such as performance and reliability, utilising a well-defined composition theory. Nowadays, such theories and their accompanying prediction methods are still in a maturation stage. Several factors influencing extra-functional properties need additional research to be understood. A special problem in CBSE stems from its specific development process: Software components should be specified and implemented independently from their later context to enable reuse. Thus, extra-functional properties of components need to be specified in a parametric way to take different influencing factors like the hardware platform or the usage profile into account. Our approach uses the Palladio component model (PCM) to specify component-based software architectures in a parametric way. This model offers direct support of the CBSE development process by dividing the model creation among the developer roles. This paper presents our model and a simulation tool based on it, which is capable of making performance predictions. Within a case study, we show that the resulting prediction accuracy is sufficient to support the evaluation of architectural design decisions.
[17] Steffen Becker and Ralf Reussner. The Impact of Software Component Adaptation on Quality of Service Properties. L objet, 12(1):105-125, 2006, RSTI. [ bib | Abstract ]
Component adapters are used to bridge interoperability problems between the required interface of a component and the provided interface of another component. As bridging functional mismatches is frequently required, the use of adapters is unavoidable. In these cases an impact on the Quality of Service resulting from the adaptation is often undesired. Nevertheless, some adapters are deployed to change the Quality of Service on purpose when the interoperability problem results from mismatching Quality of Service. This emphasises the need of adequate prediction models for the impact of component adaptation on the Quality of Service characteristics. We present research on the impact of adaptation on the Quality of Service and focus on unresolved issues hindering effective predictions nowadays.
[18] Wilhelm Hasselbring and Ralf H. Reussner. Toward Trustworthy Software Systems. IEEE Computer, 30(4):91-92, 2006. [ bib | .pdf ]
[19] Benedikt Kratz, Ralf Reussner, and Willem-Jan van den Heuvel. Empirical Research on Similarity Metrics for Software Component Interfaces. J. Integr. Des. Process Sci., 8(4):1-17, 2004, IOS Press, Amsterdam, The Netherlands, The Netherlands. [ bib | Abstract ]
The notions of design and process cut across many disciplines. Applications of abstract notions of design and process to engineering problem solving would certainly redefine and expand the notion of engineering itself in the 21st century. This Journal of SDPS strives to be the repository of human knowledge covering interdisciplinary notions of design and process in a rigorous fashion. We expect and encourage papers crossing the boundaries back and forth in mathematical landscape as well as among mathematics, physics, economics, management science, and engineering. Journal of Integrated Design and Process Science is an archival, peer-reviewed technical journal publishing the following types of papers: a) Research papers, b) Reports on case studies, c) Reports on major design and process projects, d) Design and process standards and proposals, and e) Insightful tutorials on design and process. It has been observed that most of the work related to design and process is interdisciplinary and until recently has been scattered in journals of many diverse disciplines. The objective on this journal is to publish state-of-the-art papers in this expanding field, providing an international and interdisciplinary forum for best work in design and process related areas. The audience of this journal will have a single source to stay current on new and quality work as academic research papers and synthesis on best-practices. Consistent with SDPS philosophy, the Journal strives to maintain an international and interdisciplinary balance by relying on experts from various corners of the world. Authors whose work are in the domain of interdisciplinary no-man's land with a flavor of design and process are encouraged to submit their papers to this Journal. The readership of this journal includes participants from academia and industry.
[20] Ralf H. Reussner. Automatic Component Protocol Adaptation with the CoCoNut Tool Suite. Future Generation Computer Systems, 19(5):627-639, 2003. [ bib | Abstract ]
The purpose of this tutorial is to provide concepts and historical background of the �network integration testing� (NIT) methodology. NIT is a �grey box� testing technique that is aimed at verifying the correct behaviour of interconnected networks (operated by different operators) in provisioning services to end users, or the behaviour of a complex network operated by a unique operator. The main technical concepts behind this technique are presented along with the history of some International projects that have contributed to its early definition and application. European Institute for Research and Strategic Studies in Telecommunication (EURESCOM) has actually been very active, with many projects, in defining the NIT basic methodology and providing actual NIT specifications (for narrow-band and broad-band services, covering both voice and data). EURESCOM has also been acting as a focal point in the area, e.g., encouraging the Industry in developing commercial tools supporting NIT. In particular, the EURESCOM P412 project (1994�1996) first explicitly defined the NIT methodology (the methodological aspects include test notation, test implementation, test processes, distributed testing and related co-ordination aspects). P412 applied the methodology to ISDN whilst another project, P410, applied NIT to data services. The P613 project (1997�1999) extended the basic NIT methodology to the broad band and GSM. More into details, the areas covered currently by NIT test specifications developed by EURESCOM projects include N-ISDN, N-ISUP, POTS, B-ISDN, B-ISUP, IP over ATM, ATM/FR, GSM, focusing also on their �inter-working� cases (e.g., ISDN/ISDN, ISDN/GSM, etc.). ETSI, the European Telecommunication Standards Institute, also contributed to NIT development (e.g., the definition of the TSP1+ protocol, used for the functional co-ordination and timing synchronisation of all tools involved in a distributed testing session). The paper also discusses NIT in relation to the recent major changes (processes) within the telecommunication (TLC) community. Beyond the new needs coming from the pure technical aspects (integration of voice and data, fixed mobile convergence, etc.) the full deregulation of the TLC sector has already generated new processes and new testing needs (e.g., Interconnection Testing) that had a significant influence on the methodology. NIT is likely to continue to develop further in the future according to the needs of telecom operators, authorities, user�s associations and suppliers.
[21] Ralf H. Reussner. Using SKaMPI for Developing High-Performance MPI Programs with Performance Portability. Future Generation Computer Systems, 19(5):749-759, 2003. [ bib ]
[22] Ralf H. Reussner, Heinz W. Schmidt, and Iman Poernomo. Reliability Prediction for Component-Based Software Architectures. Journal of Systems and Software - Special Issue of Software Architecture - Engineering Quality Attributes, 66(3):241-252, 2003. [ bib | Abstract ]
Due to the increasing size and complexity of software systems, software architectures have become a crucial part in development projects. A lot of effort has been put into defining formal ways for describing architecture specifications using Architecture Description Languages (ADLs). Since no common ADL today offers tools for evaluating the performance, an attempt to develop such a tool based on an event-based simulation engine has been made. Common ADLs were investigated and the work was based on the fundamentals within the field of software architectures. The tool was evaluated both in terms of correctness in predictions as well as usability to show that it actually is possible to evaluate the performance using high-level architectures as models.
[23] Heinz W. Schmidt, Iman Poernomo, and Ralf H. Reussner. Trust-By-Contract: Modelling, Analysing and Predicting Behaviour in Software Architectures. Journal of Integrated Design and Process Science, 5(3):25-51, September 2001. [ bib | Abstract ]
The increasing pressure for enterprises to join into agile business networks is changing the requirements on the enterprise computing systems. The supporting infrastructure is increasingly required to provide common facilities and societal infrastructure services to support the lifecycle of loosely-coupled, eContract-governed business networks. The required facilities include selection of those autonomously administered business services that the enterprises are prepared to provide and use, contract negotiations, and furthermore, monitoring of the contracted behaviour with potential for breach management. The essential change is in the requirement of a clear mapping between business-level concepts and the automation support for them. Our work has focused on developing B2B middleware to address the above challenges; however, the architecture is not feasible without management facilities for trust-aware decisions for entering business networks and interacting within them. This paper discusses how trust-based decisions are supported and positioned in the B2B middleware.
[24] Ralf H. Reussner, Peter Sanders, and Jesper Larsson Träff. SKaMPI: a comprehensive benchmark for public benchmarking of MPI. Scientific Computing, 2001. [ bib | .pdf ]
[25] Antje von Knethen, Erik Kamsties, Ralf H. Reussner, Christian Bunse, and Bin Shen. Une étude comparative de méthodes industrielles d'ingénierie des exigences. Génie Logiciel, 50:8-15, 1999. [ bib ]

Refereed conference/Workshop papers

inproceedings_reussner
[1] Michael Langhammer, Arman Shahbazian, Nenad Medvidovic, and Ralf H. Reussner. Automated extraction of rich software models from limited system information. In 2016 13th Working IEEE/IFIP Conference on Software Architecture (WICSA), April 2016, pages 99-108. [ bib | DOI ]
[2] Stephan Seifermann, Emre Taspolatoglu, Robert Heinrich, and Ralf Reussner. Challenges in secure software evolution - the role of software architecture. In 3rd Collaborative Workshop on Evolution and Maintenance of Long-Living Software Systems, 2016, Softwaretechnik-Trends Band 36 Heft 1, pages 8-11. [ bib | .pdf ]
[3] Birgit Vogel-Heuser, Thomas Simon, Jens Folmer, Robert Heinrich, Kiana Rostami, and Ralf H. Reussner. Towards a common classification of changes for information and automated production systems as precondition for maintenance effort estimation. In IEEE - INDIN 2016: 14th International Conference on Industrial Informatics, 2016. accepted, to appear. [ bib ]
[4] Axel Busch, Qais Noorshams, Samuel Kounev, Anne Koziolek, Ralf Reussner, and Erich Amrehn. Automated workload characterization for i/o performance analysis in virtualized environments. In Software Engineering 2016, Fachtagung des GI-Fachbereichs Softwaretechnik, 2016, pages 27-28. [ bib | .html | .pdf ]
[5] Lukas Märtin, Anne Koziolek, and Ralf H. Reussner. Quality-oriented decision support for maintaining architectures of fault-tolerant space systems. In Proceedings of the 2015 European Conference on Software Architecture Workshops, Dubrovnik/Cavtat, Croatia, September 7-11, 2015, Ivica Crnkovic, editor, 2015, pages 49:1-49:5. ACM. 2015. [ bib | DOI | http ]
[6] Qais Noorshams, Axel Busch, Samuel Kounev, and Ralf Reussner. The Storage Performance Analyzer: Measuring, Monitoring, and Modeling of I/O Performance in Virtualized Environments. In Proceedings of the 6th ACM/SPEC International Conference on Performance Engineering, Austin, Texas, USA, 2015, ICPE '15. [ bib | DOI | http | .pdf ]
[7] Axel Busch, Qais Noorshams, Samuel Kounev, Anne Koziolek, Ralf Reussner, and Erich Amrehn. Automated Workload Characterization for I/O Performance Analysis in Virtualized Environments. In Proceedings of the ACM/SPEC International Conference on Performance Engineering, Austin, Texas, USA, 2015, ICPE '15, pages 265-276. ACM, New York, NY, USA. 2015, Acceptance Rate (Full Paper): 15/56 = 27%. [ bib | DOI | http | .pdf | Abstract ]
Next generation IT infrastructures are highly driven by virtualization technology. The latter enables flexible and efficient resource sharing allowing to improve system agility and reduce costs for IT services. Due to the sharing of resources and the increasing requirements of modern applications on I/O processing, the performance of storage systems is becoming a crucial factor. In particular, when migrating or consolidating different applications the impact on their performance behavior is often an open question. Performance modeling approaches help to answer such questions, a prerequisite, however, is to find an appropriate workload characterization that is both easy to obtain from applications as well as sufficient to capture the important characteristics of the application. In this paper, we present an automated workload characterization approach that extracts a workload model to represent the main aspects of I/O-intensive applications using relevant workload parameters, e.g., request size, read-write ratio, in virtualized environments. Once extracted, workload models can be used to emulate the workload performance behavior in real-world scenarios like migration and consolidation scenarios. We demonstrate our approach in the context of two case studies of representative system environments. We present an in-depth evaluation of our workload characterization approach showing its effectiveness in workload migration and consolidation scenarios. We use an IBM System z equipped with an IBM DS8700 and a Sun Fire system as state-of-the-art virtualized environments. Overall, the evaluation of our workload characterization approach shows promising results to capture the relevant factors of I/O-intensive applications.
[8] Kiana Rostami, Johannes Stammel, Robert Heinrich, and Ralf Reussner. Architecture-based assessment and planning of change requests. In Proceedings of the 11th International ACM SIGSOFT Conference on Quality of Software Architectures, Montreal, QC, Canada, 2015, QoSA '15, pages 21-30. ACM, New York, NY, USA. 2015. [ bib | http | .pdf ]
[9] Robert Heinrich, Kiana Rostami, Johannes Stammel, Thomas Knapp, and Ralf Reussner. Architecture-based analysis of changes in information system evolution. In Softwaretechnik-Trends, 2015, volume 35(2). [ bib | .pdf ]
[10] Christian Stier, Anne Koziolek, Henning Groenda, and Ralf Reussner. Model-Based Energy Efficiency Analysis of Software Architectures. In Proceedings of the 9th European Conference on Software Architecture (ECSA '15), Dubrovnik/Cavtat, Croatia, 2015, Lecture Notes in Computer Science. Springer. 2015, Acceptance Rate (Full Paper): 15/80 = 18.8%. [ bib | DOI | http | .pdf | Abstract ]
Design-time quality analysis of software architectures evaluates the impact of design decisions in quality dimensions such as performance. Architectural design decisions decisively impact the energy efficiency (EE) of software systems. Low EE not only results in higher operational cost due to power consumption. It indirectly necessitates additional capacity in the power distribution infrastructure of the target deployment environment. Methodologies that analyze EE of software systems are yet to reach an abstraction suited for architecture-level reasoning. This paper outlines a model-based approach for evaluating the EE of software architectures. First, we present a model that describes the central power consumption characteristics of a software system. We couple the model with an existing model-based performance prediction approach to evaluate the consumption characteristics of a software architecture in varying usage contexts. Several experiments show the accuracy of our architecture-level consumption predictions. Energy consumption predictions reach an error of less than 5.5% for stable and 3.7% for varying workloads. Finally, we present a round-trip design scenario that illustrates how the explicit consideration of EE supports software architects in making informed trade-off decisions between performance and EE.
[11] Robert Heinrich, Stefan Gärtner, Tom-Michael Hesse, Thomas Ruhroth, Ralf Reussner, Kurt Schneider, Barbara Paech, and Jan Jürjens. A platform for empirical research on information system evolution. In 27th International Conference on Software Engineering and Knowledge Engineering, 2015, pages 415-420. Acceptance Rate (Full Paper) = 29%. [ bib | .pdf ]
[12] Birgit Vogel-Heuser, Stefan Feldmann, Jens Folmer, Susanne Rösch, Robert Heinrich, Kiana Rostami, and Ralf H. Reussner. Architecture-based assessment and planning of software changes in information and automated production systems. In IEEE International Conference on Systems, Man, and Cybernetics. 2015. [ bib | DOI | http | .pdf ]
[13] Robert Heinrich, Reiner Jung, Eric Schmieders, Andreas Metzger, Wilhelm Hasselbring, Ralf Reussner, and Klaus Pohl. Architectural run-time models for operator-in-the-loop adaptation of cloud applications. In IEEE 9th Symposium on the Maintenance and Evolution of Service-Oriented Systems and Cloud-Based Environments, 2015. IEEE. 2015. [ bib | .pdf ]
[14] Misha Strittmatter, Kiana Rostami, Robert Heinrich, and Ralf Reussner. A modular reference structure for component-based architecture description languages. In 2nd International Workshop on Model-Driven Engineering for Component-Based Systems (ModComp), pages 36-41. CEUR, 2015. [ bib | slides | .pdf ]
[15] Robert Heinrich, Reiner Jung, Eric Schmieders, Andreas Metzger, Wilhelm Hasselbring, Klaus Pohl, and Ralf Reussner. Integrated observation and modeling techniques to support adaptation and evolution of software systems. In DFG Priority Program SPP1593, 4th Workshop, November 2014. [ bib | http | Abstract ]
iObserve is an approach to integrate model-driven monitoring with design time models of software systems and reuse those models at run time to realize analyses based on the design time model. It is assumed that this reduces the effort to be made to interpret analysis results of a software system.
[16] Andreas Rentschler, Dominik Werle, Qais Noorshams, Lucia Happe, and Ralf Reussner. Remodularizing Legacy Model Transformations with Automatic Clustering Techniques. In Proceedings of the 3rd Workshop on the Analysis of Model Transformations co-located with the 17th International Conference on Model Driven Engineering Languages and Systems (AMT@MODELS '14), Valencia, Spain, September 29, 2014, Benoit Baudry, Jürgen Dingel, Levi Lucio, and Hans Vangheluwe, editors, October 2014, volume 1277 of CEUR Workshop Proceedings, pages 4-13. CEUR-WS.org. October 2014. [ bib | http | .pdf ]
[17] Andreas Rentschler, Dominik Werle, Qais Noorshams, Lucia Happe, and Ralf Reussner. Designing Information Hiding Modularity for Model Transformation Languages. In Proceedings of the 13th International Conference on Modularity (AOSD '14), Lugano, Switzerland, April 22 - 26, 2014, April 2014, pages 217-228. ACM, New York, NY, USA. April 2014, Acceptance Rate: 35.0%. [ bib | DOI | http | .pdf ]
[18] Lucia Happe, Erik Burger, Max Kramer, Andreas Rentschler, and Ralf Reussner. Completion and Extension Techniques for Enterprise Software Performance Engineering. In Future Business Software - Current Trends in Business Software Development, Gino Brunetti, Thomas Feld, Joachim Schnitter, Lutz Heuser, and Christian Webel, editors, Progress in IS, pages 117-131. Springer International Publishing, 2014. [ bib | DOI ]
[19] Tomás Martinec, Lukás Marek, Antonín Steinhauser, Petr Tůma, Qais Noorshams, Andreas Rentschler, and Ralf Reussner. Constructing performance model of jms middleware platform. In Proceedings of the 5th ACM/SPEC International Conference on Performance Engineering, Dublin, Ireland, 2014, ICPE '14, pages 123-134. ACM, New York, NY, USA. 2014. [ bib | DOI | http ]
[20] Qais Noorshams, Kiana Rostami, Samuel Kounev, and Ralf Reussner. Modeling of I/O Performance Interference in Virtualized Environments with Queueing Petri Nets. In Proceedings of the IEEE 22nd International Symposium on Modeling, Analysis and Simulation of Computer and Telecommunication Systems, France, Paris, 2014, MASCOTS '14. [ bib | .pdf ]
[21] Qais Noorshams, Roland Reeb, Andreas Rentschler, Samuel Kounev, and Ralf Reussner. Enriching software architecture models with statistical models for performance prediction in modern storage environments. In Proceedings of the 17th International ACM Sigsoft Symposium on Component-based Software Engineering, Marcq-en-Bareul, France, 2014, CBSE '14, pages 45-54. ACM, New York, NY, USA. 2014, Acceptance Rate (Full Paper): 14/62 = 23%. [ bib | DOI | http | .pdf ]
[22] Qais Noorshams, Axel Busch, Andreas Rentschler, Dominik Bruhn, Samuel Kounev, Petr Tůma, and Ralf Reussner. Automated Modeling of I/O Performance and Interference Effects in Virtualized Storage Systems. In 34th IEEE International Conference on Distributed Computing Systems Workshops (ICDCS 2014 Workshops). 4th International Workshop on Data Center Performance, DCPerf '14, Madrid, Spain, 2014, pages 88-93. [ bib | DOI | http | .pdf ]
[23] Zoya Durdik and Ralf Reussner. On the Appropriate Rationale for Using Design Patterns and Pattern Documentation. In Proceedings of Software Engineering (SE2014), 2014. [ bib ]
[24] Robert Heinrich, Eric Schmieders, Reiner Jung, Kiana Rostami, Andreas Metzger, Wilhelm Hasselbring, Ralf H. Reussner, and Klaus Pohl. Integrating run-time observations and design component models for cloud system analysis. In Proceedings of the 9th Workshop on Models@run.time co-located with 17th International Conference on Model Driven Engineering Languages and Systems (MODELS 2014), Valencia, Spain, September 30, 2014., 2014, pages 41-46. [ bib | .pdf ]
[25] Nikolas Roman Herbst, Samuel Kounev, and Ralf Reussner. Elasticity in Cloud Computing: What it is, and What it is Not (Short Paper). In Proceedings of the 10th International Conference on Autonomic Computing (ICAC 2013), San Jose, CA, June 24-28, 2013. USENIX. June 2013, Acceptance Rate (Short Paper): 36.9%. [ bib | slides | http | .pdf | Abstract ]
Originating from the field of physics and economics, the term elasticity is nowadays heavily used in the context of cloud computing. In this context, elasticity is commonly understood as the ability of a system to automatically provision and de-provision computing resources on demand as workloads change. However, elasticity still lacks a precise definition as well as representative metrics coupled with a benchmarking methodology to enable comparability of systems. Existing definitions of elasticity are largely inconsistent and unspecific leading to confusion in the use of the term and its differentiation from related terms such as scalability and efficiency; the proposed measurement methodologies do not provide means to quantify elasticity without mixing it with efficiency or scalability aspects. In this short paper, we propose a precise definition of elasticity and analyze its core properties and requirements explicitly distinguishing from related terms such as scalability, efficiency, and agility. Furthermore, we present a set of appropriate elasticity metrics and sketch a new elasticity tailored benchmarking methodology addressing the special requirements on workload design and calibration.
[26] Andreas Rentschler, Qais Noorshams, Lucia Happe, and Ralf Reussner. Interactive Visual Analytics for Efficient Maintenance of Model Transformations. In Proceedings of the 6th International Conference on Model Transformation (ICMT '13), Budapest, Hungary, Keith Duddy and Gerti Kappel, editors, June 2013, volume 7909 of Lecture Notes in Computer Science, pages 141-157. Springer-Verlag Berlin Heidelberg. June 2013, Acceptance Rate: 20.7%. [ bib | DOI | http | .pdf ]
[27] Zoya Durdik, Anne Koziolek, and Ralf Reussner. How the Understanding of the Effects of Design Decisions Informs Requirements Engineering. In Proceedings of the 2nd International Workshop on the Twin Peaks of Requirements and Architecture (TwinPeaks), May 2013, pages 14-18. [ bib | DOI ]
[28] Zoya Durdik and Ralf Reussner. On the Appropriate Rationale for Using Design Patterns and Pattern Documentation. In Proceedings of the 9th ACM SIGSOFT International Conference on the Quality of Software Architectures (QoSA 2013), 2013. [ bib ]
[29] Jörg Henss, Philipp Merkle, and Ralf H. Reussner. Poster abstract: The OMPCM simulator for model-based software performance prediction. In Proceedings of the 6th International ICST Conference on Simulation Tools and Techniques, Cannes, France, 2013. [ bib ]
[30] Marco Konersmann, Zoya Durdik, Michael Goedicke, and Ralf Reussner. Towards Architecture-Centric Evolution of Long-Living Systems (The ADVERT Approach). In Proceedings of the 9th ACM SIGSOFT International Conference on the Quality of Software Architectures (QoSA 2013), 2013. [ bib ]
[31] Qais Noorshams, Kiana Rostami, Samuel Kounev, Petr Tůma, and Ralf Reussner. I/O Performance Modeling of Virtualized Storage Systems. In Proceedings of the IEEE 21st International Symposium on Modeling, Analysis and Simulation of Computer and Telecommunication Systems, San Francisco, USA, 2013, MASCOTS '13, pages 121-130. Acceptance Rate (Full Paper): 44/163 = 27%. [ bib | DOI | http | .pdf ]
[32] Qais Noorshams, Dominik Bruhn, Samuel Kounev, and Ralf Reussner. Predictive Performance Modeling of Virtualized Storage Systems using Optimized Statistical Regression Techniques. In Proceedings of the ACM/SPEC International Conference on Performance Engineering, Prague, Czech Republic, 2013, ICPE '13, pages 283-294. ACM, New York, NY, USA. 2013. [ bib | DOI | http | .pdf ]
[33] Qais Noorshams, Andreas Rentschler, Samuel Kounev, and Ralf Reussner. A Generic Approach for Architecture-level Performance Modeling and Prediction of Virtualized Storage Systems. In Proceedings of the ACM/SPEC International Conference on Performance Engineering, Prague, Czech Republic, 2013, ICPE '13, pages 339-342. ACM, New York, NY, USA. 2013. [ bib | DOI | http | .pdf ]
[34] Qais Noorshams, Samuel Kounev, and Ralf Reussner. Experimental Evaluation of the Performance-Influencing Factors of Virtualized Storage Systems. In Computer Performance Engineering. 9th European Workshop, EPEW 2012, Munich, Germany, July 30, 2012, and 28th UK Workshop, UKPEW 2012, Edinburgh, UK, July 2, 2012, Revised Selected Papers, Mirco Tribastone and Stephen Gilmore, editors, volume 7587 of Lecture Notes in Computer Science, pages 63-79. Springer Berlin Heidelberg, 2013. [ bib | DOI | http | .pdf ]
[35] Robert Vaupel, Qais Noorshams, Samuel Kounev, and Ralf Reussner. Using Queuing Models for Large System Migration Scenarios - An Industrial Case Study with IBM System z. In Computer Performance Engineering. 10th European Workshop, EPEW 2013, Venice, Italy, September 16-17, 2013. Proceedings, Maria Simonetta Balsamo, William J. Knottenbelt, and Andrea Marin, editors, volume 8168 of Lecture Notes in Computer Science, pages 263-275. Springer Berlin Heidelberg, 2013. [ bib | DOI | http | .pdf ]
[36] Christoph Rathfelder, Stefan Becker, Klaus Krogmann, and Ralf Reussner. Workload-aware system monitoring using performance predictions applied to a large-scale e-mail system. In Proceedings of the Joint 10th Working IEEE/IFIP Conference on Software Architecture (WICSA) & 6th European Conference on Software Architecture (ECSA), Helsinki, Finland, August 2012, pages 31-40. IEEE Computer Society, Washington, DC, USA. August 2012, Acceptance Rate (Full Paper): 19.8%. [ bib | DOI | http | .pdf ]
[37] Stefanie Betz, Erik Burger, Alexander Eckert, Andreas Oberweis, Ralf Reussner, and Ralf Trunko. An approach for integrated lifecycle management for business processes and business software. In Aligning Enterprise, System, and Software Architectures, Ivan Mistrík, Antony Tang, Rami Bahsoon, and Judith A. Stafford, editors. IGI Global, 2012. [ bib ]
[38] Zoya Durdik and Ralf Reussner. Position Paper: Approach for Architectural Design and Modelling with Documented Design Decisions (ADMD3). In Proceedings of the 8th ACM SIGSOFT International Conference on the Quality of Software Architectures (QoSA 2012), Bertinoro, Italy, 2012. [ bib ]
[39] Michael Hauck, Michael Kuperberg, Nikolaus Huber, and Ralf Reussner. Ginpex: Deriving Performance-relevant Infrastructure Properties Through Goal-oriented Experiments. In Proceedings of the 7th ACM SIGSOFT International Conference on the Quality of Software Architectures (QoSA 2011), June 20-24, 2011, pages 53-62. ACM, New York, NY, USA. June 2011. [ bib | DOI | www: | .pdf ]
[40] Franz Brosch, Barbora Buhnova, Heiko Koziolek, and Ralf Reussner. Reliability Prediction for Fault-Tolerant Software Architectures. In International ACM Sigsoft Conference on the Quality of Software Architectures (QoSA), 2011, pages 75-84. ACM, New York, NY, USA. 2011. [ bib | .pdf | Abstract ]
Software fault tolerance mechanisms aim at improving the reliability of software systems. Their effectiveness (i.e., reliability impact) is highly application-specific and depends on the overall system architecture and usage profile. When examining multiple architecture configurations, such as in software product lines, it is a complex and error-prone task to include fault tolerance mechanisms effectively. Existing approaches for reliability analysis of software architectures either do not support modelling fault tolerance mechanisms or are not designed for an efficient evaluation of multiple architecture variants. We present a novel approach to analyse the effect of software fault tolerance mechanisms in varying architecture configurations. We have validated the approach in multiple case studies, including a large-scale industrial system, demonstrating its ability to support architecture design, and its robustness against imprecise input data.
[41] Erik Burger and Ralf Reussner. Performance Certification of Software Components. In Proceedings of the 8th International Workshop on Formal Engineering approaches to Software Components and Architectures (FESCA), 2011, volume 279 of Electronic Notes in Theoretical Computer Science, pages 33-41. Elsevier Science Publishers B. V. 2011. [ bib | slides | .pdf | Abstract ]
Non-functional properties of software should be specified early in the development process. In a distributed process of software development, this means that quality requirements must be made explicit in the specification, and the developing party of a commissioned component needs to deliver not only the implemented component, but also a description of its non-functional properties. Based on these artefacts, a conformance check guarantees that the implemented component fulfills the performance requirements. We extend the notion of model refinement to non-functional properties of software and propose a refinement calculus for conformance checking between abstract performance descriptions of components. The calculus is based on a refinement notion that covers the performance-relevant aspects of components. The approach is applied to the Palladio Component Model as a description language for performance properties of components.
[42] Michael Hauck, Jens Happe, and Ralf Reussner. Towards Performance Prediction for Cloud Computing Environments Based on Goal-oriented Measurements. In Proceedings of the 1st International Conference on Cloud Computing and Services Science (CLOSER 2011), 2011, pages 616-622. SciTePress. 2011. [ bib | http | .pdf ]
[43] Anne Koziolek, Heiko Koziolek, and Ralf Reussner. PerOpteryx: automated application of tactics in multi-objective software architecture optimization. In Joint proceedings of the Seventh International ACM SIGSOFT Conference on the Quality of Software Architectures and the 2nd ACM SIGSOFT International Symposium on Architecting Critical Systems (QoSA-ISARCS 2011), Ivica Crnkovic, Judith A. Stafford, Dorina C. Petriu, Jens Happe, and Paola Inverardi, editors, Boulder, Colorado, USA, 2011, pages 33-42. ACM, New York, NY, USA. 2011. [ bib | DOI | http | .pdf | Abstract ]
Designing software architectures that exhibit a good trade-off between multiple quality attributes is hard. Even with a given functional design, many degrees of freedom in the software architecture (e.g. component deployment or server configuration) span a large design space. In current practice, software architects try to find good solutions manually, which is time-consuming, can be error-prone and can lead to suboptimal designs. We propose an automated approach guided by architectural tactics to search the design space for good solutions. Our approach applies multi-objective evolutionary optimization to software architectures modelled with the Palladio Component Model. Software architects can then make well-informed trade-off decisions and choose the best architecture for their situation. To validate our approach, we applied it to the architecture models of two systems, a business reporting system and an industrial control system from ABB. The approach was able to find meaningful trade-offs leading to significant performance improvements or costs savings. The novel use of tactics decreased the time needed to find good solutions by up to 80%.
[44] Anne Koziolek, Qais Noorshams, and Ralf Reussner. Focussing multi-objective software architecture optimization using quality of service bounds. In Models in Software Engineering, Workshops and Symposia at MODELS 2010, Oslo, Norway, October 3-8, 2010, Reports and Revised Selected Papers, J. Dingel and A. Solberg, editors, 2011, volume 6627 of Lecture Notes in Computer Science, pages 384-399. Springer-Verlag Berlin Heidelberg. 2011. [ bib | DOI | http | .pdf | Abstract ]
Quantitative prediction of non-functional properties, such as performance, reliability, and costs, of software architectures supports systematic software engineering. Even though there usually is a rough idea on bounds for quality of service, the exact required values may be unclear and subject to trade-offs. Designing architectures that exhibit such good trade-off between multiple quality attributes is hard. Even with a given functional design, many degrees of freedom in the software architecture (e.g. component deployment or server configuration) span a large design space. Automated approaches search the design space with multi-objective metaheuristics such as evolutionary algorithms. However, as quality prediction for a single architecture is computationally expensive, these approaches are time consuming. In this work, we enhance an automated improvement approach to take into account bounds for quality of service in order to focus the search on interesting regions of the objective space, while still allowing trade-offs after the search. We compare two different constraint handling techniques to consider the bounds. To validate our approach, we applied both techniques to an architecture model of a component-based business information system. We compared both techniques to an unbounded search in 4 scenarios. Every scenario was examined with 10 optimization runs, each investigating around 1600 architectural candidates. The results indicate that the integration of quality of service bounds during the optimization process can improve the quality of the solutions found, however, the effect depends on the scenario, i.e. the problem and the quality requirements. The best results were achieved for costs requirements: The approach was able to decrease the time needed to find good solutions in the interesting regions of the objective space by 25% on average.
[45] Anne Koziolek and Ralf Reussner. Towards a generic quality optimisation framework for component-based system models. In Proceedings of the 14th international ACM Sigsoft symposium on Component based software engineering, Ivica Crnkovic, Judith A. Stafford, Antonia Bertolino, and Kendra M. L. Cooper, editors, Boulder, Colorado, USA, 2011, CBSE '11, pages 103-108. ACM, New York, NY, USA, New York, NY, USA. 2011. [ bib | DOI | http | .pdf | Abstract ]
Designing component-based systems (CBS) that exhibit a good trade-off between multiple quality criteria is hard. Even after functional design, many remaining degrees of freedom of different types (e.g. component allocation, component selection, server configuration) in the CBS span a large, discontinuous design space. Automated approaches have been proposed to optimise CBS models, but they only consider a limited set of degrees of freedom, e.g. they only optimise the selection of components without considering the allocation, or vice versa. We propose a flexible and extensible formulation of the design space for optimising any CBS model for a number of quality properties and an arbitrary number of degrees of freedom. With this design space formulation, a generic quality optimisation framework that is independent of the used CBS metamodel can apply multi-objective metaheuristic optimisation such as evolutionary algorithms.
[46] Michael Kuperberg, Martin Krogmann, and Ralf Reussner. Metric-based Selection of Timer Methods for Accurate Measurements. In Proceedings of the 2nd ACM/SPEC International Conference on Performance Engineering, Karlsruhe, Germany, 2011, ICPE '11, pages 151-156. ACM, New York, NY, USA. 2011. [ bib | DOI | http | .pdf | Abstract ]
Performance measurements are often concerned with accurate recording of timing values, which requires timer methods of high quality. Evaluating the quality of a given timer method or performance counter involves analysing several properties, such as accuracy, invocation cost and timer stability. These properties are metrics with platform-dependent values, and ranking and selecting timer methods requires comparisons using multidimensional metric sets, which make the comparisons ambiguous and unnecessary complex. To solve this problem, this paper proposes a new unified metric that allows for a simpler comparison. The one-dimensional metric is designed to capture fine-granular differences between timer methods, and normalises accuracy and other quality attributes by using CPU cycles instead of time units. The proposed metric is evaluated on all timer methods provided by Java and .NET platform APIs.
[47] Michael Kuperberg and Ralf Reussner. Analysing the Fidelity of Measurements Performed With Hardware Performance Counters. In Proceedings of the International Conference on Software Engineering 2011 (ICPE'11), March 14-16, 2011, Karlsruhe, Germany, 2011. [ bib | .pdf | Abstract ]
Performance evaluation requires accurate and dependable measurements of timing values. Such measurements are usually made using timer methods, but these methods are often too coarse-grained and too inaccurate. Thus, direct usage of hardware performance counters is frequently used for fine-granular measurements due to higher accuracy. However, direct access to these counters may be misleading on multicore computers because cores can be paused or core affinity changed by the operating system, resulting in misleading counter values. The contribution of this paper is the demonstration of an additional, significant flaw arising from the direct use of hardware performance counters. We demonstrate that using JNI and assembler instructions to access the Timestamp Counter from Java applications can result in grossly wrong values, even in single-threaded scenarios.
[48] Samuel Kounev, Fabian Brosig, Nikolaus Huber, and Ralf Reussner. Towards self-aware performance and resource management in modern service-oriented systems. In Proceedings of the 7th IEEE International Conference on Services Computing (SCC 2010), July 5-10, Miami, Florida, USA, Miami, Florida, USA, July 5-10, 2010. IEEE Computer Society. July 2010. [ bib | .pdf | Abstract ]
Modern service-oriented systems have increasingly complex loosely-coupled architectures that often exhibit poor performance and resource efficiency and have high operating costs. This is due to the inability to predict at run-time the effect of dynamic changes in the system environment (e.g., varying service workloads) and adapt the system configuration accordingly. In this paper, we describe a long-term vision and approach for designing systems with built-in self-aware performance and resource management capabilities. We advocate the use of architecture-level performance models extracted dynamically from the evolving system configuration and maintained automatically during operation. The models will be exploited at run-time to adapt the system to changes in the environment ensuring that resources are utilized efficiently and performance requirements are continuously satisfied.
[49] Nikolaus Huber, Steffen Becker, Christoph Rathfelder, Jochen Schweflinghaus, and Ralf Reussner. Performance Modeling in Industry: A Case Study on Storage Virtualization. In ACM/IEEE 32nd International Conference on Software Engineering (ICSE 2010), Software Engineering in Practice Track, Cape Town, South Africa, May 2-8, 2010, pages 1-10. ACM, New York, NY, USA. May 2010, Acceptance Rate (Full Paper): 23% (16/71). [ bib | DOI | slides | .pdf | Abstract ]
In software engineering, performance and the integration of performance analysis methodologies gain increasing importance, especially for complex systems. Well-developed methods and tools can predict non-functional performance properties like response time or resource utilization in early design stages, thus promising time and cost savings. However, as performance modeling and performance prediction is still a young research area, the methods are not yet well-established and in wide-spread industrial use. This work is a case study of the applicability of the Palladio Component Model as a performance prediction method in an industrial environment. We model and analyze different design alternatives for storage virtualization on an IBM (Trademark of IBM in USA and/or other countries) system. The model calibration, validation and evaluation is based on data measured on a System z9 (Trademark of IBM in USA and/or other countries) as a proof of concept. The results show that performance predictions can identify performance bottlenecks and evaluate design alternatives in early stages of system development. The experiences gained were that performance modeling helps to understand and analyze a system. Hence, this case study substantiates that performance modeling is applicable in industry and a valuable method for evaluating design decisions.
[50] Franz Brosch, Heiko Koziolek, Barbora Buhnova, and Ralf Reussner. Parameterized Reliability Prediction for Component-based Software Architectures. In International Conference on the Quality of Software Architectures (QoSA), 2010, volume 6093 of LNCS, pages 36-51. Springer. 2010. [ bib | DOI | .pdf | Abstract ]
Critical properties of software systems, such as reliability, should be considered early in the development, when they can govern crucial architectural design decisions. A number of design-time reliability-analysis methods has been developed to support this task. However, the methods are often based on very low-level formalisms, and the connection to different architectural aspects (e.g., the system usage profile) is either hidden in the constructs of a formal model (e.g., transition probabilities of a Markov chain), or even neglected (e.g., resource availability). This strongly limits the applicability of the methods to effectively support architectural design. Our approach, based on the Palladio Component Model (PCM), integrates the reliability-relevant architectural aspects in a highly parameterized UML-like model, which allows for transparent evaluation of architectural design options. It covers the propagation of the system usage profile throughout the architecture, and the impact of the execution environment, which are neglected in most of the existing approaches. Before analysis, the model is automatically transformed into a formal Markov model in order to support effective analytical techniques to be employed. The approach has been validated against a reliability simulation of a distributed Business Reporting System.
[51] Vittorio Cortellessa, Anne Martens, Ralf Reussner, and Catia Trubiani. A process to effectively identify guilty performance antipatterns. In Fundamental Approaches to Software Engineering, 13th International Conference, FASE 2010, David Rosenblum and Gabriele Taentzer, editors, Paphos, Cyprus, 2010, pages 368-382. Springer-Verlag Berlin Heidelberg. 2010. [ bib | DOI | http | .pdf | Abstract ]
The problem of interpreting the results of software performance analysis is very critical. Software developers expect feedbacks in terms of architectural design alternatives (e.g., split a software component in two components and re-deploy one of them), whereas the results of performance analysis are either pure numbers (e.g. mean values) or functions (e.g. probability distributions). Support to the interpretation of such results that helps to fill the gap between numbers/functions and software alternatives is still lacking. Performance antipatterns can play a key role in the search of performance problems and in the formulation of their solutions. In this paper we tackle the problem of identifying, among a set of detected performance antipatterns, the ones that are the real causes of problems (i.e. the guilty ones). To this goal we introduce a process to elaborate the performance analysis results and to score performance requirements, model entities and performance antipatterns. The cross observation of such scores allows to classify the level of guiltiness of each antipattern. An example modeled in Palladio is provided to demonstrate the validity of our approach by comparing the performance improvements obtained after removal of differently scored antipatterns.
[52] Jens Happe, Henning Groenda, Michael Hauck, and Ralf H. Reussner. A Prediction Model for Software Performance in Symmetric Multiprocessing Environments. In Proceedings of the 2010 7th International Conference on the Quantitative Evaluation of Systems, 2010, QEST '10, pages 59-68. IEEE Computer Society, Washington, DC, USA. 2010. [ bib | DOI | http | .pdf | Abstract ]
The broad introduction of multi-core processors made symmetric multiprocessing (SMP) environments mainstream. The additional cores can significantly increase software performance. However, their actual benefit depends on the operating system scheduler's capabilities, the system's workload, and the software's degree of concurrency. The load distribution on the available processors (or cores) strongly influences response times and throughput of software applications. Hence, understanding the operating system scheduler's influence on performance and scalability is essential for the accurate prediction of software performance (response time, throughput, and resource utilisation). Existing prediction approaches tend to approximate the influence of operating system schedulers by abstract policies such as processor sharing and its more sophisticated extensions. However, these abstractions often fail to accurately capture software performance in SMP environments. In this paper, we present a performance Model for general-purpose Operating System Schedulers (MOSS). It allows analyses of software performance taking the influences of schedulers in SMP environments into account. The model is defined in terms of timed Coloured Petri Nets and predicts the effect of different operating system schedulers (e.g., Windows 7, Vista, Server 2003, and Linux 2.6) on software performance. We validated the prediction accuracy of MOSS in a case study using a business information system. In our experiments, the deviation of predictions and measurements was below 10% in most cases and did not exceed 30%.
[53] Michael Hauck, Jens Happe, and Ralf H. Reussner. Automatic Derivation of Performance Prediction Models for Load-balancing Properties Based on Goal-oriented Measurements. In Proceedings of the 18th IEEE International Symposium on Modeling, Analysis and Simulation of Computer and Telecommunication Systems (MASCOTS'10), 2010, pages 361-369. IEEE Computer Society. 2010. [ bib | DOI | http | Abstract ]
In symmetric multiprocessing environments, the performance of a software system heavily depends on the application's parallelism, the scheduling and load-balancing policies of the operating system, and the infrastructure it is running on. The scheduling of tasks can influence the response time of an application by several orders of magnitude. Thus, detailed models of the operating system scheduler are essential for accurate performance predictions. However, building such models for schedulers and including them into performance prediction models involves a lot of effort. For this reason, simplified scheduler models are used for the performance evaluation of business information systems in general. In this work, we present an approach to derive load-balancing properties of general-purpose operating system (GPOS) schedulers automatically. Our approach uses goal-oriented measurements to derive performance models based on observations. Furthermore, the derived performance model is plugged into the Palladio Component Model (PCM), a model-based performance prediction approach. We validated the applicability of the approach and its prediction accuracy in a case study on different operating systems.
[54] Lucia Kapova, Thomas Goldschmidt, Jens Happe, and Ralf H. Reussner. Domain-specific templates for refinement transformations. In MDI '10: Proceedings of the First International Workshop on Model-Drive Interoperability, Oslo, Norway, 2010, pages 69-78. ACM, New York, NY, USA. 2010. [ bib | DOI ]
[55] Lucia Kapova and Ralf Reussner. Application of advanced model-driven techniques in performance engineering. In Computer Performance Engineering, Alessandro Aldini, Marco Bernardo, Luciano Bononi, and Vittorio Cortellessa, editors, 2010, volume 6342 of Lecture Notes in Computer Science, pages 17-36. Springer Berlin / Heidelberg. 2010, 10.1007/978-3-642-15784-4_2. [ bib | http ]
[56] Lucia Kapova, Barbora Zimmerova, Anne Martens, Jens Happe, and Ralf H. Reussner. State dependence in performance evaluation of component-based software systems. In Proceedings of the 1st Joint WOSP/SIPEW International Conference on Performance Engineering (WOSP/SIPEW '10), San Jose, California, USA, 2010, pages 37-48. ACM, New York, NY, USA. 2010. [ bib | DOI | .pdf | Abstract ]
Performance prediction and measurement approaches for component-based software systems help software architects to evaluate their systems based on component performance specifications created by component developers. Integrating classical performance models such as queueing networks, stochastic Petri nets, or stochastic process algebras, these approaches additionally exploit the benefits of component-based software engineering, such as reuse and division of work. Although researchers have proposed many approaches in this direction during the last decade, none of them has attained widespread industrial use. On this basis, we have conducted a comprehensive state-of-the-art survey of more than 20 of these approaches assessing their applicability. We classified the approaches according to the expressiveness of their component performance modelling languages. Our survey helps practitioners to select an appropriate approach and scientists to identify interesting topics for future research.
[57] Anne Martens, Danilo Ardagna, Heiko Koziolek, Raffaela Mirandola, and Ralf Reussner. A hybrid approach for multi-attribute QoS optimisation in component based software systems. In Research into Practice - Reality and Gaps (Proceedings of the 6th International Conference on the Quality of Software Architectures, QoSA 2010), George Heineman, Jan Kofron, and Frantisek Plasil, editors, 2010, volume 6093 of Lecture Notes in Computer Science, pages 84-101. Springer-Verlag Berlin Heidelberg. 2010. [ bib | DOI | .pdf | .pdf | Abstract ]
Multiple, often conflicting quality of service (QoS) requirements arise when evaluating design decisions and selecting design alternatives of complex component-based software systems. In this scenario, selecting a good solution with respect to a single quality attribute can lead to unacceptable results with respect to the other quality attributes. A promising way to deal with this problem is to exploit multi-objective optimization where the objectives represent different quality attributes. The aim of these techniques is to devise a set of solutions, each of which assures a trade-off between the conflicting qualities. To automate this task, this paper proposes a combined use of analytical optimization techniques and evolutionary algorithms to efficiently identify a significant set of design alternatives, from which an architecture that best fits the different quality objectives can be selected. The proposed approach can lead both to a reduction of development costs and to an improvement of the quality of the final system. We demonstrate the use of this approach on a simple case study.
[58] Anne Martens, Heiko Koziolek, Steffen Becker, and Ralf H. Reussner. Automatically improve software models for performance, reliability and cost using genetic algorithms. In Proceedings of the first joint WOSP/SIPEW international conference on Performance engineering, Alan Adamson, Andre B. Bondi, Carlos Juiz, and Mark S. Squillante, editors, San Jose, California, USA, 2010, WOSP/SIPEW '10, pages 105-116. ACM, New York, NY, USA. 2010. [ bib | DOI | slides | http | .pdf | Abstract ]
Quantitative prediction of quality properties (i.e. extra-functional properties such as performance, reliability, and cost) of software architectures during design supports a systematic software engineering approach. Designing architectures that exhibit a good trade-off between multiple quality criteria is hard, because even after a functional design has been created, many remaining degrees of freedom in the software architecture span a large, discontinuous design space. In current practice, software architects try to find solutions manually, which is time-consuming, can be error-prone and can lead to suboptimal designs. We propose an automated approach to search the design space for good solutions. Starting with a given initial architectural model, the approach iteratively modifies and evaluates architectural models. Our approach applies a multi-criteria genetic algorithm to software architectures modelled with the Palladio Component Model. It supports quantitative performance, reliability, and cost prediction and can be extended to other quantitative quality criteria of software architectures. We validate the applicability of our approach by applying it to an architecture model of a component-based business information system and analyse its quality criteria trade-offs by automatically investigating more than 1200 alternative design candidates.
[59] Qais Noorshams, Anne Martens, and Ralf Reussner. Using quality of service bounds for effective multi-objective software architecture optimization. In Proceedings of the 2nd International Workshop on the Quality of Service-Oriented Software Systems (QUASOSS '10), Oslo, Norway, October 4, 2010, 2010, pages 1:1-1:6. ACM, New York, NY, USA. 2010. [ bib | DOI | http | .pdf ]
[60] Jens Happe, Henning Groenda, and Ralf H. Reussner. Performance Evaluation of Scheduling Policies in Symmetric Multiprocessing Environments. In Proceedings of the 17th IEEE International Symposium on Modelling, Analysis and Simulation of Computer and Telecommunication Systems (MASCOTS'09), 2009. [ bib | .pdf | Abstract ]
The shift of hardware architecture towards parallel execution led to a broad usage of multi-core processors in desktop systems and in server systems. The benefit of additional processor cores for software performance depends on the software's parallelism as well as the operating system scheduler's capabilities. Especially, the load on the available processors (or cores) strongly influences response times and throughput of software applications. Hence, a sophisticated understanding of the mutual influence of software behaviour and operating system schedulers is essential for accurate performance evaluations. Multi-core systems pose new challenges for performance analysis and developers of operating systems. For example, an optimal scheduling policy for multi-server systems, such as shortest remaining processing time (SRPT) for single-server systems, is not yet known in queueing theory. In this paper, we present a detailed experimental evaluation of general purpose operating system (GPOS) schedulers in symmetric multiprocessing (SMP) environments. In particular, we are interested in the influence of multiprocessor load balancing on software performance. Additionally, the evaluation includes effects of GPOS schedulers that can also occur in single-processor environments, such as I/Oboundedness of tasks and different prioritisation strategies. The results presented in this paper provide the basis for the future development of more accurate performance models of today's software systems.
[61] Michael Hauck, Michael Kuperberg, Klaus Krogmann, and Ralf Reussner. Modelling Layered Component Execution Environments for Performance Prediction. In Proceedings of the 12th International Symposium on Component Based Software Engineering (CBSE 2009), 2009, number 5582 in LNCS, pages 191-208. Springer. 2009. [ bib | DOI | .html | .pdf | Abstract ]
Software architects often use model-based techniques to analyse performance (e.g. response times), reliability and other extra-functional properties of software systems. These techniques operate on models of software architecture and execution environment, and are applied at design time for early evaluation of design alternatives, especially to avoid implementing systems with insufficient quality. Virtualisation (such as operating system hypervisors or virtual machines) and multiple layers in execution environments (e.g. RAID disk array controllers on top of hard disks) are becoming increasingly popular in reality and need to be reflected in the models of execution environments. However, current component meta-models do not support virtualisation and cannot model individual layers of execution environments. This means that the entire monolithic model must be recreated when different implementations of a layer must be compared to make a design decision, e.g. when comparing different Java Virtual Machines. In this paper, we present an extension of an established model-based performance prediction approach and associated tools which allow to model and predict state-of-the-art layered execution environments, such as disk arrays, virtual machines, and application servers. The evaluation of the presented approach shows its applicability and the resulting accuracy of the performance prediction while respecting the structure of the modelled resource environment.
[62] Michael Kuperberg, Martin Krogmann, and Ralf Reussner. TimerMeter: Quantifying Accuracy of Software Times for System Analysis. In Proceedings of the 6th International Conference on Quantitative Evaluation of SysTems (QEST) 2009, 2009. [ bib | .pdf ]
[63] Michael Kuperberg, Fouad Omri, and Ralf Reussner. Using Heuristics to Automate Parameter Generation for Benchmarking of Java Methods. In Proceedings of the 6th International Workshop on Formal Engineering approaches to Software Components and Architectures, York, UK, 28th March 2009 (ETAPS 2009, 12th European Joint Conferences on Theory and Practice of Software), 2009. [ bib | .pdf | Abstract ]
Automated generation of method parameters is needed in benchmarking scenarios where manual or random generation of parameters are not suitable, do not scale or are too costly. However, for a method to execute correctly, the generated input parameters must not violate implicit semantical constraints, such as ranges of numeric parameters or the maximum length of a collection. For most methods, such constraints have no formal documentation, and human-readable documentation of them is usually incomplete and ambiguous. Random search of appropriate parameter values is possible but extremely ineffective and does not pay respect to such implicit constraints. Also, the role of polymorphism and of the method invocation targets is often not taken into account. Most existing approaches that claim automation focus on a single method and ignore the structure of the surrounding APIs where those exist. In this paper, we present HEURIGENJ, a novel heuristics-based approach for automatically finding legal and appropriate method input parameters and invocation targets, by approximating the implicit constraints imposed on them. Our approach is designed to support systematic benchmarking of API methods written in the Java language. We evaluate the presented approach by applying it to two frequently-used packages of the Java platform API, and demonstrating its coverage and effectiveness.
[64] Anne Martens, Franz Brosch, and Ralf Reussner. Optimising multiple quality criteria of service-oriented software architectures. In Proceedings of the 1st international workshop on Quality of service-oriented software systems (QUASOSS), 2009, pages 25-32. ACM, New York, NY, USA. 2009. [ bib | DOI | .pdf | Abstract ]
Quantitative prediction of quality criteria (i.e. extra-functional properties such as performance, reliability, and cost) of service-oriented architectures supports a systematic software engineering approach. However, various degrees of freedom in building a software architecture span a large, discontinuous design space. Currently, solutions with a good trade-off between multiple quality criteria have to be found manually. We propose an automated approach to search the design space by modifying the architectural models, to improve the architecture with respect to multiple quality criteria, and to find optimal architectural models. The found optimal architectural models can be used as an input for trade-off analyses and thus allow systematic engineering of high-quality software architectures. Using this approach, the design of a high-quality component-based software system is eased for the software architect and thus saves cost and effort. Our approach applies a multi-criteria genetic algorithm to software architectures modelled with the Palladio Component Model (PCM). Currently, the method supports quantitative performance and reliability prediction, but it can be extended to other quality properties such as cost as well.
[65] Barbara Paech, Andreas Oberweis, and Ralf Reussner. Qualität von Geschäftsprozessen und Unternehmenssoftware - Eine Thesensammlung. In Software Engineering (Workshops), Jürgen Münch and Peter Liggesmeyer, editors, 2009, volume 150 of LNI, pages 223-228. GI. 2009. [ bib ]
[66] Johannes Stammel and Ralf Reussner. Kamp: Karlsruhe architectural maintainability prediction. In Proceedings of the 1. Workshop des GI-Arbeitskreises Langlebige Softwaresysteme (L2S2): "Design for Future - Langlebige Softwaresysteme", Gregor Engels, Ralf Reussner, Christof Momm, and Stefan Sauer, editors, 2009, pages 87-98. [ bib | http | Abstract ]
In their lifetime software systems usually need to be adapted in order to fit in a changing environment or to cover new required functionality. The effort necessary for implementing changes is related to the maintainability of the software system. Therefore, maintainability is an important quality aspect of software systems. Today Software Architecture plays an important role in achieving software quality goals. Therefore, it is useful to evaluate software architectures regarding their impact on the quality of the program. However, unlike other quality attributes, such as performance or reliability, there is relatively less work on the impact of the software architecture on maintainability in a quantitative manner. In particular, the cost of software evolution not only stems from software-development activities, such as reimplementation, but also from software management activities, such as re-deployment, upgrade installation, etc. Most metrics for software maintainability base on code of object-oriented designs, but not on architectures, and do not consider costs from software management activities. Likewise, existing current architectural maintainability evaluation techniques manually yield just qualitative (and often subjective) results and also do concentrate on software (re-)development costs. In this paper, we present KAMP, the Karlsruhe Architectural Maintainability Prediction Method, a quantitative approach to evaluate the maintainability of software architectures. Our approach estimates the costs of change requests for a given architecture and takes into account re-implementation costs as well as re-deployment and upgrade activities. We combine several strengths of existing approaches. First, our method evaluates maintainability for concrete change requests and makes use of explicit architecture models. Second, it estimates change efforts using semi-automatic derivation of work plans, bottom-up effort estimation, and guidance in investigation of estimation supports (e.g. design and code properties, team organization, development environment, and other influence factors).
[67] Heiko Koziolek, Steffen Becker, Jens Happe, and Ralf Reussner. Evaluating performance of software architecture models with the palladio component model. In Model-Driven Software Development: Integrating Quality Assurance, Jörg Rech and Christian Bunse, editors, December 2008, pages 95-118. IDEA Group Inc. December 2008. [ bib ]
[68] Christoph Rathfelder, Henning Groenda, and Ralf Reussner. Software Industrialization and Architecture Certification. In Industrialisierung des Software-Managements: Fachtagung des GI-Fachausschusses Management der Anwendungsentwicklung und -Wartung im Fachbereich Wirtschaftsinformatik (WI-MAW), Georg Herzwurm and Martin Mikusz, editors, volume 139 of Lecture Notes in Informatics (LNI), pages 169-180. November 2008. [ bib ]
[69] Heiko Koziolek, Steffen Becker, Jens Happe, and Ralf Reussner. Life-Cycle Aware Modelling of Software Components. In Proceedings of the 11th International Symposium on Component-Based Software Engineering (CBSE), October 2008, Lecture Notes in Computer Science, pages 278-285. Springer-Verlag Berlin Heidelberg, Universität Karlsruhe (TH), Karlsruhe, Germany. October 2008. [ bib | Abstract ]
Current software component models insufficiently reflect the different stages of component life-cycle, which involves design, implementation, deployment, and runtime. Therefore, reasoning techniques for component-based models (e.g., protocol checking, QoS predictions, etc.) are often limited to a particular life-cycle stage. We propose modelling software components in different design stages, after implemenatation, and during deployment. Abstract models for newly designed components can be combined with refined models for already implemented components. As a proof-of-concept, we have implemented the new modelling techniques as part of our Palladio Component Model (PCM).
[70] Michael Kuperberg, Klaus Krogmann, and Ralf Reussner. Performance Prediction for Black-Box Components using Reengineered Parametric Behaviour Models. In Proceedings of the 11th International Symposium on Component Based Software Engineering (CBSE 2008), Karlsruhe, Germany, 14th-17th October 2008, October 2008, volume 5282 of Lecture Notes in Computer Science, pages 48-63. Springer-Verlag Berlin Heidelberg. October 2008. [ bib | .pdf | Abstract ]
In component-based software engineering, the response time of an entire application is often predicted from the execution durations of individual component services. However, these execution durations are specific for an execution platform (i.e. its resources such as CPU) and for a usage profile. Reusing an existing component on different execution platforms up to now required repeated measurements of the concerned components for each relevant combination of execution platform and usage profile, leading to high effort. This paper presents a novel integrated approach that overcomes these limitations by reconstructing behaviour models with platform-independent resource demands of bytecode components. The reconstructed models are parameterised over input parameter values. Using platform-specific results of bytecode benchmarking, our approach is able to translate the platform-independent resource demands into predictions for execution durations on a certain platform. We validate our approach by predicting the performance of a file sharing application.
[71] Klaus Krogmann, Michael Kuperberg, and Ralf Reussner. Reverse Engineering of Parametric Behavioural Service Performance Models from Black-Box Components. In MDD, SOA und IT-Management (MSI 2008), Ulrike Steffens, Jan Stefan Addicks, and Niels Streekmann, editors, September 2008, pages 57-71. GITO Verlag, Oldenburg. September 2008. [ bib | .pdf | Abstract ]
Integrating heterogeneous software systems becomes increasingly important. It requires combining existing components to form new applications. Such new applications are required to satisfy non-functional properties, such as performance. Design-time performance prediction of new applications built from existing components helps to compare design decisions before actually implementing them to the full, avoiding costly prototype and glue code creation. But design-time performance prediction requires understanding and modeling of data flow and control flow accross component boundaries, which is not given for most black-box components. If, for example one component processes and forwards files to other components, this effect should be an explicit model parameter to correctly capture its performance impact. This impact should also be parameterised over data, but no reverse engineering approach exists to recover such dependencies. In this paper, we present an approach that allows reverse engineering of such behavioural models, which is applicable for blackbox components. By runtime monitoring and application of genetic programming, we recover functional dependencies in code, which then are expressed as parameterisation in the output model. We successfully validated our approach in a case study on a file sharing application, showing that all dependencies could correctly be reverse engineered from black-box components.
[72] Thomas Kappler, Heiko Koziolek, Klaus Krogmann, and Ralf H. Reussner. Towards Automatic Construction of Reusable Prediction Models for Component-Based Performance Engineering. In Software Engineering 2008, February 18-22 2008, volume 121 of Lecture Notes in Informatics, pages 140-154. Bonner Köllen Verlag, Munich, Germany. February 18-22 2008. [ bib | .pdf | Abstract ]
Performance predictions for software architectures can reveal performance bottlenecks and quantitatively support design decisions for different architectural alternatives. As software architects aim at reusing existing software components, their performance properties should be included into performance predictions without the need for manual modelling. However, most prediction approaches do not include automated support for modelling implemented components. Therefore, we propose a new reverse engineering approach, which generates Palladio performance models from Java code. In this paper, we focus on the static analysis of Java code, which we have implemented as an Eclipse plugin called Java2PCM. We evaluated our approach on a larger component-based software architecture, and show that a similar prediction accuracy can be achieved with generated models compared to completely manually specified ones.
[73] Steffen Becker, Mircea Trifu, and Ralf Reussner. Towards Supporting Evolution of Service Oriented Architectures through Quality Impact Prediction. In 1st International Workshop on Automated engineeRing of Autonomous and run-time evolving Systems (ARAMIS 2008), L'Aquila, Italy, 2008. [ bib ]
[74] Thomas Goldschmidt, Ralf Reussner, and Jochen Winzen. A Case Study Evaluation of Maintainability and Performance of Persistency Techniques. In ICSE '08: Proceedings of the 30th international conference on Software engineering, Leipzig, Germany, 2008, pages 401-410. ACM, New York, NY, USA. 2008. [ bib | .pdf | Abstract ]
Efforts for software evolution supersede any other part of the software life cycle. Technological decisions have a major impact on the maintainability, but are not well reflected by existing code or architecture based metrics. The way the persistency of object structures with relational databases is solved affects the maintainability of the overall system. Besides maintainability other quality attributes of the software are of interest, in particular performance metrics. However, a systematic evaluation of the benefits and drawback of different persistency frameworks is lacking. In this paper we systematically evaluate the maintainability and performance of different technological approaches for this mapping. The paper presents a testbed and an evaluation process with specifically designed metrics to evaluate persistency techniques regarding their maintainability and performance. In the second part we present and discuss the results of the case study.
[75] Jens Happe, Holger Friedrich, Steffen Becker, and Ralf H. Reussner. A Pattern-Based Performance Completion for Message-Oriented Middleware. In Proceedings of the 7th International Workshop on Software and Performance (WOSP '08), Princeton, NJ, USA, 2008, pages 165-176. ACM, New York, NY, USA. 2008. [ bib | Abstract ]
Details about the underlying Message-oriented Middleware (MOM) are essential for accurate performance predictions of software systems using message-based communication. The MOM's configuration and usage strongly influence its throughput, resource utilisation and timing behaviour. Prediction models need to reflect these effects and allow software architects to evaluate the performance influence of MOM configured for their needs. Performance completions [31, 32] provide the general concept to include low-level details of execution environments in abstract performance models. In this paper, we extend the Palladio Component Model (PCM) [4] by a performance completion for Message-oriented Middleware. With our extension to the model, software architects can specify and configure message-based communication using a language based on messaging patterns. For performance evaluation, a model-to-model transformation integrates the low-level details of a MOM into the high-level software architecture model. A case study based on the SPECjms2007 Benchmark [1] predicts the performance of message-based communication with an error less than 20 percent.
[76] Heiko Koziolek and Ralf Reussner. A Model Transformation from the Palladio Component Model to Layered Queueing Networks. In Performance Evaluation: Metrics, Models and Benchmarks, SIPEW 2008, 2008, volume 5119 of Lecture Notes in Computer Science, pages 58-78. Springer-Verlag Berlin Heidelberg. 2008. [ bib | .pdf | Abstract ]
For component-based performance engineering, software component developers individually create performance specifications of their components. Software architects compose these specifications to architectural models. This enables assessing the possible fulfilment of performance requirements without the need to purchase and deploy the component implementations. Many existing performance models do not support component-based performance engineering but offer efficient solvers. On the other hand, component-based performance engineering approaches often lack tool support. We present a model transformation combining the advanced component concepts of the Palladio Component Model (PCM) with the efficient performance solvers of Layered Queueing Networks (LQN). Joining the tool-set for PCM specifications with the tool-set for LQN solution is an important step to carry component-based performance engineering into industrial practice.We validate the correctness of the transformation by mapping the PCM model of a componentbased architecture to an LQN and conduct performance predictions.
[77] Michael Kuperberg, Martin Krogmann, and Ralf Reussner. ByCounter: Portable Runtime Counting of Bytecode Instructions and Method Invocations. In Proceedings of the 3rd International Workshop on Bytecode Semantics, Verification, Analysis and Transformation, Budapest, Hungary, 5th April 2008 (ETAPS 2008, 11th European Joint Conferences on Theory and Practice of Software), 2008. [ bib | .pdf | Abstract ]
For bytecode-based applications, runtime instruction counts can be used as a platform- independent application execution metric, and also can serve as the basis for bytecode-based performance prediction. However, different instruction types have different execution durations, so they must be counted separately, and method invocations should be identified and counted because of their substantial contribution to the total application performance. For Java bytecode, most JVMs and profilers do not provide such functionality at all, and existing bytecode analysis frameworks require expensive JVM instrumentation for instruction-level counting. In this paper, we present ByCounter, a lightweight approach for exact runtime counting of executed bytecode instructions and method invocations. ByCounter significantly reduces total counting costs by instrumenting only the application bytecode and not the JVM, and it can be used without modifications on any JVM. We evaluate the presented approach by successfully applying it to multiple Java applications on different JVMs, and discuss the runtime costs of applying ByCounter to these cases.
[78] Anne Martens, Steffen Becker, Heiko Koziolek, and Ralf Reussner. An empirical investigation of the applicability of a component-based performance prediction method. In Proceedings of the 5th European Performance Engineering Workshop (EPEW'08), Palma de Mallorca, Spain, N. Thomas and C. Juiz, editors, 2008, volume 5261 of Lecture Notes in Computer Science, pages 17-31. Springer-Verlag Berlin Heidelberg. 2008. [ bib | DOI | .pdf | Abstract ]
Component-based software performance engineering (CBSPE) methods shall enable software architects to assess the expected response times, throughputs, and resource utilization of their systems already during design. This avoids the violation of performance requirements. Existing approaches for CBSPE either lack tool support or rely on prototypical tools, who have only been applied by their authors. Therefore, industrial applicability of these methods is unknown. On this behalf, we have conducted a controlled experiment involving 19 computer science students, who analysed the performance of two component-based designs using our Palladio performance prediction approach, as an example for a CBSPE method. Our study is the first of its type in this area and shall help to mature CBSPE to industrial applicability. In this paper, we report on results concerning the prediction accuracy achieved by the students and list several lessons learned, which are also relevant for other methods than Palladio.
[79] Anne Martens, Steffen Becker, Heiko Koziolek, and Ralf Reussner. An empirical investigation of the effort of creating reusable models for performance prediction. In Proceedings of the 11th International Symposium on Component-Based Software Engineering (CBSE'08), Karlsruhe, Germany, 2008, volume 5282 of Lecture Notes in Computer Science, pages 16-31. Springer-Verlag Berlin Heidelberg. 2008. [ bib | DOI | .pdf | Abstract ]
Model-based performance prediction methods aim at evaluating the expected response time, throughput, and resource utilisation of a software system at design time, before implementation. Existing performance prediction methods use monolithic, throw-away prediction models or component-based, reusable prediction models. While it is intuitively clear that the development of reusable models requires more effort, the actual higher amount of effort has not been quantified or analysed systematically yet. To study the effort, we conducted a controlled experiment with 19 computer science students who predicted the performance of two example systems applying an established, monolithic method (Software Performance Engineering) as well as our own component-based method (Palladio). The results show that the effort of model creation with Palladio is approximately 1.25 times higher than with SPE in our experimental setting, with the resulting models having comparable prediction accuracy. Therefore, in some cases, the creation of reusable prediction models can already be justified, if they are reused at least once.
[80] Steffen Becker, Heiko Koziolek, and Ralf H. Reussner. Model-based Performance Prediction with the Palladio Component Model. In WOSP '07: Proceedings of the 6th International Workshop on Software and performance, Buenes Aires, Argentina, February 5-8 2007, pages 54-65. ACM, New York, NY, USA. February 5-8 2007. [ bib | DOI | .pdf | Abstract ]
One aim of component-based software engineering (CBSE) is to enable the prediction of extra-functional properties, such as performance and reliability, utilising a well-defined composition theory. Nowadays, such theories and their accompanying prediction methods are still in a maturation stage. Several factors influencing extra-functional properties need additional research to be understood. A special problem in CBSE stems from its specific development process: Software components should be specified and implemented independent from their later context to enable reuse. Thus, extra-functional properties of components need to be specified in a parametric way to take different influence factors like the hardware platform or the usage profile into account. In our approach, we use the Palladio Component Model (PCM) to specify component-based software architectures in a parametric way. This model offers direct support of the CBSE development process by dividing the model creation among the developer roles. In this paper, we present our model and a simulation tool based on it, which is capable of making performance predictions. Within a case study, we show that the resulting prediction accuracy can be sufficient to support the evaluation of architectural design decisions.
[81] T. Goldschmidt, J. Winzen, and R. Reussner. Evaluation of Maintainability of Model-driven Persistency Techniques. In IEEE CSMR 07 - Workshop on Model-Driven Software Evolution (MoDSE2007), 2007, pages 17-24. [ bib | .pdf | Abstract ]
Although the original OMG Model-Driven Architecture Approach is not concerned with software evolution, modeldriven techniques may be good candidates to ease software evolution. However, a systematic evaluation of the benefits and drawback of model-driven approaches compared to other approaches are lacking. Besides maintainability other quality attributes of the software are of interest, in particular performance metrics. One specific area where model driven approaches are established in the area of software evolution are the generation of adapters to persist modern object oriented business models with legacy software and databases. This paper presents a testbed and an evaluation process with specifically designed metrics to evaluate model-driven techniques regarding their maintainability and performancerouven against established persistency frameworks.
[82] Jens Happe, Heiko Koziolek, and Ralf H. Reussner. Parametric Performance Contracts for Software Components with Concurrent Behaviour. In Proceedings of the 3rd International Workshop on Formal Aspects of Component Software (FACS), Frank S. de Boer and Vladimir Mencl, editors, 2006, volume 182 of Electronic Notes in Theoretical Computer Science, pages 91-106. [ bib | .pdf | Abstract ]
Performance prediction methods for component-based software systems aim at supporting design decisions of software architects during early development stages. With the increased availability of multicore processors, possible performance gains by distributing threads and processes across multiple cores should be predictable by these methods. Many existing prediction approaches model concurrent behaviour insufficiently and yield inaccurate results due to hard underlying assumptions. In this paper, we present a formal performance prediction approach for component-based systems, which is parameterisable for the number of CPUs or CPU cores. It is able to predict the response time of component services for generally distributed execution times. An initial, simple case study shows that this approach can accurately predict response times of multithreaded software components in specific cases. However, it is limited if threads change the CPU during their execution, if the effect of processor cache thrashing is present, and if the memory bus is heavily used.
[83] Viktoria Firus, Heiko Koziolek, Steffen Becker, Ralf H. Reussner, and Wilhelm Hasselbring. Empirische Bewertung von Performanz-Vorhersageverfahren für Software-Architekturen. In Software Engineering 2005 Proceedings - Fachtagung des GI-Fachbereichs Softwaretechnik, Peter Liggesmeyer, Klaus Pohl, and Michael Goedicke, editors, 2005, volume 64 of GI-Edition Lecture Notes in Informatics, pages 55-66. [ bib | .pdf | Abstract ]
Die Architektur eines Software-Systems beeinflusst maßgeblich seine Qualit ätseigenschaften wie Performanz oder Zuverlässigkeit. Daher sind Architekturänderungen oft die einzige Möglichkeit, Mängel bei diesen Qualitätseigenschaften zu beheben. Je spa�ter diese A� nderungen an der Architektur wa�hrend des Software-Entwicklungsprozesses vorgenommen werden, desto teurer und riskanter sind sie. Aus diesem Grund ist eine frühzeitige Analyse verschiedener Architektur-Entwurfsalternativen bez üglich ihrer Auswirkungen auf Qualitätseigenschaften vorteilhaft. Dieser Artikel beschreibt die Evaluation dreier verschiedener Performanz-Vorhersageverfahren für Software-Architekturen hinsichtlich ihrer Eignung, korrekte Empfehlungen für frühzeitige Entwurfsentscheidungen zu geben. Zusätzlich sollen diese Vorhersageverfahren prüfen, ob extern vorgegebene Performanz-Anforderungen realisierbar sind. Die Performanz-Vorhersageverfahren � SPE�, � Capacity Planning� und � umlPSI� wurden empirisch durch 31 Teilnehmer untersucht, die eine Menge vorgegebener Alternativen beim Entwurf der Architektur eines Webservers zu bewerten hatten. Die Ergebnisse zeigen, dass Entwurfsalternativen mit allen Verfahren richtig bewertet wurden, sofern deutliche Auswirkungen auf die Performanz vorhanden waren. Ohne den Einsatz der Performanz-Vorhersageverfahren wurden häufiger weniger performante Entwurfsalternativen vorgeschlagen. Darüber hinaus konnte das Verfahren Capacity Planning die absoluten Werte bei den meisten Entwurfsalternativen relativ genau vorhersagen.
[84] Ralf Reussner, Jens Happe, and Annegreth Habel. Modelling Parametric Contracts and the State Space of Composite Components by Graph Grammars. In Fundamental Approaches to Software Engineering (FASE), 2005, volume 3442 of Lecture Notes in Computer Science, pages 80-95. Springer-Verlag Berlin Heidelberg. 2005. [ bib | .pdf | Abstract ]
Modeling the dependencies between provided and required services within a software component is necessary for several reasons, such as automated component adaptation and architectural dependency analysis. Parametric contracts for software components specify such dependencies and were successfully used for automated protocol adaptation and quality of service prediction. In this paper, a novel model for parametric contracts based on graph grammars is presented and a first definition of the compositionality of parametric contracts is given. Compared to the previously used finite state machine based formalism, the graph grammar formalism allows a more elegant formulation of parametric contract applications and considerably simpler implementations.
[85] Ralf H. Reussner, Steffen Becker, and Viktoria Firus. Component Composition with Parametric Contracts. In Tagungsband der Net.ObjectDays 2004, September 2004, pages 155-169. [ bib | .pdf | Abstract ]
We discuss compositionality in terms of (a) component interoperability and contractual use of components, (b) component adaptation and (c) prediction of properties of composite components. In particular, we present parametric component contracts as a framework treating the above mentioned facets of compositionality in a unified way. Parametric contracts compute component interfaces in dependency of context properties, such as available external services or the profile how the component will be used by its clients. Under well-specified conditions, parametric contracts yield interfaces offering interoperability to the component context (as they are component-specifically generated). Therefore, parametric contracts can be considered as adaptation mechanism, adapting a components provides- or requires-interface depending on connected components. If non-functional properties are specified in a component provides interface, parametric contracts compute these nonfunctional properties in dependency of the environment.
[86] Steffen Becker, Viktoria Firus, Simon Giesecke, Wilhelm Hasselbring, Sven Overhage, and Ralf H. Reussner. Towards a Generic Framework for Evaluating Component-Based Software Architectures. In Architekturen, Komponenten, Anwendungen - Proceedings zur 1. Verbundtagung Architekturen, Komponenten, Anwendungen (AKA 2004), Universität Augsburg, Klaus Turowski, editor, 2004, volume 57 of GI-Edition Lecture Notes in Informatics, pages 163-180. [ bib | .pdf | Abstract ]
Abstract: The evaluation of software architectures is crucial to ensure that the design of software systems meets the requirements. We present a generic methodical framework that enables the evaluation of component-based software architectures. It allows to determine system characteristics on the basis of the characteristics of its constituent components. Basic prerequisites are discussed and an overview of different architectural views is given, which can be utilised for the evaluation process. On this basis, we outline the general process of evaluating software architectures and provide a taxonomy of existing evaluation methods. To illustrate the evaluation of software architectures in practice, we present some of the methods in detail.
[87] Steffen Becker, Sven Overhage, and Ralf H. Reussner. Classifying Software Component Interoperability Errors to Support Component Adaption. In Proceedings of the 7th International Symposium on Component-Based Software Engineering (CBSE 2004), Edinburgh, UK, Ivica Crnkovic, Judith A. Stafford, Heinz W. Schmidt, and Kurt C. Wallnau, editors, 2004, volume 3054 of Lecture Notes in Computer Science, pages 68-83. Springer-Verlag Berlin Heidelberg. 2004. [ bib | http | Abstract ]
This paper discusses various classifications of component interoperability errors. These classifications aim at supporting the automation of component adaptation. The use of software components will only demonstrate beneficial, if the costs for component deployment (i.e., acquisition and composition) are considerably lower than those for custom component development. One of the main reasons for the moderate progress in component-based software engineering are the high costs for component deployment. These costs are mainly caused by adapting components to bridge interoperability errors between unfitting components. One way to lower the costs of component deployment is to support component adaptation by tools, i.e., for interoperability checks of (semi-)automated adaptor generation. This automation of component adaptation requires a deep understanding of component interoperability errors. In particular, one has to differentiate between different classes of interoperability errors, as different errors require different adaptors for resolving. Therefore, the presented classification of component interoperability errors supports the automation of component adaptation by aiding automated interoperability problem detection and semi-automated adaptor generation. The experience gained from already implemented solutions for a specific class of interoperability errors provides hints for the solution of similar problems of the same class.
[88] Steffen Becker and Ralf H. Reussner. The Impact of Software Component Adaptors on Quality of Service Properties. In Proceedings of the First International Workshop on Coordination and Adaptation Techniques for Software Entities (WCAT 04), Carlos Canal, Juan Manuel Murillo, and Pascal Poizat, editors, 2004. [ bib | .pdf | Abstract ]
Component adaptors often are used to bridge gaps between the functional requirements of a component and the functional specification of another one supposed to provide the needed services. As bridging functional mismatches is necessary, the use of adaptors is often unavoidable. This emphasises the relevance of a drawback of adaptor usage: The alteration of Quality of Service properties of the adapted component. That is especially nasty, if the original QoS properties of the component have been a major criteria for the choice of the respective component. Therefore, we give an overview of examples of the problem and highlight some approaches how to cope with it.
[89] W. Hasselbring, Ralf H. Reussner, H. Jaekel, J. Schlegelmilch, T. Teschke, and S. Krieghoff. The Dublo Architecture Pattern for Smooth Migration of Business Information Systems: An Experience Report. In ICSE '04: Proceedings of the 26th International Conference on Software Engineering, 2004, pages 117-126. IEEE Computer Society, Washington, DC, USA. 2004. [ bib | http | Abstract ]
While the importance of multi-tier architectures for enterpriseinformation systems is widely accepted and theirbenefits are well published, the systematic migration frommonolithic legacy systems toward multi-tier architectures isknown to a much lesser extent. In this paper we present apattern on how to re-use elements of legacy systems withinmulti-tier architectures, which also allows for a smooth migrationpath. We report on experience we made with migratingexisting municipal information systems towards a multitierarchitecture. The experience is generalized by describingthe underlying pattern such that it can be re-used forsimilar architectural migration tasks. The emerged Dublopattern is based on the partial duplication of businesslogic among legacy system and newly deployed applicationserver. While this somehow contradicts the separation-of-concernsprinciple, it offers a high degree of flexibility inthe migration process and allows for a smooth transition.Experience with the combination of outdated databasetechnology with modern server-side component and webservices technologies is discussed. In this context, we alsoreport on technology and architecture selection processes.
[90] Jürgen Meister, Ralf H. Reussner, and Martin Rhode. Applying Patterns to Develop a Product Line Architecture for Statistical Analysis Software. In Proceedings of the Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 4), 2004. IEEE/IFIP. 2004. [ bib ]
[91] Jürgen Meister, Ralf H. Reussner, and Martin Rhode. Managing Product Line Variability by Patterns. In Proceedings of the 5th Annual International Conference on Object-Oriented and Internet-based Technologies, Concepts, and Applications for a Networked World (Net.Objectdays 2004), 2004, Lecture Notes in Computer Science. Springer-Verlag Berlin Heidelberg. 2004. [ bib ]
[92] Ralf H. Reussner, Viktoria Firus, and Steffen Becker. Parametric Performance Contracts for Software Components and their Compositionality. In Proceedings of the 9th International Workshop on Component-Oriented Programming (WCOP 04), Wolfgang Weck, Jan Bosch, and Clemens Szyperski, editors, 2004. [ bib | .pdf | Abstract ]
The performance of a software component heavily depends on the environment of the component. As a software component only justifies its investment when deployed in several environments, one can not specify the performance of a component as a constant (e.g., as a single value or distribution of values in its interface). Hence, classical component contracts allowing to state the component�s performance as a post-condition, if the environment realises a specific performance stated in the precondition, do not help. This fixed pair of pre- and postcondition do not model that a component can have very different performance figures depending on its context. Instead of that, parametric contracts are needed for specifying the environmental dependency of the component�s provided performance. In this paper we discuss the specification of such dependencies for the performance metric response time. We model the statistical distribution of response time in dependency of the distribution of response times of environmental services.
[93] Jasminka Matevska-Meyer, Wilhelm Hasselbring, and Ralf H. Reussner. Exploiting Protocol Information for Speeding up Runtime Reconfiguration of Component-Based Systems. In Proceedings of the Eigth International Workshop on Component-Oriented Programming (WCOP'03), Wolfgang Weck, Jan Bosch, and Clemens Szyperski, editors, June 2003. [ bib | .pdf | Abstract ]
To reduce the down-time of software systems and maximise the set of available services during reconfiguration, we propose exploiting component protocol information. This is achieved by knowing the state of a running system and determining the component dependencies for the time interval from receiving a reconfiguration request until reconfiguration completion. For this forecast we use the architectural descriptions that specify static dependencies, as well as component protocol information. By considering only component interactions for the time interval of reconfiguration we can exclude past and future dependencies from our runtime dependency graphs. We show that such change-request-specific runtime dependency graphs may be considerably smaller than the corresponding static architecture based dependency graphs; this way, we are speeding up runtime reconfiguration of component-based systems while maximising the set of available services.
[94] Ralf H. Reussner. Contracts and Quality Attributes of Software Components. In Proceedings of the Eighth International Workshop on Component-Oriented Programming (WCOP'03), Wolfgang Weck, Jan Bosch, and Clemens Szyperski, editors, June 2003. [ bib ]
[95] Ralf H. Reussner, Iman H. Poernomo, and Heinz W. Schmidt. Contracts and Quality Attributes for Software Components. In Proceedings of the Eigth International Workshop on Component-Oriented Programming (WCOP'03), Wolfgang Weck, Jan Bosch, and Clemens Szyperski, editors, June 2003. [ bib | .pdf ]
[96] Steffen Becker, Ralf H. Reussner, and Viktoria Firus. Specifying Contractual Use, Protocols and Quality Attributes for Software Components. In Proceedings of the First International Workshop on Component Engineering Methodology, Klaus Turowski and Sven Overhage, editors, 2003. [ bib | .pdf | Abstract ]
We discuss the specification of signatures, protocols (behaviour) and quality of service within software component specification frameworks. In particular we focus on (a) contractually used components, (b) the specification of components with variable contracts and interfaces, and (c) of quality of service. Interface descriptions including these aspects allow powerful static interoperability checks. Unfortunately, the specification of constant component interfaces hinders the specification of quality attributes and impedes automated component adaptation. This is because, especially quality attributes heavily depend on the components context. To enable the specification of quality attributes, we demonstrate the inclusion of parameterised contracts within a component specification framework. These parameterised contracts compute adapted, context-dependent component interfaces (including protocols and quality attributes). This allows to take context dependencies into account while allowing powerful static interoperability checks.
[97] I. Poernomo, Ralf H. Reussner, and H. W. Schmidt. Architectural Configuration with EDOC and .NET Component Services. In Euromicro 2003, IEEE, Antalya - Turkey, September 3rd-5th, 2003, Gerhard Chroust, editor, 2003. [ bib ]
[98] Ralf H. Reussner, Iman H. Poernomo, and Heinz W. Schmidt. Reasoning on Software Architectures with Contractually Specified Components. In Component-Based Software Quality: Methods and Techniques, A. Cechich, M. Piattini, and A. Vallecillo, editors, volume 2693 of Lecture Notes in Computer Science, pages 287-325. Springer-Verlag Berlin Heidelberg, 2003. [ bib | Abstract ]
One of the motivations for specifying software architectures explicitly is the better prediction of system quality attributes. In this chapter we present an approach for determining the reliability of component-based software architectures. Our method is based on RADL (Rich Architecture Definition Language), an extension of DARWIN [16]. RADL places special emphasis on component interoperation and, in particular, on accounting for the effects of interoperation on system reliability. To achieve this, our methods use a notion of design-by-contract [19] for components, called parameterized contracts [26]. Our contracts involve finite state machines that allow software architects to define how a componentrsquos reliability will react to a deployment environment. We show how a system, built from contractually specified components, can be understood in terms of Markov models, facilitating system reliability analysis. We illustrate our approach with an e-commerce example and report about empirical measurements which confirm our analytical reliability prediction by means of monitoring in our reliability testbed.
[99] Ralf H. Reussner. Counter-Constraint Finite State Machines: A new Model for Resource-bounded Component Protocols. In Proceedings of the 29th Annual Conference in Current Trends in Theory and Practice of Informatics (SOFSEM 2002), Milovy, Tschechische Republik, Bill Grosky, Frantisek Plasil, and Ales Krenek, editors, November 2002, volume 2540 of Lecture Notes in Computer Science, pages 20-40. Springer-Verlag Berlin Heidelberg. November 2002. [ bib ]
[100] Iman H. Poernomo, Ralf H. Reussner, and Heinz W. Schmidt. Architectures of Enterprise Systems: Modelling Transactional Contexts. In Proceedings of the First IFIP/ACM Working Conference on Component Deployment (CD 2002), June 2002, volume 2370 of Lecture Notes in Computer Science, pages 233-243. Springer-Verlag Berlin Heidelberg. June 2002. [ bib ]
[101] Matthias Clauss, Elke Pulvermüller, Ralf H. Reussner, Andreas Speck, and Ragnhild van der Straeten. Model-based Software Reuse. In ECOOP '02 Reader, Lecture Notes in Computer Science. Springer-Verlag Berlin Heidelberg, 2002. [ bib | Abstract ]
In a model based software system, a set of business rules is scanned, and patterns are identified. The patterns are then compared, and similarities identified which indicate that software can be reused in the system. In one embodiment, identifiers of the rules are scanned. In another embodiment, usage patterns are used for designing a middle layer and generating code. In another embodiment of the invention, a data model is generated by capturing data from a user interface for a business document. Read more: http://www.faqs.org/patents/app/20090024980#ixzz0Wdx5gzQS
[102] Jane Christy Jayaputera, Iman H. Poernomo, Ralf H. Reussner, and Heinz W. Schmidt. Timed Probabilistic Reasoning on Component Based Architectures. In Proceedings of the Third australian workshop on computational logic (AWCL 2002), Canberra, Australia, December 2002 Australian National University, Harald Sondergaad, editor, 2002. [ bib ]
[103] Erik Kamsties, Antje von Knethen, and Ralf H. Reussner. A Controlled Experiment on the Understandability of Different Requirements Specifications Styles. In Proceedings of the Eighth International Workshop on Requirements Engineering: Foundation for Software Quality, 2002. [ bib | .pdf | Abstract ]
In this paper, we report on a controlled experiment, in which we compared two different requirements specification styles. Following the traditional black-box style, a system is described by its externally visible behavior, any design detail is omitted from the requirements. Following the white-box style, which was popularized by object-oriented analysis, a system is described by the behavior of its constituent entities, e.g., objects. In the experiment, we compared the understandability of two requirements specifications of the same system each written in a different style. The appropriate choice of a specification style depends on several factors including the project characteristics, the nature of the requirements at hand, and the intended readers. In this paper, we focus on the last factor, and investigate understandability from the viewpoint of a customer. The results of the experiment indicate that it is easier to understand black-box requirements specifications from a customer point of view. Questions about particular functions and particular behavior of the specified system were answered by the participants faster and more correct. This result suggests using the black-box specification style when communication with customers is important.
[104] Bernd J. Krämer, Ralf H. Reussner, and Heinz W. Schmidt. Predicting Properties of Component Based Software Architectures through Parameterised Contracts. In Monterey Workshop 2002 - Radical Innovations of Software and Systems Engineering, Venice, Italy, October 7-11, Martin Wirsing, editor, 2002, Lecture Notes in Computer Science. Springer-Verlag Berlin Heidelberg. 2002. [ bib ]
[105] Bernd J. Krämer, Heinz W. Schmidt, Iman H. Poernomo, and Ralf H. Reussner. Predictable COmponent Architectures Using Dependent Finite State Machines. In Radical Innovations of Software and Systems Engineering in the Future, 9th International Workshop, RISSEF 2002, Venice, Italy, October 7-11, 2002, Revised Papers, Martin Wirsing, Alexander Knapp, and Simonetta Balsamo, editors, 2002, pages 310-324. Springer-Verlag Berlin Heidelberg. 2002. [ bib ]
[106] Ralf H. Reussner, Iman H. Poernomo, and Heinz W. Schmidt. Using the TrustME Tool Suite for Automatic Component Protocol Adaptation. In Computational Science-ICCS 2002, Proc. of ICCS 2002, International Conference on Computational Science, Amsterdam, The Netherlands, 2002, P. Sloot, J. J. Dongarra, and C. J. K. Tan, editors, 2002, volume 2330 of Lecture Notes in Computer Science, pages 854-862. [ bib | Abstract ]
The deployment of component oriented software approaches gains increasing importance in the computational sciences. Not only the promised increase of reuse makes components attractive, but also the possibilities of integrating different stand-alone programs into a distributed application. Middleware platforms facilitate the development of distributed applications by providing services and infrastructure. Component developers can thus benefit from a common standard to shape components towards and application designers from using pre-fabricated software components and shared platform services. Although such platforms claim to achieve fast and flexible development of distributed systems, they fall short in key requirements to reliability and interoperability in loosely coupled distributed systems. For example, many interoperability errors remain undetected during development and the adaptation and integration of of third-party components still requires major effort and cost. Partly this problem can be alleviated by the use of formal approaches to automatic interoperability checks and component adaptation. Our Reliable Architecture Description Language (RADL) is aimed at precisely this problem. In this paper we present key aspects of RADL used to specify component-based, compositional views of distributed applications. RADL involves a rich component model, enabling protocol information to be contained in interfaces. We focus on protocol-based notions of interoperability and adaptation, important for the construction of distributed systems with loosely coupled components.
[107] Ralf H. Reussner and Heinz W. Schmidt. Using Parameterised Contracts to Predict Properties of Component Based Software Architectures. In Workshop On Component-Based Software Engineering (in association with 9th IEEE Conference and Workshops on Engineering of Computer-Based Systems), Lund, Sweden, 2002, Ivica Crnkovic, Stig Larsson, and Judith Stafford, editors, 2002. [ bib | .pdf ]
[108] Heinz W. Schmidt and Ralf H. Reussner. Generating Adapters for Concurrent Component Protocol Synchronisation. In Proceedings of the Fifth IFIP International Conference on Formal Methods for Open Object-Based Distributed Systems, 2002. [ bib | .pdf | Abstract ]
In general few components are reused as they are. Often, available components are incompatible with what is required. This necessitates component adaptations or the use of adapters between components. In this paper we develop algorithms for the synthesis of adapters, coercing incompatible components into meeting requirements. We concentrate on adapters for concurrent systems, where adapters are able to resolve synchronisation problems of concurrent components. A new interface model for components, which includes protocol information, allows us to generate these adapters semi-automatically.
[109] Heinz W. Schmidt and Ralf H. Reussner. Parameterised Contracts and Adaptor Synthesis. In Proceedings of the ICSE Workshop of Component Oriented Software Engineering (CBSE5), 2002. IEEE. 2002. [ bib ]
[110] Thomas Worsch, Ralf Reussner, and Werner Augustin. On Benchmarking Collective MPI Operations. In Proceedings of the 9th European PVM/MPI Users' Group Meeting on Recent Advances in Parallel Virtual Machine and Message Passing Interface, pages 271-279. Springer-Verlag Berlin Heidelberg, London, UK, 2002. [ bib ]
[111] Ralf H. Reussner. The Use of Parameterised Contracts for Architecting Systems with Software Components. In Proceedings of the Sixth International Workshop on Component-Oriented Programming (WCOP'01), Wolfgang Weck, Jan Bosch, and Clemens Szyperski, editors, June 2001. [ bib | .pdf ]
[112] Ralf H. Reussner. Adapting Components and Predicting Architectural Properties with Parameterised Contracts. In Tagungsband des Arbeitstreffens der GI Fachgruppen 2.1.4 und 2.1.9, Bad Honnef, Wolfgang Goerigk, editor, 2001, pages 33-43. [ bib | .pdf ]
[113] Ralf H. Reussner. Recent Advances in SKaMPI. In High Performance Computing in Science and Engineering 2000, E. Krause and W. Jäger, editors, Transactions of the High Performance Computing Center Stuttgart (HLRS), pages 520-530. Springer-Verlag Berlin Heidelberg, 2001. [ bib | .pdf ]
[114] Ralf H. Reussner. Enhanced Component Interfaces to Support Dynamic Adaption and Extension. In 34th Hawaiin International Conference on System Sciences, 2001. IEEE. 2001. [ bib | .pdf ]
[115] Ralf H. Reussner and Gunnar T. Hunzelmann. Achieving Performance Portability with SKaMPI for High-Performance MPI Programs. In Computational Science-ICCS 2001, Proc. of ICCS 2001, International Conference on Computational Science, Part II, Special Session on Tools and Environments for Parallel and Distributed Programming, San Francisco, CA, 2001, V. N. Alexandrov, J. J. Dongarra, B. A. Juliano, R. S. Renner, and C. J. K. Tan, editors, 2001, volume 2074 of Lecture Notes in Computer Science, pages 841-850. [ bib | .pdf | Abstract ]
Current development processes for parallel software often fail to deliver portable software. This is because these processes usually require a tedious tuning phase to deliver software of good performance. This tuning phase often is costly and results in machine specific tuned (i.e., less portable) software. Designing software for performance and portability in early stages of software design requires performance data for all targeted parallel hardware platforms. In this paper we present a publicly available database, which contains data necessary for software developers to design and implement portable and high performing MPI software.
[116] Ralf H. Reussner, Peter Sanders, and Jesper Larsson Träff. Multi-Platform Benchmarking of the MPI Communications Interface. In International Workshop on Performance-oriented Application Development for Distributed Architectures, 2001. [ bib | .pdf ]
[117] Ralf H. Reussner. An Enhanced Model for Component Interfaces to Support Automatic and Dynamic Adaption. In New Issues in Object Interoperability - Proceedings of the ECOOP' 2000 Workshop on Object Interoperability, J. Hernández, A. Vallecillo, and J. M. Troya, editors, June12-6 2000, pages 33-42. Published by Universidad de Extremadura Dpto. Informática. [ bib | .pdf | Abstract ]
This paper presents a new model of software component interfaces, using an extension of finite states machines to describe (a) the protocol to use a component�s offered services, and (b) the sequences of calls to the external services the component requires to fulfill its offered services. With this model we integrate information into the interface of a software component to: (a) Check whether a component will be used correctly in its environment during system integration (i.e., before the component is actually used). (b) Adapt the interface of a component which describes the component�s offered services, in case the environment does not offer all resources the component requires to offer all its services. In this case the adapted component still offers a subset of its services, to the contrary of todays component systems, which do not allow any integration in this case at all.
[118] Ralf H. Reussner, Jesper L. Träff, and Gunnar Hunzelmann. A Benchmark for MPI Derived Datatypes. In Recent advances in parallel virtual machine and message passing interface: 7th European PVM/MPI Users' Group Meeting, Balatonfüred, Hungary, September 10-13, 2000, J. J. Dongarra, P. Kacsuk, and N. Podhorszki, editors, 2000, volume 1908 of Lecture Notes in Computer Science, pages 10-18. [ bib | http ]
[119] Dirk Heuzeroth and Ralf H. Reussner. Dynamic Coupling of Binary Components and its Technical Support. In First Workshop on Generative and Component based Software Engineering (GCSE) - Young Researchers Workshop, 1999. [ bib | .pdf | Abstract ]
The aim of todays software development is to build applications by the reuse of binary components. This requires the composition of components and as special cases component enhancement as well as adaption. We demonstrate how to deal with these cases by furnishing components with a type consisting of two protocols � a call and a use protocol. We model these protocols by finite automata and show how those reflect component enhancement and adaption. This mechanism allows for automatic adaption of components in changing environments. In order to obtain binary components we have to compile corresponding sources. In view of the required features of the binary components and with the problems of compiling generic classes in mind, we describe an approach to generate such pre-compiled components by appropriate compiler extensions.
[120] Dieter Kranzlmüller, Ralf H. Reussner, and Christian Schaubschläger. Monitor overhead measurement with SKaMPI. In Recent advances in parallel virtual machine and message passing interface: 6th European PVM/MPI Users' Group Meeting, Barcelona, Spain, September 26-29, 1999: proceedings, J. J. Dongarra, E. Luque, and Tomas Margalef, editors, 1999, volume 1697 of Lecture Notes in Computer Science, pages 43-50. [ bib | .pdf ]
[121] Ralf H. Reussner. Dynamic Types for Software Components. In Companion of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA '99), 1999. Extended abstract. [ bib | .pdf ]
[122] Ralf H. Reussner and Dirk Heuzeroth. A Meta-Protocol and Type system for the Dynamic Coupling of Binary Components. In Proceedings of the OOPSLA'99 Workshop on Object Oriented Reflection and Software Engineering, 1999. [ bib | .pdf | Abstract ]
1We introduce a new type system, where the type of a component consists of two protocols � a call and a use protocol. We model these protocols by finite automata and show how those reflect component enhancement and adaption. Coupling is controlled by a meta-protocol, which calls the adaption and enhancement algorithms. These algorithms require type information of the components involved. This type information is provided by the meta-protocol using reflection. This mechanism allows automatic adaption of components in changing environments.
[123] Antje von Knethen, Erik Kamsties, Ralf H. Reussner, Christian Bunse, and Bin Shen. A Comparative Case Study with Industrial Requirements Engineering Methods. In Proceedings of the 11th International Conference on Software Engineering and its Applications, 1998. [ bib | .pdf | Abstract ]
Numerous requirements engineering methods have been proposed to improve the quality of requirements documents as well as the developed software and to increase customer satisfaction with the final product. In this paper, we report on an explorative case study in the area of reactive systems with eight requirements engineering methods from a wide spectrum, namely, BSM, OCTOPUS, ROOM, SA/RT, SCR, SDL, UML (with OMT process), and Z. Our major finding is that the structuring mechanisms provided by a requirements engineering method, like hierarchies (e.g., ROOM) or views (e.g., UML), are directly related (1) to the number of problems found in the informal requirements during the creation of a requirements specification as well as (2) to the understandability of the final requirements specification.
[124] Ralf H. Reussner, Peter Sanders, Lutz Prechelt, and Matthias Müller. SKaMPI: A Detailed, Accurate MPI Benchmark. In Recent advances in parallel virtual machine and message passing interface: 5th European PVM/MPI Users' Group Meeting, Liverpool, UK, September 7-9, 1998, V. Alexandrov and J. J. Dongarra, editors, 1998, volume 1497 of Lecture Notes in Computer Science, pages 52-59. Springer-Verlag Berlin Heidelberg. 1998. [ bib | .pdf ]

Technical Reports

[1] Robert Heinrich, Kiana Rostami, and Ralf Reussner. The CoCoME platform for collaborative empirical research on information system evolution. Technical Report 2016,2; Karlsruhe Reports in Informatics, Karlsruhe Institute of Technology, February 2016. [ bib | http ]
[2] Robert Heinrich, Eric Schmieders, Reiner Jung, Wilhelm Hasselbring, Andreas Metzger, Klaus Pohl, and Ralf Reussner. Run-time architecture models for dynamic adaptation and evolution of cloud applications. Technical Report No. 1593, Kiel University, Kiel, Germany, April 2015. [ bib | http ]
[3] Wilhelm Hasselbring, Robert Heinrich, Reiner Jung, Andreas Metzger, Klaus Pohl, Ralf Reussner, and Eric Schmieders. iObserve: Integrated observation and modeling techniques to support adaptation and evolution of software systems. Technical Report No. 1309, Kiel University, Kiel, Germany, Oktober 2013. [ bib | http ]
[4] Michael Kuperberg, Nikolas Roman Herbst, Joakim Gunnarson von Kistowski, and Ralf Reussner. Defining and Quantifying Elasticity of Resources in Cloud Computing and Scalable Platforms. Technical report, Karlsruhe Institute of Technology (KIT), Am Fasanengarten 5, 76131 Karlsruhe, Germany, 2011. [ bib | http | .pdf | Abstract ]
Elasticity is the ability of a software system to dynamically scale the amount of the resources it provides to clients as their workloads increase or decrease. Elasticity is praised as a key advantage of cloud computing, where computing resources are dynamically added and released. However, there exists no concise or formal definition of elasticity, and thus no approaches to quantify it have been developed so far. Existing work on cloud computing is limited to the technical view of implementing elastic systems, and definitions or scalability have not been extended to cover elasticity. In this report, we present a detailed discussion of elasticity, propose techniques for quantifying and measuring it, and outline next steps to be taken for enabling comparisons between cloud computing offerings on the basis of elasticity. We also present preliminary work on measuring elasticity of resource pools provided by the Java Virtual Machine.
[5] Ralf Reussner, Steffen Becker, Erik Burger, Jens Happe, Michael Hauck, Anne Koziolek, Heiko Koziolek, Klaus Krogmann, and Michael Kuperberg. The Palladio Component Model. Technical report, KIT, Fakultät für Informatik, Karlsruhe, 2011. [ bib | http | Abstract ]
This report introduces the Palladio Component Model (PCM), a novel software component model for business information systems, which is specifically tuned to enable model-driven quality-of-service (QoS, i.e., performance and reliability) predictions. The PCMs goal is to assess the expected response times, throughput, and resource utilization of component-based software architectures during early development stages. This shall avoid costly redesigns, which might occur after a poorly designed architecture has been implemented. Software architects should be enabled to analyse different architectural design alternatives and to support their design decisions with quantitative results from performance or reliability analysis tools.
[6] Michael Hauck, Matthias Huber, Markus Klems, Samuel Kounev, Jörn Müller-Quade, Alexander Pretschner, Ralf Reussner, and Stefan Tai. Challenges and Opportunities of Cloud Computing - Trade-off Decisions in Cloud Computing Architecture. Technical Report 2010-19, Karlsruhe Institue of Technology, Faculty of Informatics, 2010. [ bib | http ]
[7] Franz Brosch, Henning Groenda, Lucia Kapova, Klaus Krogmann, Michael Kuperberg, Anne Martens, Pierre Parrend, Ralf Reussner, Johannes Stammel, and Emre Taspolatoglu. Software-industrialisierung. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, 2009. Interner Bericht. [ bib | http | Abstract ]
Die Industrialisierung der Software-Entwicklung ist ein zur Zeit sehr stark diskutiertes Thema. Es geht dabei vor allem um die Efizienzsteigerung durch die Steigerung des Standardisierungsgrades, des Automatisierungsgrades sowie eine Erhöhung der Arbeitsteilung. Dies wirkt sich einerseits auf die den Software- Systemen zu Grunde liegenden Architekturen, aber auch auf die Entwicklungsprozesse aus. So sind Service-orientierte Architekturen ein Beispiel für eine gesteigerte Standardisierung innerhalb von Software-Systemen. Es ist zu berücksichtigen, dass sich die Software-Branche von den klassischen produzierenden Industriezweigen dadurch unterscheidet, dass Software ein immaterielles Produkt ist und so ohne hohe Produktionskosten beliebig oft vervielfältigt werden kann. Trotzdem lassen sich viele Erkenntnisse aus den klassischen Industriezweigen auf die Software-Technik übertragen. Die Inhalte dieses Berichts stammen hauptsächlich aus dem Seminar " Software- Industrialisierung welches sich mit der Professionalisierung der Software- Entwi- cklung und des Software-Entwurfs beschäftigte. Während die klassische Software-Entwicklung wenig strukturiert ist und weder im Bezug auf Reproduzierbarkeit oder Qualitätssicherung erhöhten Anforderungen genügt, befindet sich die Software-Entwick- lung im Rahmen der Industrialisierung in einemWandel. Dazu zählen arbeitsteiliges Arbeiten, die Einführung von Entwicklungsprozessen mit vorhersagbaren Eigenschaften (Kosten, Zeitbedarf, ...), und in der Folge die Erstellung von Produkten mit garantierbaren Eigenschaften. Das Themenspektrum des Seminars umfasste dabei unter anderem: * Komponentenbasierte Software-Architekturen * Modellgetriebene Softwareentwicklung: Konzepte und Technologien * Industrielle Softwareentwicklungsprozesse und deren Bewertung Das Seminar wurde wie eine wissenschaftliche Konferenz organisiert: Die Einreichungen wurden in einem zweistufigen Peer-Review-Verfahren begutachtet. In der ersten Stufe wurde eine Begutachtung der studentischen Arbeiten durch Kommilitonen durchgeführt, in der zweiten Stufe eine Begutachtung durch die Betreuer. In verschiedenen Sessions wurden die Artikel wie bei einer Konferenz präsentiert. Die besten Beiträge wurden durch zwei Best Paper Awards ausgezeichnet. Diese gingen an Tom Beyer für seine Arbeit Realoptionen für Entscheidungen in der Software-Entwicklung, sowie an Philipp Meier für seine Arbeit Assessment Methods for Software Product Lines. Ergänzt wurden die Vorträge der Seminarteilnehmer durch zwei eingeladene Vorträge: Collin Rogowski von der 1&1 Internet AG stellte den agilen Softwareentwicklungsprozess beim Mail-Produkt GMX.COM vor. Heiko Koziolek, Wolfgang Mahnke und Michaela Saeftel von ABB referierten über das Thema Software Product Line Engineering anhand der bei ABB entwickelten Robotik-Applikationen.
[8] Franz Brosch, Thomas Goldschmidt, Henning Groenda, Lucia Kapova, Klaus Krogmann, Michael Kuperberg, Anne Martens, Christoph Rathfelder, Ralf Reussner, and Johannes Stammel. Software-industrialisierung. Interner bericht, Universität Karlsruhe, Fakultät für Informatik, Institut für Programmstrukturen und Datenorganisation, Karlsruhe, 2008. [ bib | http | Abstract ]
Die Industrialisierung der Software-Entwicklung ist ein zurzeit sehr stark diskutiertes Thema. Es geht dabei vor allem um die Efizienzsteigerung durch die Steigerung des Standardisierungsgrades, des Automatisierungsgrades sowie eine Erhöhung der Arbeitsteilung. Dies wirkt sich einerseits auf die den Software- Systemen zu Grunde liegenden Architekturen aber auch auf die Entwicklungsprozesse aus. So sind service-orientierte Architekturen ein Beispiel für eine gesteigerte Standardisierung innerhalb von Software-Systemen. Es ist zu berücksichtigen, dass sich die Software-Branche von den klassischen produzierenden Industriezweigen dadurch unterscheidet, dass Software ein immaterielles Produkt ist und so ohne hohe Produktionskosten beliebig oft vervielfältigt werden kann. Trotzdem lassen sich viele Erkenntnisse aus den klassischen Industriezweigen auf die Software-Technik übertragen. Die Inhalte dieses Berichts stammen hauptsächlich aus dem Seminar "Software- Industrialisierung welches sich mit der Professionalisierung der Software- Entwicklung und des Software-Entwurfs beschäftigte. Während die klassische Software-Entwicklung wenig strukturiert ist und weder im Bezug auf Reproduzierbarkeit oder Qualitätssicherung erhöhten Anforderungen genügt, befindet sich die Software-Entwicklung im Rahmen der Industrialisierung in einem Wandel. Dazu zählen arbeitsteiliges Arbeiten, die Einführung von Entwicklungsprozessen mit vorhersagbaren Eigenschaften (Kosten, Zeitbedarf, ...) und in der Folge die Erstellung von Produkten mit garantierbaren Eigenschaften. Das Themenspektrum des Seminars umfasste dabei unter anderem: * Software-Architekturen * Komponentenbasierte Software-Entwicklung * Modellgetriebene Entwicklung * Berücksichtigung von Qualitätseigenschaften in Entwicklungsprozessen Das Seminar wurde wie eine wissenschaftliche Konferenz organisiert: Die Einreichungen wurden in einem zweistufigen Peer-Review-Verfahren begutachtet. In der ersten Stufe wurde eine Begutachtung der studentischen Arbeiten durch Kommilitonen durchgeführt, in der zweiten Stufe eine Begutachtung durch die Betreuer. In verschiedenen Sessions wurden die Artikel an zwei Konferenztagen präsentiert. Der beste Beitrag wurde durch einen Best Paper Award ausgezeichnet. Dieser ging an Benjamin Klatt für seine Arbeit Software Extension Mechanisms, dem hiermit noch einmal herzlich zu dieser herausragenden Leistung gratuliert wird. Ergänzend zu den Vorträgen der Seminarteilnehmer wurde ein eingeladener Vortrag gehalten. Herr Florian Kaltner und Herr Tobias Pohl vom IBM-Entwicklungslabor gaben dabei dankenswerterweise in ihrem Vortrag Einblicke in die Entwicklung von Plugins für Eclipse sowie in die Build-Umgebung der Firmware für die zSeries Mainframe-Server.
[9] Wolfgang Weck, Ralf H. Reussner, and Clemens Szyperski. Component-Oriented Programming: Report on the 12th Workshop WCOP at ECOOP 2007. Technical Report Volume 4906/2008, University of Karlsruhe, 2008. [ bib | DOI | http | Abstract ]
This report covers the twelfth Workshop on Component-Oriented Programming (WCOP). WCOP has been affiliated with ECOOP since its inception in 1996. The report summarizes the contributions made by authors of accepted position papers as well as those made by all attendees of the workshop sessions.
[10] Steffen Becker, Tobias Dencker, Jens Happe, Heiko Koziolek, Klaus Krogmann, Martin Krogmann, Michael Kuperberg, Ralf Reussner, Martin Sygo, and Nikola Veber. Software-entwicklung mit eclipse. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, Germany, 2007. Interner Bericht. [ bib | http | Abstract ]
Die Entwicklung von Software mit Hilfe von Eclipse gehört heute zu den Standard-Aufgaben eines Software-Entwicklers. Die Artikel in diesem technischen Bericht beschäftigen sich mit den umfangreichen Möglichkeiten des Eclipse-Frameworks, die nicht zuletzt auf Grund zahlreicher Erweiterungsmöglichkeiten mittels Plugins möglich sind. Dieser technische Bericht entstand aus einem Proseminar im Wintersemester 2006/2007.
[11] Steffen Becker, Jens Happe, Heiko Koziolek, Klaus Krogmann, Michael Kuperberg, Ralf Reussner, Sebastian Reichelt, Erik Burger, Igor Goussev, and Dimitar Hodzhev. Software-komponentenmodelle. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, 2007. Interner Bericht. [ bib | http | Abstract ]
In der Welt der komponentenbasierten Software-Entwicklung werden Komponentenmodelle unter Anderem dazu eingesetzt, Software-Systeme mit vorhersagbaren Eigenschaften zu erstellen. Die Bandbreite reicht von Forschungs- bis zu Industrie-Modellen. In Abhängigkeit von den Zielen der Modelle werden unterschiedliche Aspekte von Software in ein Komponentenmodell abgebildet. In diesem technischen Bericht wird ein überblick über die heute verfügbaren Software-Komponentenmodelle vermittelt.
[12] Ralf H. Reussner, Steffen Becker, Heiko Koziolek, Jens Happe, Michael Kuperberg, and Klaus Krogmann. The Palladio Component Model. Interner Bericht 2007-21, Universität Karlsruhe (TH), 2007. October 2007. [ bib | .pdf ]
[13] Steffen Becker, Aleksander Dikanski, Nils Drechsel, Aboubakr Achraf El Ghazi, Jens Happe, Ihssane El-Oudghiri, Heiko Koziolek, Michael Kuperberg, Andreas Rentschler, Ralf H. Reussner, Roman Sinawski, Matthias Thoma, and Marko Willsch. Modellgetriebene Software-Entwicklung - Architekturen, Muster und Eclipse-basierte MDA. Technical report, Universität Karlsruhe (TH), 2006. [ bib | http | Abstract ]
Modellgetriebene Software-Entwicklung ist in den letzten Jahren insbesondere unter Schlagworten wie MDA und MDD zu einem Thema von allgemeinem Interesse für die Software-Branche geworden. Dabei ist ein Trend weg von der Code-zentrierten Software-Entwicklung hin zum (Architektur-) Modell im Mittelpunkt der Software- Entwicklung festzustellen. Modellgetriebene Software-Entwicklung verspricht eine stetige automatisierte Synchronisation von Software-Modellen verschiedenster Ebenen. Damit einher geht eine mögliche Verkürzung von Entwicklungszyklen und mehr Produktivität. Primär wird nicht mehr reiner Quellcode entwickelt, sondern Modelle und Transformationen übernehmen als eine höhere Abstraktionsebene die Rolle der Entwicklungssprache für Software-Produkte. Derweil ist eine Evolution von Werkzeugen zur modellgetriebenen Entwicklung festzustellen, die einen zusätzlichen Gewinn an Produktivität und Effizienz ermöglichen sollen. Waren die Werkzeuge zur Jahrtausendwende in ihrer Mächtigkeit noch stark eingeschränkt, weil die Transformationssprachen nur eine begrenzte Ausdrucksstärke besaßen und die verfügbaren Werkzeuge eine nur geringe Integration von modellgetriebenen Entwicklungsprozessen boten, so ist heute mit den Eclipse-basiertenWerkzeugen rund um EMF ein deutlicher Fortschritt spürbar. In der Eclipse-Plattform werden dabei als Plugins verschiedenste Aspekte der modellgetriebenen Entwicklung vereint: � Modellierungswerkzeuge zur Erstellung von Software-Architekturen � Frameworks für Software-Modelle � Erstellung und Bearbeitung von Transformationen � Durchführung von Transformationen � Entwicklung von Quellcode Der Seminartitel enthält eine Reihe von Schlagworten: �MDA, Architekturen, Muster, Eclipse�. Unter dem Dach von MDA ergeben sich zwischen diesen Schlagworten Zusammenhänge, die im Folgenden kurz skizziert werden. Software-Architekturen stellen eine allgemeine Form von Modell für Software dar. Sie sind weder auf eine Beschreibungssprache noch auf eine bestimmte Domänen beschränkt. Im Zuge der Bemühungen modellgetriebener Entwicklung lassen sich hier Entwicklungen hin zu Standard-Beschreibungssprachen wie UML aber auch die Einführung von domänen-spezifischen Sprachen (DSL) erkennen. Auf diesen weiter formalisierten Beschreibungen von Software lassen sich schließlich Transformationen anwenden. Diese können entweder zu einem weiteren Modell (�Model-to-Model�) oder einer textuellen Repräsentation (�Model-to-Text�) erfolgen. In beiden Fällen spielen Muster eine wichtige Rolle. Transformationen kapseln in gewisser Weise wiederholt anwendbares Entwurfs-Wissen (�Muster�) in parametrisierbaren Schablonen. Eclipse stellt schließlich eine freie Plattform dar, die in letzter Zeit zunehmend Unterstützung für modellgetriebene Entwicklung bietet. In die Bemühungen zur Unterstützung modellgetriebener Entwicklung fällt auch das im Mai 2006 angekündigte �Eclipse Modeling Project�, das als �top level project� auf die Evolution und Verbreitung modellgetriebener Entwicklungs-Technologien in Eclipse zielt. Das Seminar wurde wie eine wissenschaftliche Konferenz organisiert: Die Einreichungen wurden in einem peer-to-peer-Verfahren begutachtet (vor der Begutachtung durch den Betreuer) und in verschiedenen �Sessions� wurden die �Artikel� an zwei �Konferenztagen� präsentiert. Es gab �best paper awards� und einen eingeladenen Gastredner, Herrn Achim Baier von der itemis AG & Co KG, der dankenswerter Weise einen aufschlussreichen Einblick in Projekte mit modellgetriebener Entwicklung in der Praxis gab. Die �best paper awards� wurden an Herrn El-Ghazi und Herrn Rentschler verliehen, denen hiermit nochmal herzlich zu dieser herausragenden Leistung gedankt wird.
[14] Short Paper Proceedings of the Second International Conference on Quality of Software Architectures (QoSA2006), Västerås, Sweden, June 27 - 29, 2006, TR 2006-10, University of Karlsruhe (TH). Technical Report 2006-10, Universität Karlsruhe (TH), 2006. [ bib ]
[15] Ralf H. Reussner, Juliana Küster-Filipe, Iman H. Poernomo, and Sandeep Shukla. Report on the Workshop on Formal Foundations of Embedded Software and Component-based Software Architectures (FESCA). Technical report, 2004. [ bib ]
[16] Ralf H. Reussner. Counter-Constraint Finite State Machines: Modelling Component Protocols with Resource-Dependencies. Technical Report 2002/121, School for Computer Science and Software Engineering, Monash University, 2002. [ bib | Abstract ]
This paper deals with the specification of software component protocols (i. e., the set of service call sequences). The contribution of this paper is twofold: (a) We discuss specific requirements of realworld protocols, especially in the presence of components which make use of limited resources. (b) We define counter-constrained finite state machines, a novel extension of finite state machines, specifically created to model protocols containing dependencies between services due to their access to shared resources. Opposed to other approaches like classical finite state machines, this newmo del combines two valuable properties: (a) it is powerful enough to model realistic component protocols with resource allocation, -usage, and -deallocation dependencies between methods (as occurring in common abstract data-types such as stacks or queues) and (b) allows effcient checking of interoperability and substitutability.
[17] Ralf H. Reussner, Iman H. Poernomo, and John C. Grundy. Proceedings of the Fourth Australasian Workshop on Software and Systems Architectures. Technical report, 2002. [ bib ]
[18] Ralf H. Reussner. Formal Foundations of Dynamic Types for Software Components. Technical Report 08/2000, Department of Informatics, Universität Karlsruhe, 2000. [ bib | .pdf ]
[19] Heinz W. Schmidt and Ralf H. Reussner. Automatic Component Adaptation By Concurrent State Machine Retrofitting. Technical Report 25/2000, School of Computer Science and Software Engineering, Monash University, Melbourne, Australia, 2000. This report appeared simultaneously as Technical Report No. 2000/81 of the School of Computer Science and Software Engineering, Monash University, Melbourne, Australia. [ bib ]
[20] Ralf H. Reussner. SKaLib: SKaMPI as a library - Technical Reference Manual. Technical Report 07/99, University of Karlsruhe, 1999. [ bib | .pdf ]
[21] Ralf H. Reussner. SKaMPI: The Special Karlsruher MPI-Benchmark-User Manual. Technical Report 02/99, University of Karlsruhe, 1999. [ bib | .pdf ]
[22] Dieter Bär, Michael Schmidt, Ingo Redeke, Thomas Brückner, Ulrich Veigel, Ralf H. Reussner, and Lutz Prechelt. Experimentelle Methoden in der Informatik. Technical Report 38/1995, Department of Informatics, Universität Karlsruhe, 1995. [ bib | Abstract ]
Dieser Report enthaelt die Ausarbeitungen von Vortraegen aus einem Seminar gleichen Namens, das am 3./4. Juli 1995 am Institut f"ur Programmstrukturen und Datenorganisation unter Leitung von Walter Tichy, Ernst Heinz, Paul Lukowicz und Lutz Prechelt stattfand. Die Artikel geben einen Ueberblick ueber die moegliche Funktion und den Stellenwert experimentellen Vorgehens in verschiedenen Teilen der Informatik, sowie einerseits deren wissenschaftstheoretische Grundlage und andererseits ihre bisherige praktische Umsetzung.

Theses

[1] Ralf H. Reussner. Parametrisierte Verträge zur Protokolladaption bei Software-Komponenten. Phd. thesis, Department of Informatics, University of Karlsruhe, 2001. [ bib ]
[2] Ralf H. Reussner. Portable Leistungsmessung des Message Passing Interfaces. Masters thesis, Department of Informatics, University of Karlsruhe, 1997. [ bib | .pdf ]

Other

[1] Christian Stier, Anne Koziolek, Henning Groenda, and Ralf Reussner. Model-based analysis of energy efficiency for software architectures. Poster at the Symposium on Software Performance 2015, 2015. Best Poster Award. [ bib ]
[2] Ralf H. Reussner. Gefördert ab dem Ersten Semester: die Fakultät für Informatik am KIT bietet Stipendien für Begabte aus einkommensschwachen Familien, 2008. [ bib ]
[3] Ralf H. Reussner. The Working Group Software Architecture of the German Computer Science Society (GI-AK SoftArch)Report on the Workshop on Formal Foundations of Embedded Software and Component-based Software Architectures (FESCA). Newsletter of the European Association of Software Science and Technology (EASST), 2004. [ bib ]
[4] Ralf H. Reussner. Home Page of the Palladio Research Group. http://se.informatik.uni-oldenburg.de/research/current/Palladio , 20.12.2004, 2004. [ bib ]
[5] Ralf H. Reussner. The Role of the Software Architect: The Software Architecture Memorandum of the Sylter Runde. Newsletter of the European Association of Software Science and Technology (EASST), 2004. [ bib ]
[6] Ralf H. Reussner. Über die Simulation der Lotka-Volterra-Differentialgleichungen durch einen Zellularautomaten, 1996. [ bib | .pdf ]