Catálogo de publicaciones - libros

Software product families have found broad adoption in the embedded systems industry. Product family thinking has been prevalent in this context for mechanics and hardware and adopting the same for software has been viewed as a logical approach. During recent years, however, the trends of convergence, end-to-end solutions, shortened innovation and R&D cycles and differentiaton through software engineering capabilities have lead to a development where organizations are stretching the scope of their product families far beyond the initial design. Failing to adjust the product family approach, including the architectural and process dimensions when the business strategy is changing is leading to several challenging problems that can be viewed as symptons of this approach. The keynote discusses the key symptoms, the underlying causes for these symptons as well as solutions for realigning the product family approach with the business strategy.

Composability itself is probably the least composable term in the theory of computer science. In this talk, I’ll explore some of the troubling reasons why we have succeeded only so-so when it comes to the creation of composable software – and thus software components. Architecture can often come to the rescue, but only when applied with great style.

Software architecture has become a widely-accepted conceptual basis for the development of non-trivial software in all application areas and by organizations of all sizes. Effectively documenting an architecture is as important as crafting it; if the architecture is not understood, or worse, misunderstood, it cannot meet its goals as the unifying vision for software development. Development-based architecture strategies, such as Rational’s Unified Process, stop short of prescribing documentation standards. The Views and Beyond approach to software architecture provides practical guidance on the what, why, and how of creating IEEE 1471-2000 compliant documentation for your software architecture that will be used for years to come. The approach is based on the well-known concept of views and is presented in the context of prevailing prescriptive models for architecture, including the Unified Process and UML 2.0, which has improved support for representing key architectural elements over its predecessors.

The tutorial consists of two parts. In the first part (45 min), Ralf Reussner focuses on the importance of an explicitly modelled software architecture. Besides an introduction into common architectural views, the role of the software architect is compared to ”classical building” architects. As part of this, the often used comparison between building architecture and software architecture is critically reviewed. In particular, the role of an architect is discussed in model-driven software projects.

During the second part of the tutorial (135 min), Steffen Becker demonstrates online model driven development tools based on Eclipse. First, an introduction is given on the metamodelling tools of the Eclipse Modelling Framework (EMF) and on the Graphical Modelling Framework (GMF) used to generate a domain specific editors for user defined (meta-)models. Additionally, the MDA framework of the OMG is presented and the concepts are applied to the introduced tools.

A live demonstration of the capabilities of the introduced tools for model transformations shows finally how a domain specific modelling tool can be generated to a large extend automatically using an EMF-model instance and the generator of GMF. As a result, an editor based on the Eclipse Graphical Editing Framework (GEF) can be deployed and run using Eclipse.

A software architecture describes the structure of a software system on an abstract implementation independent level. In forward engineering it serves as a blueprint to prescribe the intended software structure (so-called architecture model). In reverse engineering it can provide an abstract view of the actual code structure of the existing software system (so-called code architecture). Architecture models and actual code architectures play a vital role for all comprehension and communication tasks during the development and evolution of large software systems. Therefore, architecture models and code architectures have to be explicitly represented and consistently maintained during the development, maintenance, and reengineering processes.

The need to insure compliance of the architecture model and the actual code architecture has drawn considerable attention in recent years. In order to facilitate maintainability and enhancement of a software system the compliance of the architecture model and the actual code architecture is essential. Various tools have been developed to analyse and evaluate the deviation of code architecture and architecture model. In this tutorial we present static analysis tools that may be used for architectural analyses. We demonstrate how these tools can create useful architectural views for different evaluation tasks such as identification of reconstruction scope, critical architectural elements and potential design irregularities. If possible we will analyse a software system provided by a participant of the workshop in a life demonstration.

Middleware architectures play a crucial role in determining the overall quality of many distributed applications. Systematic evaluation methods for middleware architectures are therefore important to thoroughly assess the impact of design decisions on quality goals. This paper presents MEMS, a scenario-based evaluation approach. MEMS provides a principled way of evaluating middleware architectures by leveraging generic qualitative and quantitative evaluation techniques such as prototyping, testing, rating, and analysis. It measures middleware architectures by rating multiple quality attributes, and the outputs aid the determination of the suitability of alternative middleware architectures to meet an application’s quality goals. MEMS also benefits middleware development by uncovering potential problems at early stage, making it cheaper and quicker to fix design problems. The paper describes a case study to evaluate the security architecture of grid middleware architectures for managing secure conversations and access control. The results demonstrate the practical utility of MEMS for evaluating middleware architectures for multiple quality attributes.

Component-based approaches to elaborate software must deal with the fact that in practical settings, components information may be incomplete, imprecise and uncertain, and requirements may be likewise. Architects wanting to evaluate candidate architectures regarding requirements satisfaction need to use whatever information be available about components, however imperfect. Imperfect information can be dealt with using specialized analytical formalisms, such as fuzzy values for imprecision and rough sets for incompleteness; but if used, evaluations need to compare and rank using non-scalar, non-symbolic values. This article presents an approach to systematically describe components’ imperfect information, and to evaluate and rank whole component assemblies, by using credibility values-based “support scores” that aggregate imperfect information about requirements, mechanisms and components. The approach builds on the Azimut framework, which offers progressive refinement of architectural entities via architectural policies, architectural mechanisms, components, and component assemblies. An example of the proposed approach and “what-if” analysis are illustrated.

Architectural knowledge consists of architecture design as well as the design decisions, assumptions, context, and other factors that together determine why a particular solution is the way it is. Except for the architecture design part, most of the architectural knowledge usually remains hidden, tacit in the heads of the architects. We conjecture that an explicit representation of architectural knowledge is helpful for building and evolving quality systems. If we had a repository of architectural knowledge for a system, what would it ideally contain, how would we build it, and exploit it in practice? In this paper we describe a use-case model for an architectural knowledge base, together with its underlying ontology. We present a small case study in which we model available architectural knowledge in a commercial tool, the Aduna Cluster Map Viewer, which is aimed at ontology-based visualization. Putting together ontologies, use cases and tool support, we are able to reason about which types of architecting tasks can be supported, and how this can be done.

In this paper, we propose a negative scenario framework along with a mitigation action model as the linkage between safety quality attribute and architecture definition. The scenario framework provides an effective means of formulating safety concerns. The mitigation action model facilitates exploitation and codification of existing safety-critical system design knowledge. Finally, we present a series of steps that enable the justification of architectural design decisions that refine both requirements and architectures. We demonstrate and discuss the application of our framework by means of a case study.

Service-based software architectures are often modeled with queues and queuing networks. Such models are useful for performance evaluation and design. They can also assist in runtime maintenance and administration, but, in this context, it is often far more valuable to be able to forecast how QoS characteristics are likely to evolve in the near future. This is particularly important in cases where systems can be adapted to counter QoS constraint violations: in such systems, given predictions of likely future QoS characteristics, pre-emptive adaptation strategies can be implemented.

This paper outlines an approach to runtime prediction of QoS characteristics of queued systems. Predictions are computed by applying ARIMA forecasting techniques to basic properties of a queued model, and then using the model to predict complex QoS characteristics. We outline how our methods integrate into our implementation framework for monitoring and pre-emptive adaptation of web service based systems.