Home | Sitemap | Index | Contact | Legals | KIT

Publications of Steffen Becker

Books/Book Chapters and edited Proceedings

[1] Lukas Esterle, Kirstie L. Bellman, Steffen Becker, Anne Koziolek, Christopher Landauer, and Peter Lewis. Assessing Self-awareness, pages 465-481. Springer International Publishing, Cham, 2017. [ bib | DOI | http ]
[2] 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. [ 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.
[3] 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 ]
[4] Achim Baier, Steffen Becker, Martin Jung, Klaus Krogmann, Carsten Röttgers, Niels Streekmann, Karsten Thoms, and Steffen Zschaler. Handbuch der Software-Architektur, chapter Modellgetriebene Software-Entwicklung, pages 93-122. dPunkt.verlag Heidelberg, 2 edition, December 2008. [ bib ]
[5] Steffen Becker. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Quality of Service Modeling Language, pages 43-47. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf | Abstract ]
This chapter gives an overview over the Quality of Service Modeling Language (QML), a language which can be used to describe QoS offerings or needs of specified services.
[6] Steffen Becker. Dependability Metrics, volume 4909 of Lecture Notes in Computer Science, chapter Performance-Related Metrics in the ISO 9126 Standard, pages 204-206. Springer-Verlag Berlin Heidelberg, 2008. [ bib | .pdf | Abstract ]
ISO 9126 [243, 244, 245] is a standard which can be used to describe the quality of software systems. It is based on a quality model that is illustrated in part one of the standard [243]. This model distinguishes quality attributes into internal and external attributes. Internal metrics depend on knowledge on the internal details of the respective software. External metrics can be measured without knowing internal details. Furthermore, the quality model introduces characteristics and sub-characteristicswhich are abstractions of the actual attributes.For example, Usability is an abstraction of Learnability,Understandability, and Operability which each itself again abstracts from the different attributes. The ISO 9126 standard has no characteristic Performance. The closest characteristic to our definition of performance is Efficiency. It is divided into two sub-characteristics: time behaviour and resource behaviour. Some people say this distinction is artificial as time is also a (rare) resource. Nevertheless, the timing behaviour is separated in ISO 9126. The important attributes of Efficiency in ISO 9126 are being described in the external metrics specification. Hence, the followin
[7] Steffen Becker. Coupled Model Transformations for QoS Enabled Component-Based Software Design, volume 1 of The Karlsruhe Series on Software Design and Quality. Universitätsverlag Karlsruhe, 2008. [ bib ]
[8] 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 ]

Refereed journal articles

[1] Fabian Brosig, Philipp Meier, Steffen Becker, Anne Koziolek, Heiko Koziolek, and Samuel Kounev. Quantitative evaluation of model-driven performance analysis and simulation of component-based architectures. Software Engineering, IEEE Transactions on, 41(2):157-175, Feb 2015. [ bib | DOI | Abstract ]
During the last decade, researchers have proposed a number of model transformations enabling performance predictions. These transformations map performance-annotated software architecture models into stochastic models solved by analytical means or by simulation. However, so far, a detailed quantitative evaluation of the accuracy and efficiency of different transformations is missing, making it hard to select an adequate transformation for a given context. This paper provides an in-depth comparison and quantitative evaluation of representative model transformations to, e.g., Queueing Petri Nets and Layered Queueing Networks. The semantic gaps between typical source model abstractions and the different analysis techniques are revealed. The accuracy and efficiency of each transformation are evaluated by considering four case studies representing systems of different size and complexity. The presented results and insights gained from the evaluation help software architects and performance engineers to select the appropriate transformation for a given context, thus significantly improving the usability of model transformations for performance prediction.
[2] Matthias Becker, Sebastian Lehrig, and Steffen Becker. Systematically deriving quality metrics for cloud computing systems. Proceedings of the 6th ACM/SPEC International Conference on Performance Engineering, ICPE, 15:169-174, 2015. [ bib ]
[3] Frank Brüseke, Henning Wachsmuth, Gregor Engels, and Steffen Becker. Pblaman: performance blame analysis based on palladio contracts. Concurrency and Computation: Practice and Experience, page to appear, 2014. [ bib | DOI | http ]
[4] Heiko Koziolek, Steffen Becker, Jens Happe, Petr Tuma, and Thijmen de Gooijer. Towards software performance engineering for multicore and manycore systems. SIGMETRICS Perform. Eval. Rev., 41(3):2-11, 2014, ACM, New York, NY, USA. [ bib | DOI | http ]
[5] 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 ]
[6] Sebastian Lehrig and Steffen Becker. Cloudscale - skalierbarkeit für die cloud. ForschungsForum Paderborn, 17:20-23, 2014. [ bib ]
[7] Markus von Detten, Marie Christin Platenius, and Steffen Becker. Reengineering Component-Based Software Systems with Archimetrix. Software and Systems Modeling, April 2013:1-30, 2013, Springer-Verlag. [ bib | DOI | http ]
[8] Steffen Becker, Stefan Sauer, Matthias Riebisch, and Bernhard Schätz. Modellbasierte und Modellgetriebene Softwaremodernisierung. Softwaretechnik-Trends, 32(2):1-2, 2012, Köllen Druck & Verlag GmbH. [ bib ]
[9] Benjamin Klatt and Steffen Becker. Architekturen 2012: Industrie und Wissenschaft treffen sich. OBJEKTspektrum, 6(6), 2012, Sigs Datacom. [ bib | http ]
[10] Heiko Koziolek, Bastian Schlich, Steffen Becker, and Michael Hauck. Performance and reliability prediction for evolving service-oriented software systems. Empirical Software Engineering, pages 1-45, 2012, Springer US. [ bib | DOI | http ]
[11] Heiko Koziolek, Steffen Becker, Jens Happe, and Paul Pettersson. Quality of service-oriented software systems (QUASOSS 2010). Models in Software Engineering, pages 364-368, 2011, Springer. [ bib ]
[12] 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%
[13] 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.
[14] Steffen Becker, Wilhelm Hasselbring, Alexandra Paul, Marko Boskovic, Heiko Koziolek, Jan Ploski, Abhishek Dhama, Henrik Lipskoch, Matthias Rohr, Daniel Winteler, Simon Giesecke, Roland Meyer, Mani Swaminathan, Jens Happe, Margarete Muhle, and Timo Warns. Trustworthy software systems: a discussion of basic concepts and terminology. SIGSOFT Softw. Eng. Notes, 31(6):1-18, 2006, ACM, New York, NY, USA. [ bib | DOI | .pdf | Abstract ]
Basic concepts and terminology for trustworthy software systems are discussed. Our discussion of definitions for terms in the domain of trustworthy software systems is based on former achievements in dependable, trustworthy and survivable systems. We base our discussion on the established literature and on approved standards. These concepts are discussed in the context of our graduate school TrustSoft on trustworthy software systems. In TrustSoft, we consider trustworthiness of software systems as determined by correctness, safety, quality of service (performance, reliability, availability), security, and privacy. Particular means to achieve trustworthiness of component-based software systems � as investigated in TrustSoft � are formal verification, quality prediction and certification; complemented by fault diagnosis and fault tolerance for increased robustness.
[15] 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.

