Steffen Becker

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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%

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.

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.

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.

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\%.

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.

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.

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.

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).

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.

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.

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.

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

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.

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.

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.

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.

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%.

Abstract

Terrain has a big impact on how battlefield situations unfold primarily because of its effects on observability, mobility, and restriction of fields of fire. As armed forces of the information age come within each other's sensor coverage, information about them is rapidly conveyed to their opponents. Terrain imposes constraints and opens opportunities for the creative use of Battlefield Operating Systems (BOS) and the capabilities and limitations of available troops, vehicles, systems, and materiel. Thus, understanding terrain, and its tactical import is essential for a force to succeed in its missions. Future Force Warrior (FFW) and Future Combat Systems (FCS) initiatives are developing advanced functional capabilities to aid Soldiers in operations to control and hold ground. Adding robotic vehicles, sensors, and weapons creates a planning and coordination challenge for commanders, and highlights the need for autonomous robotic systems that effectively ünderstand" the tactical import of terrain and integrate that understanding into their situation awareness and behavior-generation processes. TAH-RI is reusable component software providing means of increasing readiness of Soldiers (e.g., in training and performance support systems) to integrate terrain understanding into battlefield decision-making processes, and means of enabling more autonomy in robots through terrain understanding for tactical behavior generation.

Abstract

In order to put component based software engineering into practice we have to consider the e�ect 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.

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.

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.

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.

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.

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.

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.

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.

Abstract

In order to put component based software engineering into practice we have to consider the e�ect 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.

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.

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.

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.

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.

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.

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.