Refereed conference/Workshop papers

[1] Sebastian Lehrig and Steffen Becker. Software architecture design assistants need controlled efficiency experiments: Lessons learned from a survey. In Proceedings of the 1st International Workshop on Future of Software Architecture Design Assistants, 2015, pages 19-24. ACM. [ bib ]
[2] Sebastian Lehrig, Hendrik Eikerling, and Steffen Becker. Scalability, elasticity, and efficiency in cloud computing: a systematic literature review of definitions and metrics. In Proceedings of the 11th International ACM SIGSOFT Conference on Quality of Software Architectures, 2015, pages 83-92. ACM. [ bib ]
[3] Sebastian Lehrig and Steffen Becker. Beyond simulation: Composing scalability, elasticity, and efficiency analyses from preexisting analysis results. In Proceedings of the 2015 Workshop on Challenges in Performance Methods for Software Development, 2015, pages 29-34. ACM. [ bib ]
[4] Sebastian Lehrig and Steffen Becker. The cloudscale method for software scalability, elasticity, and efficiency engineering: a tutorial. In Proceedings of the 6th ACM/SPEC International Conference on Performance Engineering, 2015, pages 329-331. ACM. [ bib ]
[5] Stefan Dziwok, Christopher Gerking, Steffen Becker, Sebastian Thiele, Christian Heinzemann, and Uwe Pohlmann. A tool suite for the model-driven software engineering of cyber-physical systems. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, 2014, pages 715-718. ACM. [ bib ]
[6] Matthias Becker, Marie Christin Platenius, and Steffen Becker. Cloud computing reduces uncertainties in quality-of-service matching! In Advances in Service-Oriented and Cloud Computing, pages 153-159. Springer International Publishing, 2014. [ bib ]
[7] Rebekka Wohlrab, Thijmen de Gooijer, Anne Koziolek, and Steffen Becker. Experience of pragmatically combining RE methods for performance requirements in industry. In Proceedings of the 22nd IEEE International Requirements Engineering Conference (RE), Aug 2014, pages 344-353. [ bib | DOI | .pdf | Abstract ]
To meet end-user performance expectations, precise performance requirements are needed during development and testing, e.g., to conduct detailed performance and load tests. However, in practice, several factors complicate performance requirements elicitation: lacking skills in performance requirements engineering, outdated or unavailable functional specifications and architecture models, the specification of the system's context, lack of experience to collect good performance requirements in an industrial setting with very limited time, etc. From the small set of available non-functional requirements engineering methods, no method exists that alone leads to precise and complete performance requirements with feasible effort and which has been reported to work in an industrial setting. In this paper, we present our experiences in combining existing requirements engineering methods into a performance requirements method called PROPRE. It has been designed to require no up-to-date system documentation and to be applicable with limited time and effort. We have successfully applied PROPRE in an industrial case study from the process automation domain. Our lessons learned show that the stakeholders gathered good performance requirements which now improve performance testing.
[8] Matthias Becker, Steffen Becker, Galina Besova, Sven Walther, and Heike Wehrheim. Towards systematic configuration for architecture validation. In Proceedings of the 40th Euromicro Conference on Software Engineering and Advanced Applications (Work in Progress Session), 2014. IEEE. 2014, to appear. [ bib ]
[9] Svetlana Arifulina, Marie Christin Platenius, Christian Gerth, Steffen Becker, Gregor Engels, and Wilhelm Schaefer. Market-optimized service specification and matching. In Proceedings of the 12th International Conference on Service Oriented Computing (ICSOC 2014), 2014. to appear. [ bib ]
[10] Marie Christin Platenius, Steffen Becker, and Wilhelm Schaefer. Integrating service matchers into a service market architecture. In Proceedings of the 8th European Conference on Software Architecture (ECSA 2014), 2014. [ bib ]
[11] Matthias Becker, Marie Christin Platenius, and Steffen Becker. Cloud computing reduces uncertainties in quality-of-service matching! In Proceedings to the 2nd International Workshop on Cloud Service Brokerage (CSB 2014), 2014. to appear. [ bib ]
[12] Steffen Becker, Stefan Dziwok, Christopher Gerking, Christian Heinzemann, Wilhelm Schäfer, Matthias Meyer, and Uwe Pohlmann. The mechatronicuml method: Model-driven software engineering of self-adaptive mechatronic systems. In Proceedings of the 36th International Conference on Software Engineering (Posters), 2014. ACM, New York, NY, USA. 2014, accepted. [ bib ]
[13] Stefan Dziwok, Christopher Gerking, Steffen Becker, Sebastian Thiele, Christian Heinzemann, and Uwe Pohlmann. A tool suite for the model-driven software engineering of cyber-physical systems. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE), 16 - 22  2014. Accepted. [ bib ]
[14] Stefan Dziwok, Sebastian Goschin, and Steffen Becker. Specifying intra-component dependencies for synthesizing component behaviors. In Proceedings of the 1st International Workshop on Model-Driven Engineering for Component-Based Software Systems (ModComp) 2014, 2014, pages 16-25. ACM/IEEE. 2014. [ bib ]
[15] Matthias Becker, Markus Luckey, and Steffen Becker. Performance analysis of self-adaptive systems for requirements validation at design-time. In Proceedings of the 9th ACM SigSoft International Conference on Quality of Software Architectures (QoSA'13), June 2013. ACM. June 2013. [ bib | Abstract ]
Self-adaptation allows continuously running software systems to operate in changing and uncertain contexts while meeting their requirements in a broad range of contexts, e.g., from low to high load situations. As a consequence, requirementsfor self-adaptive systems are more complex than requirements for static systems as they have to explicitly address properties of the self-adaptation layer.While approaches exist in the literature to capture this new type of requirements formally, their achievement cannot be analyzed in early design phases yet. In this paper, we apply RELAX to formally specify non-functional requirements for self-adaptive systems. We then apply our model-based SimuLizar approach for a semi-automatic analysis to test whether the self-adaptation layer ensures that these non-functional requirements are met. We evaluate our approach on the design of a proof-of-concept load balancer system. As this evaluation demonstrates, we can iteratively improve our system design by improving unsatisfactory self-adaption rules.
[16] Matthias Becker, Steffen Becker, and Joachim Meyer. SimuLizar: Design-Time Modelling and Performance Analysis of Self-Adaptive Systems. In Proceedings of Software Engineering 2013, Aachen, 2013, volume P-213 of Lecture Notes in Informatics (LNI), pages 71-84. Gesellschaft für Informatik e.V. (GI), Bonn, Germany. 2013. [ bib | .pdf ]
[17] Steffen Becker, Raffaela Mirandola, Lucia Happe, and Catia Trubiani. Towards a methodology driven by dependencies of quality attributes for QoS-based analysis. In Proceedings of the 4th Joint ACM/SPEC International Conference on Performance Engineering (ICPE '13), Work-In-Progress Track, Prague, Chech Repbulic, 2013. ACM, New York, NY, USA. 2013. [ bib ]
[18] Christian Heinzemann and Steffen Becker. Executing reconfigurations in hierarchical component architectures. In Proceedings of the 16th International ACM SigSoft Symposium on Component-Based Software Engineering (CBSE), 2013. ACM. 2013. [ bib ]
[19] Marie Christin Platenius, Markus von Detten, Steffen Becker, Wilhelm Schäfer, and Gregor Engels. A survey of fuzzy service matching approaches in the context of on-the-fly computing. In Proceedings of the 16th International ACM Sigsoft Symposium on Component-Based Software Engineering, 2013. ACM. 2013. [ bib | Abstract ]
In the last decades, development turned from monolithic software products towards more flexible software components that can be provided on world-wide markets in form of services. Customers request such services or compositions of several services. However, in many cases, discovering the best services to address a given request is a tough challenge and requires expressive, gradual matching results, considering di fferent aspects of a service description, e.g., inputs/ouputs, protocols, or quality properties. Furthermore,in situations in which no service exactly satifies the request, approximate matching which can deal with a certain amount of fuzziness becomes necessary. There is a wealth of service matching approaches, but it is not clear whether there is a comprehensive, fuzzy matching approach which addresses all these challenges. Although there are a few service matchingsurveys, none of them is able to answer this question. In this paper, we perform a systematic literature survey of 35 (outof 504) service matching approaches which consider fuzzy matching. Based on this survey, we propose a classi cation,discuss how diff erent matching approaches can be combined into a comprehensive matching method, and identify future research challenges.
[20] Jens Frieben, Henning Heutger, Matthias Meyer, and Steffen Becker. Modulare leistungsprognose von kompaktsteuerungen. In 9. Paderborner Workshop Entwurf mechatronischer Systeme, Jürgen Gausemeier, Roman Dumitrescu, Franz-Josef Rammig, Wilhelm Schäfer, and Ansgar Trächtler, editors, 2013, pages 147-160. HNI Verlagsschriftenreihe, Paderborn, Paderborn. 2013. [ bib ]
[21] Frank Brüseke, Gregor Engels, and Steffen Becker. Decision support via automated metric comparison for the palladio-based performance blame analysis. In Proceedings of the 4th Joint ACM/SPEC International Conference on Performance Engineering (ICPE '13), Prague, Chech Repbulic, 2013. ACM, New York, NY, USA. 2013. [ bib ]
[22] Gunnar Brataas, Erlend Stav, Sebastian Lehrig, Steffen Becker, Goran Kopčak, and Darko Huljenic. Cloudscale: Scalability management for cloud systems. In Proceedings of the 4th ACM/SPEC International Conference on Performance Engineering, Prague, Czech Republic, 2013, ICPE '13, pages 335-338. ACM, New York, NY, USA. 2013. [ bib | DOI | http ]
[23] Matthias Becker, Markus Luckey, and Steffen Becker. Model-driven Performance Engineering of Self-Adaptive Systems: A Survey. In Proceedings of the International Conference on Quality of Software Architecture, 2012, QoSA'12. ACM, New York, NY, USA. 2012. [ bib ]
[24] Steffen Becker. Model transformations in non-functional analysis. In Formal methods for Model-Driven Engineering, Marco Bernado, Vittorio Cortellessa, and Alfonso Pierantonio, editors, 2012, Lecture Notes in Computer Science. Springer-Verlag Berlin Heidelberg. 2012. [ bib ]
[25] Steffen Becker and Matthias Tichy. Towards Model-Driven Evolution of Performance Critical Business Information Systems to Cloud Computing Architectures. In Proceedings of the GI-Workshop on Model-Based and Model-Driven Softwaremodernization 2012 (MMSM12), Modellierung 2012, Bamberg, 2012. [ bib ]
[26] G. Besova, S. Walther, H. Wehrheim, and S. Becker. Weaving-based configuration and modular transformation of multi-layer systems. In Models 2012, Robert France, Juergen Kazmeier, Colin Atkinson, and Ruth Breu, editors, 2012, volume to appear. Springer Verlag Berlin/Heidelberg. 2012. [ bib ]
[27] Thomas Goldschmidt, Steffen Becker, and Erik Burger. Towards a tool-oriented taxonomy of view-based modelling. In Proceedings of the Modellierung 2012, Elmar J. Sinz and Andy Schürr, editors, Bamberg, 2012, volume P-201 of GI-Edition - Lecture Notes in Informatics (LNI), pages 59-74. Gesellschaft für Informatik e.V. (GI), Bonn, Germany. 2012. [ bib | .pdf ]
[28] C. Heinzemann, C. Priesterjahn, and S. Becker. Towards modeling reconfiguration in hierarchical component architectures. In 15th ACM SigSoft International Symposium on Component-Based Software Engineering (CBSE 2012), 2012. [ bib ]
[29] M. Platenius, M. von Detten, and S. Becker. Archimetrix: Improved Software Architecture Recovery in the Presence of Design Deficiencies. In Proceedings of the 16th European Conference on Software Maintenance and Reengineering (CSMR), 2012. [ bib ]
[30] Markus von Detten and Steffen Becker. Combining clustering and pattern detection for the reengineering of component-based software systems. In 7th ACM SIGSOFT International Conference on the Quality of Software Architectures (QoSA 2011), June 20-24 2011. [ bib ]
[31] Steffen Becker. Towards System Viewpoints to Specify Adaptation Models at Runtime. In Proc. of the Software Engineering Conference, Young Researches Track (SE 2011), 2011, volume 31 of Softwaretechnik-Trends. [ bib | .pdf ]
[32] Frank Brüseke, Gregor Engels, and Steffen Becker. Palladio-based performance blame analysis. In Proc. 16th International Workshop on Component Oriented Programming (WCOP'11), Ralf Reussner, Clemens Szyperski, and Wolfgang Weck, editors, 2011. [ bib ]
[33] Heiko Koziolek, Bastian Schlich, Carlos Bilich, Roland Weiss, Steffen Becker, Klaus Krogmann, Mircea Trifu, Raffaela Mirandola, and Anne Koziolek. An industrial case study on quality impact prediction for evolving service-oriented software. In Proceeding of the 33rd international conference on Software engineering (ICSE 2011), Software Engineering in Practice Track, Richard N. Taylor, Harald Gall, and Nenad Medvidovic, editors, Waikiki, Honolulu, HI, USA, 2011, pages 776-785. ACM, New York, NY, USA. 2011, Acceptance Rate: 18% (18/100). [ bib | DOI | http | Abstract ]
Systematic decision support for architectural design decisions is a major concern for software architects of evolving service-oriented systems. In practice, architects often analyse the expected performance and reliability of design alternatives based on prototypes or former experience. Modeldriven prediction methods claim to uncover the tradeoffs between different alternatives quantitatively while being more cost-effective and less error-prone. However, they often suffer from weak tool support and focus on single quality attributes. Furthermore, there is limited evidence on their effectiveness based on documented industrial case studies. Thus, we have applied a novel, model-driven prediction method called Q-ImPrESS on a large-scale process control system consisting of several million lines of code from the automation domain to evaluate its evolution scenarios. This paper reports our experiences with the method and lessons learned. Benefits of Q-ImPrESS are the good architectural decision support and comprehensive tool framework, while one drawback is the time-consuming data collection.
[34] Oleg Travkin, Markus von Detten, and Steffen Becker. Towards the combination of clustering-based and pattern-based reverse engineering approaches. In Proceedings of the 3rd Workshop of the GI Working Group L2S2 - Design for Future 2011, 2011. [ bib ]
[35] 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.
[36] Steffen Becker, Michael Hauck, Mircea Trifu, Klaus Krogmann, and Jan Kofron. Reverse Engineering Component Models for Quality Predictions. In Proceedings of the 14th European Conference on Software Maintenance and Reengineering, European Projects Track, 2010, pages 199-202. IEEE. 2010. [ bib | .pdf | Abstract ]
Legacy applications are still widely spread. If a need to change deployment or update its functionality arises, it becomes difficult to estimate the performance impact of such modifications due to absence of corresponding models. In this paper, we present an extendable integrated environment based on Eclipse developed in the scope of the Q-ImPrESS project for reverse engineering of legacy applications (in C/C++/Java). The Q-ImPrESS project aims at modeling quality attributes at an architectural level and allows for choosing the most suitable variant for implementation of a desired modification. The main contributions of the project include i) a high integration of all steps of the entire process into a single tool, a beta version of which has been already successfully tested on a case study, ii) integration of multiple research approaches to performance modeling, and iii) an extendable underlying meta-model for different quality dimensions.
[37] Thomas Goldschmidt, Steffen Becker, and Axel Uhl. Incremental Updates for Textual Modeling of Large Scale Models. In Proceedings of the 15th IEEE International Conference on Engineering of Complex Computer Systems (ICECCS 2010) - Poster Paper, 2010. IEEE. 2010. [ bib | Abstract ]
Model-Driven Engineering (MDE) aims at improving the development of complex computer systems. Within this context textual concrete syntaxes for models are beneficial for many reasons. They foster usability and productivity because of their fast editing style, their usage of error markers, autocompletion and quick fixes. Several frameworks and tools from different communities for creating concrete textual syntaxes for models emerged during recent years. However, there are still cases where no solution has been published yet. Open issues are incremental parsing and model updating as well as partial and federated views. On the other hand incremental parsing and the handling of abstract syntaxes as leading entities has been investigated within the compiler construction communities many years ago. In this paper we present an approach for concrete textual syntaxes that makes use of incremental parsing and transformation techniques. Thus, we circumvent problems that occur when dealing with concrete textual syntaxes in a UUID based environment including multiple partial and federated views. We validated our approach using a proof of concept implementation including a case study.
[38] Lucia Kapova and Steffen Becker. Systematic refinement of performance models for concurrent component-based systems. In 7th International Workshop on Formal Engineering approaches to Software Components and Architectures (FESCA), 2010, Electronic Notes in Theoretical Computer Science. Elsevier. 2010. [ bib | .pdf | Abstract ]
Model-driven performance prediction methods require detailed design models to evaluate the performance of software systems during early development stages. However, the complexity of detailed prediction models and the semantic gap between modelled performance concerns and functional concerns prevents many developers to address performance. As a solution to this problem, systematic model refinements, called completions, hide low-level details from developers. Completions automatically integrate performance-relevant details into component-based architectures using model-to-model transformations. In such scenarios, conflicts between different completions are likely. Therefore, the application order of completions must be determined unambiguously in order to reduce such conflicts. Many existing approaches employ the concept of performance completions to include performance-relevant details to the prediction model. So far researcher only address the application of a single completion on an architectural model. The reduction of conflicting completions have not yet been considered. In this paper, we present a systematic approach to reduce and avoid conflicts between completions that are applied to the same model. The method presented in this paper is essential for the automated integration of completions in software performance engineering. Furthermore, we apply our approach to reduce conflicts of a set of completions based on design patterns for concurrent software systems.
[39] Lucia Kapova, Thomas Goldschmidt, Steffen Becker, and Joerg Henss. Evaluating Maintainability with Code Metrics for Model-to-Model Transformations. In Research into Practice - Reality and Gaps (Proceeding of QoSA 2010), George Heineman, Jan Kofron, and Frantisek Plasil, editors, 2010, volume 6093 of LNCS, pages 151-166. Springer-Verlag Berlin Heidelberg. 2010. [ bib | .pdf | Abstract ]
Using model-to-model transformations to generate analysis models or code from architecture models is sought to promote compliance and reuse of components. The maintainability of transformations is influenced by various characteristics - as with every programming language artifact. Code metrics are often used to estimate code maintainability. However, most of the established metrics do not apply to declarative transformation languages (such as QVT Relations) since they focus on imperative (e.g. object-oriented) coding styles. One way to characterize the maintainability of programs are code metrics. However, the vast majority of these metrics focus on imperative (e.g., object-oriented) coding styles and thus cannot be reused as-is for transformations written in declarative languages. In this paper we propose an initial set of quality metrics to evaluate transformations written in the declarative QVT Relations language.We apply the presented set of metrics to several reference transformations to demonstrate how to judge transformation maintainability based on our metrics.
[40] 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.
[41] Thomas Goldschmidt, Steffen Becker, and Axel Uhl. FURCAS: Framework for UUID-Retaining Concrete to Abstract Syntax Mappings. In Proceedings of the 5th European Conference on Model Driven Architecture - Foundations and Applications (ECMDA 2009) - Tools and Consultancy Track, 2009. CTIT. 2009. [ bib | Abstract ]
Textual concrete syntaxes for models are beneficial for many reasons. They foster usability and productivity because of their fast editing style, their usage of error markers, autocompletion and quick fixes. Several frameworks and tools from different communities for creating concrete textual syntaxes for models emerged during recent years. However, these approaches failed to provide a solution in general. Open issues are incremental parsing and model updating as well as partial and federated views. Building views on abstract models is one of the key concepts of model-driven engineering. Different views help to present concepts behind a model in a way that they can be understood and edited by different stakeholders or developers in different roles. Within graphical modelling several approaches exist allowing the definition of explicit holistic, partial or combined graphical views for models. On the other hand several frameworks that provide textual editing support for models have been presented over recent years. However, the combination of both principals, meaning textual, editable and decorating views is lacking in all of these approaches. In this presentation, we show FURCAS (Framework for UUID Retaining Concrete to Abstract Syntax Mappings), a textual decorator approach that allows to separately store and manage the textual concrete syntax from the actual abstract model elements. Thereby we allow to define textual views on models that may be partial and/or overlapping concerning other (graphical and/or textual) views.
[42] Thomas Goldschmidt, Steffen Becker, and Axel Uhl. Textual views in model driven engineering. In Proceedings of the 35th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA), 2009. IEEE. 2009. [ bib | Abstract ]
Building views on abstract models is one of the key concepts of model-driven engineering. Different views help to present concepts behind a model in a way that they can be understood and edited by different stakeholders or developers in different roles. Within graphical modelling several approaches exist allowing the definition of explicit holistic, partial or combined graphical views for models. On the other hand several frameworks that provide textual editing support for models have been presented over recent years. However, the combination of both principals, meaning textual, editable and decorating views is lacking in all of these approaches. In this paper, we introduce a textual decorator approach that allows to separately store and manage the textual concrete syntax from the actual abstract model elements. Thereby we allow to define textual views on models that may be partial and/or overlapping concerning other (graphical and/or textual) views.
[43] 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 ]
[44] 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).
[45] Steffen Becker. Coupled Model Transformations. In WOSP '08: Proceedings of the 7th International Workshop on Software and performance, Princeton, NJ, USA, 2008, pages 103-114. ACM, New York, NY, USA. 2008. [ bib | DOI | Abstract ]
Model-driven performance prediction methods use abstract design models to predict the performance of the modelled system during early development stages. However, performance is an attribute of the running system and not its model. The system contains many implementation details not part of its model but still affecting the performance at run-time. Existing approaches neglect details of the implementation due to the abstraction underlying the design model. Completion components [26] deal with this problem, however, they have to be added manually to the prediction model. In this work, we assume that the system's implementation is generated by a chain of model transformations. In this scenario, the transformation rules determine the transformation result. By analysing these transformation rules, a second transformation can be derived which automatically adds details to the prediction model according to the encoded rules. We call this transformation a coupled transformation as it is coupled to an corresponding model-to-code transformation. It uses the knowledge on the output of the model-to-code transformation to increase performance prediction accuracy. The introduced coupled transformations method is validated in a case study in which a parametrised transformation maps abstract component connectors to realisations in different RPC calls. In this study, the corresponding coupled transformation captures the RPC's details with a prediction error of less than 5%.
[46] Steffen Becker, Tobias Dencker, and Jens Happe. Model-Driven Generation of Performance Prototypes. In Performance Evaluation: Metrics, Models and Benchmarks (SIPEW 2008), 2008, volume 5119 of Lecture Notes in Computer Science, pages 79-98. Springer-Verlag Berlin Heidelberg. 2008. [ bib | DOI | .pdf | Abstract ]
Early, model-based performance predictions help to understand the consequences of design decisions on the performance of the resulting system before the system's implementation becomes available. While this helps reducing the costs for redesigning systems not meeting their extra-functional requirements, performance prediction models have to abstract from the full complexity of modern hard- and software environments potentially leading to imprecise predictions. As a solution, the construction and execution of prototypes on the target execution environment gives early insights in the behaviour of the system under realistic conditions. In literature several approaches exist to generate prototypes from models which either generate code skeletons or require detailed models for the prototype. In this paper, we present an approach which aims at automated generation of a performance prototype based solely on a design model with performance annotations. For the concrete realisation, we used the Palladio Component Model (PCM), which is a component-based architecture modelling language supporting early performance analyses. For a typical three-tier business application, the resulting Java EE code shows how the prototype can be used to evaluate the influence of complex parts of the execution environment like memory interactions or the operating system's scheduler.
[47] 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 ]
[48] Thomas Goldschmidt, Steffen Becker, and Axel Uhl. Classification of Concrete Textual Syntax Mapping Approaches. In Proceedings of the 4th European Conference on Model Driven Architecture - Foundations and Applications, 2008, volume 5059 of Lecture Notes in Computer Science, pages 169-184. Springer-Verlag Berlin Heidelberg. 2008. [ bib | DOI | .pdf | Abstract ]
Textual concrete syntaxes for models are beneficial for many reasons. They foster usability and productivity because of their fast editing style, their usage of error markers, autocompletion and quick fixes. Furthermore, they can easily be integrated into existing tools such as diff/merge or information interchange through e-mail, wikis or blogs. Several frameworks and tools from different communities for creating concrete textual syntaxes for models emerged during recent years. However, these approaches failed to provide a solution in general. Open issues are incremental parsing and model updating as well as partial and federated views. To determine the capabilities of existing approaches, we provide a classification schema, apply it to these approaches, and identify their deficiencies.
[49] 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.
[50] 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.
[51] 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.
[52] Heiko Koziolek, Steffen Becker, and Jens Happe. Predicting the Performance of Component-based Software Architectures with different Usage Profiles. In Proc. 3rd International Conference on the Quality of Software Architectures (QoSA'07), July 2007, volume 4880 of Lecture Notes in Computer Science, pages 145-163. Springer-Verlag Berlin Heidelberg. July 2007. [ bib | .pdf | Abstract ]
Performance predictions aim at increasing the quality of software architectures during design time. To enable such predictions, specifications of the performance properties of individual components within the architecture are required. However, the response times of a component might depend on its configuration in a specific setting and the data send to or retrieved from it. Many existing prediction approaches for component-based systems neglect these influences. This paper introduces extensions to a performance specification language for components, the Palladio Component Model, to model these influences. The model enables to predict response times of different architectural alternatives. A case study on a component-based architecture for a web portal validates the approach and shows that it is capable of supporting a design decision in this scenario.
[53] Michael Kuperberg and Steffen Becker. Predicting Software Component Performance: On the Relevance of Parameters for Benchmarking Bytecode and APIs. In Proceedings of the 12th International Workshop on Component Oriented Programming (WCOP 2007), Ralf Reussner, Clemens Czyperski, and Wolfgang Weck, editors, July 2007. [ bib | .pdf | Abstract ]
Performance prediction of component-based software systems is needed for systematic evaluation of design decisions, but also when an application�s execution system is changed. Often, the entire application cannot be benchmarked in advance on its new execution system due to high costs or because some required services cannot be provided there. In this case, performance of bytecode instructions or other atomic building blocks of components can be used for performance prediction. However, the performance of bytecode instructions depends not only on the execution system they use, but also on their parameters, which are not considered by most existing research. In this paper, we demonstrate that parameters cannot be ignored when considering Java bytecode. Consequently, we outline a suitable benchmarking approach and the accompanying challenges.
[54] Klaus Krogmann and Steffen Becker. A Case Study on Model-Driven and Conventional Software Development: The Palladio Editor. In Software Engineering 2007 - Beiträge zu den Workshops, Wolf-Gideon Bleek, Henning Schwentner, and Heinz Züllighoven, editors, March 27 2007, volume 106 of Lecture Notes in Informatics, pages 169-176. Series of the Gesellschaft für Informatik (GI). March 27 2007. [ bib | .pdf | Abstract ]
The actual benefits of model-driven approaches compared to code-centric development have not been systematically investigated. This paper presents a case study in which functional identical software was once developed in a code-centric, conventional style and once using Eclipse-based model-driven development tools. In our specific case, the model-driven approach could be carried in 11% of the time of the conventional approach, while simultaneously improving code quality.
[55] 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.
[56] Steffen Becker, Thomas Goldschmidt, Boris Gruschko, and Heiko Koziolek. A Process Model and Classification Scheme for Semi-Automatic Meta-Model Evolution. In Proc. 1st Workshop MDD, SOA und IT-Management (MSI'07), 2007, pages 35-46. GiTO-Verlag. 2007. [ bib | .pdf | Abstract ]
Abstract: Model Driven Software Development (MDSD) has matured over the last few years and is now becoming an established technology. As a consequence, dealing with evolving meta-models and the necessary migration activities of instances of this meta-model is becoming increasingly important. Approaches from database schema migration tackle a similar problem, but cannot be adapted easily to MDSD. This paper presents work towards a solution in the model-driven domain. Firstly, we introduce a process model, which defines the necessary steps to migrate model instances upon an evolving meta-model. Secondly, we have created an initial classification of metamodel changes in EMF/Ecore utilised by our process model
[57] Steffen Becker, Jens Happe, and Heiko Koziolek. Putting Components into Context: Supporting QoS-Predictions with an explicit Context Model. In Proc. 11th International Workshop on Component Oriented Programming (WCOP'06), Ralf Reussner, Clemens Szyperski, and Wolfgang Weck, editors, July 2006, pages 1-6. [ bib | .pdf | Abstract ]
The evaluation of Quality of Service (QoS) attributes in early development stages of a software product is an active research area. For component-based systems, this yields many challenges, since a component can be deployed and used by third parties in various environments, which influence the functional and extra-functional properties of a component. Current component models do not reflect these environmental dependencies sufficiently. In this position statement, we motivate an explicit context model for software components. A context model exists for each single component and contains its connections, its containment, the allocation on hard- and software resources, the usage profile, and the perceived functional and extra-functional properties in the actual environment.
[58] Heiko Koziolek, Jens Happe, and Steffen Becker. Parameter Dependent Performance Specification of Software Components. In Proc. 2nd Int. Conf. on the Quality of Software Architectures (QoSA'06), Christine Hofmeister, Ivica Crnkovic, Ralf H. Reussner, and Steffen Becker, editors, July 2006, volume 4214 of Lecture Notes in Computer Science, pages 163-179. Springer-Verlag Berlin Heidelberg. July 2006. [ bib | .pdf | Abstract ]
Performance predictions based on design documents aim at improving the quality of software architectures. In component-based architectures, it is difficult to specify the performance of individual components, because it depends on the deployment context of a component, which may be unknown to its developers. The way components are used influences the perceived performance, but most performance prediction approaches neglect this influence. In this paper, we present a specification notation based on annotated UML diagrams to explicitly model the influence of parameters on the performance of a software component. The UML specifications are transformed into a stochastical model that allows the prediction of response times as distribution functions. Furthermore, we report on a case study performed on an online store. The results indicate that more accurate predictions could be obtained with the newly introduced specification and that the method was able to support a design decision on the architectural level in our scenario.
[59] Steffen Becker, Antonio Brogi, Ian Gorton, Sven Overhage, Alexander Romanovsky, and Massimo Tivoli. Towards an Engineering Approach to Component Adaptation. In Architecting Systems with Trustworthy Components, 2006, volume 3938 of Lecture Notes in Computer Science, pages 193-215. Springer-Verlag Berlin Heidelberg. 2006. [ bib | Abstract ]
Component adaptation needs to be taken into account when developing trustworthy systems, where the properties of component assemblies have to be reliably obtained from the properties of its constituent components. Thus, a more systematic approach to component adaptation is required when building trustworthy systems. In this paper, we illustrate how (design and architectural) patterns can be used to achieve component adaptation and thus serve as the basis for such an approach. The paper proposes an adaptation model which is built upon a classification of component mismatches, and identifies a number of patterns to be used for eliminating them. We conclude by outlining an engineering approach to component adaptation that relies on the use of patterns and provides additional support for the development of trustworthy component-based systems.
[60] Steffen Becker, Carlos Canal, Nikolay Diakov, Juan Manuel Murillo, Pascal Poizat, and Massimo Tivoli. Coordination and Adaptation Techniques: Bridging the Gap Between Design and Implementation. In Object-Oriented Technology, ECOOP 2006 Workshop Reader, ECOOP 2006 Workshops, Nantes, France, July 3-7, 2006, Final Reports, Mario Südholt and Charles Consel, editors, 2006, volume 4379 of Lecture Notes in Computer Science, pages 72-86. Springer-Verlag Berlin Heidelberg. 2006. [ bib ]
[61] Steffen Becker, Lars Grunske, Raffaela Mirandola, and Sven Overhage. Performance Prediction of Component-Based Systems: A Survey from an Engineering Perspective. In Architecting Systems with Trustworthy Components, Ralf Reussner, Judith Stafford, and Clemens Szyperski, editors, 2006, volume 3938 of Lecture Notes in Computer Science, pages 169-192. Springer-Verlag Berlin Heidelberg. 2006. [ bib | Abstract ]
More and more complex embedded system use component based development. Non-functional properties of component model are used to predict performance of the final system. We analyzed the thread properties of component in network processor based system. The proposed method is based on the thread properties and provides quantified performance of the component, and so we can predict the performance of final system at composing time. The experiments show that the difference between theoretic and simulation result is less than 10%.
[62] Niels Streekmann and Steffen Becker. A Case Study for Using Generator Configuration to Support Performance Prediction of Software Component Adaptation. In 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), Christine Hofmeister, Ivica Crnkovic, Ralf H. Reussner, and Steffen Becker, editors, 2006. [ bib | Abstract ]
In order to put component based software engineering into practice we have to consider the eect of software component adaptation. Adaptation is used in existing systems to bridge interoperability problems between bound interfaces, e.g., to integrate existing legacy systems into new software architectures. In CBSE, one of the aims is to predict the properties of the assembled system from its basic parts. Adaptation is a special case of composition and can be treated consequently in a special way. The precision of the prediction methods can be increased by exploiting additional knowledge about the adapter. This work motivates the use of adapter generators which simultaneously produce prediction models.
[63] Heiko Koziolek and Steffen Becker. Transforming Operational Profiles of Software Components for Quality of Service Predictions. In Proceedings of the 10th Workshop on Component Oriented Programming (WCOP2005), Glasgow, UK, Ralf H. Reussner, Clemens Szyperski, and Wolfgang Weck, editors, July 2005. [ bib | .pdf | Abstract ]
Current Quality-of-Service (QoS) predictions methods for component-based software systems disregard the influence of the operational profile for anticipating an architecture�s performance, reliability, security or safety. The operational profile captures the set of inputs and outputs to a software components. We argue, that a detailed operational profile especially for software components is necessary for accurate QoS-predictions and that a standardised form of it is needed. We demonstrate that components act as transformers to an operational profile and discuss that this transformation has to be described, so that QoS prediction methods are able to deliver appropriate results for component-based architectures.
[64] Steffen Becker. Using Generated Design Patterns to Support QoS Prediction of Software Component Adaptation. In Proceedings of the Second International Workshop on Coordination and Adaptation Techniques for Software Entities (WCAT 05), Carlos Canal, Juan Manuel Murillo, and Pascal Poizat, editors, 2005. [ bib | .pdf | Abstract ]
In order to put component based software engineering into practice we have to consider the eect of software component adaptation. Adaptation is used in existing systems to bridge interoperability problems between bound interfaces, e.g., to integrate existing legacy systems into new software architectures. In CBSE, one of the aims is to predict the properties of the assembled system from its basic parts. Adaptation is a special case of composition and can be treated consequently in a special way. The precision of the prediction methods can be increased by exploiting additional knowledge about the adapter. This work motivates the use of adapter generators which simultaneously produce prediction models.
[65] Steffen Becker, Carlos Canal, Juan Manuel Murillo, Pascal Poizat, and Massimo Tivoli. Design Time, Run Time and Implementation of Adaptation. In Report on the Second International Workshop on Coordination and Adaptation Techniques for Software Entities (WCAT'05), 2005. [ bib ]
[66] Viktoria Firus, Steffen Becker, and Jens Happe. Parametric Performance Contracts for QML-specified Software Components. In Formal Foundations of Embedded Software and Component-based Software Architectures (FESCA), 2005, volume 141 of Electronic Notes in Theoretical Computer Science, pages 73-90. [ 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 preand 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 dependencies of external calls for the performance metric response time. We present an approach using parametric contracts to compute the statistical distribution of response time as a discrete distribution in dependency of the distribution of response times of environmental services. We use the Quality of Service Modeling Language (QML) as a syntax for specifying distributions.
[67] 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.
[68] 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.
[69] 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.
[70] 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.
[71] 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.
[72] Viktoria Firus and Steffen Becker. Towards Performance Evaluation of Component Based Software Architectures. In Proceedings of Formal Foundation of Embedded Software and Component-Based Software Architectures (FESCA), 2004, volume 108 of Electronic Notes in Theoretical Computer Science, pages 118-121. [ bib | .pdf ]
[73] 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.
[74] Steffen Becker and Sven Overhage. Stücklistenbasiertes Komponenten-Konfigurationsmanagement. In Tagungsband 5. Workshop Komponentenorientierte betriebliche Anwendungssysteme, Klaus Turowski, editor, 2003, pages 17-32. Universität Augsburg. 2003. [ bib | .pdf | Abstract ]
In diesem Beitrag wird ein Konzept für das Konfigurationsmanagement komponentenorientierter Anwendungen dargestellt. Dabei wird zunächst der Begriff �Konfigura-tionsmanagement� näher erläutert und anschließend die Stücklistenorganisation als eine geeignete Methode für das Konfigurationsmanagement beschrieben. Der Beitrag konzentriert sich auf die Entwicklung einer Vorgehensweise zur (automatisierten) Unterstützung der Komponentenaus-wahl, die auf Stücklisten, einem einheitlichen Spezifikationsrahmen und einer multiattributiven Entscheidungsfindung basiert. Abschließend wird das änderungsmanagement beschrieben, das ebenfalls zum Konfigurationsmanagement zu zählen ist.
[75] 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.

Technical Reports

[1] Svetlana Arifulina, Marie Christin Platenius, Christian Gerth, Steffen Becker, Gregor Engels, and Wilhelm Schäfer. Configuration of specification language and matching for services in on-the-fly computing. Technical Report tr-ri-14-342, Heinz Nixdorf Institute, University of Paderborn, 2014. [ bib ]
[2] Christian Heinzemann and Steffen Becker. Comparison of the mechatronicuml component models. Technical Report tr-ri-14-341, Software Engineering Group, Heinz Nixdorf Institute, University of Paderborn, 2014. [ bib ]
[3] Marie Christin Platenius, Steffen Becker, and Wilhelm Schäfer. Integrating service matchers into a service market architecture. Technical Report tr-ri-14-340, Software Engineering Group, Heinz Nixdorf Institute, University of Paderborn, 2014. [ bib ]
[4] Steffen Becker, Stefan Dziwok, Christopher Gerking, Wilhelm Schäfer, Christian Heinzemann, Sebastian Thiele, Matthias Meyer, Claudia Priesterjahn, Uwe Pohlmann, and Matthias Tichy. The mechatronicuml design method - process and language for platform-independent modeling. Technical Report tr-ri-14-337, Heinz Nixdorf Institute, University of Paderborn, 2014. Version 0.4. [ bib ]
[5] S. Becker, C. Brenner, S. Dziwok, T. Gewering, C. Heinzemann, U. Pohlmann, C. Priesterjahn, W. Schäfer, J. Suck, O. Sudmann, and M. Tichy. The MechatronicUML Method - Process, Syntax, and Semantics. Technical report, Software Engineering Group, Heinz Nixdorf Institute University of Paderborn, 2012. [ bib ]
[6] Steffen Becker, Markus von Detten, Christian Heinzemann, and Jan Rieke. Structuring complex story diagrams by polymorphic calls. Technical report, Software Engineering Group, Heinz Nixdorf Institute, 2011. [ bib ]
[7] 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.
[8] 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.
[9] Steffen Becker, Thomas Goldschmidt, Henning Groenda, Jens Happe, Henning Jacobs, Christian Janz, Konrad Jünemann, Benjamin Klatt, Christopher Köker, and Heiko Koziolek. Transformationen in der modellgetriebenen software-entwicklung. Technical report, Fakultät für Informatik, Universität Karlsruhe, Karlsruhe, 2007. Interner Bericht. [ bib | http | Abstract ]
Software-Architekturen lassen sich durch Modell beschreiben. 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 standardisierten Beschreibungssprachen wie UML aber auch die Einführung von domänen-spezifischen Sprachen (DSL) erkennen. Auf diese formalisierten Modelle 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. Transformationen kapseln dabei wiederholt anwendbares Entwurfs-Wissen ("Muster") in parametrisierten Schablonen. Für die Definition der Transformationen können Sprachen wie beispielsweise QVT verwendet werden. Mit AndoMDA und openArchitectureWare existieren Werkzeuge, welche die Entwickler bei der Ausführung von Transformationen unterstützen.
[10] 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.
[11] 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 ]
[12] 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.
[13] 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 ]
[14] Steffen Becker. The Palladio Component Model. Technical report, University of Oldenburg, 2004. [ bib ]

Theses

[1] Steffen Becker. Coupled Model Transformations for QoS Enabled Component-Based Software Design. PhD thesis, University of Oldenburg, Germany, 2008. [ bib ]
[2] Steffen Becker. Konfigurationsmanagement komponentenorientierter betrieblicher Anwendungen. Master's thesis, TU Darmstadt, 2003. [ bib | .pdf | Abstract ]
Diese Diplomarbeit beschäftigt sich mit Fragen des Konfigurationsmanagements bei der betrieblichen Anwendungsentwicklung mit Softwarekomponenten. Besondere Schwerpunkte liegen dabei in der Generierung von Konfigurationen und deren systematischer Bewertung im Bezug auf ihre Nutzen und ihre Kosten. Die wichtigsten Elemente bei der Durchführung des Konfigurationsmanagements werden in Form von Prozessen dargestellt, darunter ein Prozess zur Suche nach Konfigurationen sowie deren Nutzenbewertung mit Hilfe des AHP.

Other

[1] Steffen Becker, Erich Ortner, and Sven Overhage. Der Komponentenansatz - ein Riesenschritt für unsere geistige Entwicklung, 2003. [ bib ]
[1] Fabian Brosig, Philipp Meier, Steffen Becker, Anne Koziolek, Heiko Koziolek, and Samuel Kounev. Quantitative evaluation of model-driven performance analysis and simulation of component-based architectures. Software Engineering, IEEE Transactions on, 41(2):157-175, Feb 2015. [ bib | DOI | Abstract ]
During the last decade, researchers have proposed a number of model transformations enabling performance predictions. These transformations map performance-annotated software architecture models into stochastic models solved by analytical means or by simulation. However, so far, a detailed quantitative evaluation of the accuracy and efficiency of different transformations is missing, making it hard to select an adequate transformation for a given context. This paper provides an in-depth comparison and quantitative evaluation of representative model transformations to, e.g., Queueing Petri Nets and Layered Queueing Networks. The semantic gaps between typical source model abstractions and the different analysis techniques are revealed. The accuracy and efficiency of each transformation are evaluated by considering four case studies representing systems of different size and complexity. The presented results and insights gained from the evaluation help software architects and performance engineers to select the appropriate transformation for a given context, thus significantly improving the usability of model transformations for performance prediction.
[2] Matthias Becker, Sebastian Lehrig, and Steffen Becker. Systematically deriving quality metrics for cloud computing systems. Proceedings of the 6th ACM/SPEC International Conference on Performance Engineering, ICPE, 15:169-174, 2015. [ bib ]
[3] Frank Brüseke, Henning Wachsmuth, Gregor Engels, and Steffen Becker. Pblaman: performance blame analysis based on palladio contracts. Concurrency and Computation: Practice and Experience, page to appear, 2014. [ bib | DOI | http ]
[4] Heiko Koziolek, Steffen Becker, Jens Happe, Petr Tuma, and Thijmen de Gooijer. Towards software performance engineering for multicore and manycore systems. SIGMETRICS Perform. Eval. Rev., 41(3):2-11, 2014, ACM, New York, NY, USA. [ bib | DOI | http ]
[5] 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 ]
[6] Sebastian Lehrig and Steffen Becker. Cloudscale - skalierbarkeit für die cloud. ForschungsForum Paderborn, 17:20-23, 2014. [ bib ]
[7] Markus von Detten, Marie Christin Platenius, and Steffen Becker. Reengineering Component-Based Software Systems with Archimetrix. Software and Systems Modeling, April 2013:1-30, 2013, Springer-Verlag. [ bib | DOI | http ]
[8] Steffen Becker, Stefan Sauer, Matthias Riebisch, and Bernhard Schätz. Modellbasierte und Modellgetriebene Softwaremodernisierung. Softwaretechnik-Trends, 32(2):1-2, 2012, Köllen Druck & Verlag GmbH. [ bib ]
[9] Benjamin Klatt and Steffen Becker. Architekturen 2012: Industrie und Wissenschaft treffen sich. OBJEKTspektrum, 6(6), 2012, Sigs Datacom. [ bib | http ]
[10] Heiko Koziolek, Bastian Schlich, Steffen Becker, and Michael Hauck. Performance and reliability prediction for evolving service-oriented software systems. Empirical Software Engineering, pages 1-45, 2012, Springer US. [ bib | DOI | http ]
[11] Heiko Koziolek, Steffen Becker, Jens Happe, and Paul Pettersson. Quality of service-oriented software systems (QUASOSS 2010). Models in Software Engineering, pages 364-368, 2011, Springer. [ bib ]
[12] 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%
[13] 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.
[14] Steffen Becker, Wilhelm Hasselbring, Alexandra Paul, Marko Boskovic, Heiko Koziolek, Jan Ploski, Abhishek Dhama, Henrik Lipskoch, Matthias Rohr, Daniel Winteler, Simon Giesecke, Roland Meyer, Mani Swaminathan, Jens Happe, Margarete Muhle, and Timo Warns. Trustworthy software systems: a discussion of basic concepts and terminology. SIGSOFT Softw. Eng. Notes, 31(6):1-18, 2006, ACM, New York, NY, USA. [ bib | DOI | .pdf | Abstract ]
Basic concepts and terminology for trustworthy software systems are discussed. Our discussion of definitions for terms in the domain of trustworthy software systems is based on former achievements in dependable, trustworthy and survivable systems. We base our discussion on the established literature and on approved standards. These concepts are discussed in the context of our graduate school TrustSoft on trustworthy software systems. In TrustSoft, we consider trustworthiness of software systems as determined by correctness, safety, quality of service (performance, reliability, availability), security, and privacy. Particular means to achieve trustworthiness of component-based software systems � as investigated in TrustSoft � are formal verification, quality prediction and certification; complemented by fault diagnosis and fault tolerance for increased robustness.
[15] 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.