Skip to main content
Fachgebiete
Automobil + Motoren Bauwesen + Immobilien Business IT + Informatik Elektrotechnik + Elektronik Energie + Nachhaltigkeit Finance + Banking Management + Führung Marketing + Vertrieb Maschinenbau + Werkstoffe Versicherung + Risiko
DE
EN
Themenseiten
Organisationspsychologie Projektmanagement Marketing Smart Manufacturing
Bücher
Zeitschriften
Weitere Formate
Podcasts Webinare Technik Webinare Wirtschaft Kongresse Veranstaltungskalender Awards
Jetzt Einzelzugang starten
Zugang für Unternehmen
Referenzkunden
ATZ-Fachkongress

Chassis.tech plus 2024


4 Kongresse in einer Veranstaltung

Treffen Sie in München die Fachleute von Chassis, Lenkung, Bremsen sowie Reifen/Räder.
Erweiterte Suche
Anmelden
nach oben

2004 | Buch

Sotograph – A Pragmatic Approach to Source Code Architecture Conformance Checking Kapitel lesen Erstes Kapitel lesen

Software Architecture

First European Workshop, EWSA 2004, St Andrews, UK, May 21-22, 2004. Proceedings

herausgegeben von: Flavio Oquendo, Brian C. Warboys, Ron Morrison

Verlag: Springer Berlin Heidelberg

Buchreihe : Lecture Notes in Computer Science

Enthalten in: Professional Book Archive

Einloggen, um Zugang zu erhalten
insite
SUCHEN

Über dieses Buch

The last decade has been one of great progress in the field of software architecture research and practice. Software architecture has emerged as an important subdis- pline of software engineering. A key aspect of the design of any software system is its architecture, i. e. the fundamental organization of a system embodied in its com- nents, their relationships to each other, and to the environment, and the principles guiding its design and evolution (as defined in the Recommended Practice for Arc- tectural Description of Software-Intensive Systems -- IEEE Std 1471-2000). - The First European Workshop on Software Architecture (EWSA 2004) provided an international forum for researchers and practitioners from academia and industry to discuss a wide range of topics in the area of software architecture, and to jointly f- mulate an agenda for future research in this field. EWSA 2004 distinguished among three types of papers: research papers (which describe authors’ novel research work), experience papers (which describe real-world experiences related to software architectures), and position papers (which present concise arguments about a topic of software architecture research or practice). The Program Committee selected 19 papers (9 research papers, 4 experience - pers, and 6 position papers) out of 48 submissions from 16 countries (Australia, B- zil, Canada, Chile, Finland, France, Germany, Italy, Japan, Korea, The Netherlands, Spain, Switzerland, Turkey, UK, USA). All submissions were reviewed by three members of the Program Committee.

Inhaltsverzeichnis

Frontmatter

Research Papers

Sotograph – A Pragmatic Approach to Source Code Architecture Conformance Checking
Abstract
In our experience the implementation of software systems frequently does not conform very closely to the planned architecture. For this reason we decided to implement source code architecture conformance checking support for Sotograph, our software analysis environment. Besides providing a conformance check for a single version of a system, Sotograph supports also trend analysis. I.e., the investigation of the evolution of a software system and the changes in architecture violations between a number of versions.
Walter Bischofberger, Jan Kühl, Silvio Löffler
Formal Analysis of Architectural Patterns
Abstract
Architectural patterns characterize and specify structural and behavioral properties of (sub)systems, thus allowing the provision of solutions for classes of problems.
In this paper we show the use of architectural patterns as an abstraction to carry on, and reuse, formal reasoning on systems whose configuration can dynamically change.
This kind of systems is hard to model and to reason about due to the fact that we cannot simply build a model with fixed topology (i.e. fixed number of components and connectors) and validate properties of interest on it.
The work presented in this paper proposes an approach that given an architectural pattern which expresses a class of systems configurations and a set of properties of interest (i) selects, if any, a minimal configuration for which the specified properties make sense, (ii) an abstraction of the chosen architectural model erformed, in order to reduce the complexity of the verification phase. In this stage, abstractions are driven by the properties of interest. The output of this abstraction step can be model-checked, tested and analyzed by using a standard model-checking framework. (iii) The verification results obtained in the previous step are lifted to generic configurations by performing manual reasoning driven by the constraints posed by the architectural pattern.
The approach will be applied by using an event-based architectural pattern to a publish/subscribe system, the Siena middleware, in order to validate its features and its mobility extension.
Mauro Caporuscio, Paola Inverardi, Patrizio Pelliccione
Architectural Modelling in Product Family Context
Abstract
The software development community pursues the development of software systems with a higher degree of reuse, reduction of costs, and shorter time to market. One of the successful mechanisms followed to achieve these goals is based on sharing the development efforts, producing sets of similar products. This approach is known as Product Family Engineering (PFE). Architectural modeling (producing architectural models) in product families is a key issue in PFE activities and it will be the main focus of this paper. First, we will propose an architectural UML meta-model for PFE, able to represent the different variations in products. This meta-model will set up the conceptual basis for two valuable sets of activities that reflect industrial best practices: one deals with effectively building and maintaining the product family architecture and the other with the automatic derivation of architectures of specific products. A small example of automatic derivation is included.
Rodrigo Cerón, José L. Arciniegas, José L. Ruiz, Juan C. Dueñas, Jesús Bermejo, Rafael Capilla
Reflection-Based, Aspect-Oriented Software Architecture
Abstract
The Software Architecture discipline is devoted to the study and description of structures, created by the composition of software modules. At the same time, the most important merit of Aspect Orientation is the fact that it introduces a new kind of modularization, deployed in a range of new dimensions, orthogonally to traditional models. These fields are able not only to combine, but also to complement and extend each other. They show also remarkable coincidences in some of their key concepts, such as multiple viewpoints and connectors. This paper explores their relationship, in particular from the point of view of the specification of “aspect-oriented architectures” in terms of existing Architecture Description Languages (Adls). Specifically, we consider the language \(\mathcal {PIL}\)ar: a reflective, process-algebraic Adl conceived for the description of dynamic architectures. It has three conceptual foundations which have also been proposed as a basis for aspect-orientation, namely reflection, superimposition and process algebras. We show how, due to the semantics of its reification relationship, \(\mathcal {PIL}\)ar is capable to directly describe “architectural aspects” with no need for syntactic extensions. At the same time, we suggest that the addition of these extensions could be very useful anyway. The discussion is supported by an example of a coordination aspect in \(\mathcal {PIL}\)ar, based on the classical Paxos Consensus algorithm.
Carlos E. Cuesta, M. Pilar Romay, Pablo de la Fuente, Manuel Barrio-Solórzano
Software Architecture Evolution through Dynamic AOP
Abstract
Modern computing and network environments demand ahigh degree of adaptability from applications. At run time, an application may have to face many changes: in configuration, in protocols used, in terms of the available resources, etc. Many such changes can only be adequately addressed through dynamic evolution of the software architecture of the application. In this paper, we propose a novel approach to dynamically evolve a software architecture based on run-time aspect oriented programming. In our framework, a system designer/administrator can control the architecture of an application by dynamically inserting and removing code extensions. It is even possible to replace a significant part of the underlying middleware infrastructure without stopping the application. The novelty of this work is that it allows for a much more flexible development strategy as it delegates issues like middleware choice and adherence to an architectural specification to a framework enhanced by dynamic code extensions.
Paolo Falcarin, Gustavo Alonso
On the Role of Architectural Style in Model Driven Development
Abstract
Object Management Group’s Model-Driven Architecture (MDA) can be considered as one of the achievements resulting from ever-increasing importance of software architecture. However, based on case studies on using the ideas of MDA both with UML and in a formal setting, some notions that have been conventionally associated with architecture-oriented development have no clear role in the model. In particular, we are referring to architectural styles, which can be seen as recurring architectures of various systems, especially when designing product families. In this paper, we analyze architectural styles in the context of MDA, propose a modification to the model that would allow encapsulation of architectural properties in it, and demonstrate the usage of the approach with two examples, where interaction and distribution are the essential characteristics of the used architecture.
Tommi Mikkonen, Risto Pitkänen, Mika Pussinen
UML 1.4 versus UML 2.0 as Languages to Describe Software Architectures
Abstract
UML 1.4 is widely accepted as the standard for representing the various software artifacts generated by a development process. For this reason, there have been attempts to use this language to represent the software architecture of systems as well. Unfortunately, these attempts have ended in representations (boxes and lines) already criticized by the software architecture community. Recently, OMG has published a draft that will constitute the future UML 2.0 specification. In this paper we compare the capacities of UML 1.4 and UML 2.0 to describe software architectures. In particular, we study extensions of both UML versions to describe the static view of the C3 architectural style (a simplification of the C2 style). One of the results of this study is the difficulties found when using the UML 2.0 metamodel to describe the concept of connector in a software architecture.
Jorge Enrique Pérez-Martínez, Almudena Sierra-Alonso
From Acme to CORBA: Bridging the Gap
Abstract
Software architecture and middleware platforms are different abstraction levels of component-based development that have been evolved separately. In order to address the gap between these two areas, in this paper we discuss the integration of a generic and extensible architecture description language, Acme, with a standard middleware platform – CORBA. We propose mapping rules to transform an ACME description into a CORBA IDL specification. To make it possible, we define some extensions to Acme to include some features according to the CORBA IDL specification. These extensions explore the facilities provided by Acme for expressing additional information. We use a case study to illustrate the mapping proposed.
Márcia J. N. Rodrigues, Leonardo Lucena, Thaís Batista
Constraints of Behavioural Inheritance
Abstract
We present an approach to component inheritance and reuse which closes the gap between architectural design and process-oriented approaches. To apply inheritance checks in design and verification of a system, one should consider an inheritance relation as a property of the system and specify it as an inheritance constraint. To specify the inheritance constraints we offer a logic of behavioural inheritance. In a UML profile with the process tree semantics we show how to use this logic for architectural design and for verification with respect to the specified inheritance constraint.
Ella E. Roubtsova, Serguei A. Roubtsov

Experience Papers

Software Architectures for Designing Virtual Reality Applications
Abstract
Software architectures are particularly useful when designing complex systems. Apart from facilitating the design, development and evolution processes, software architectures help developers who are new in the domain to understand the design issues involved, reducing the learning effort. In this work we present a software architecture for virtual reality systems. This architecture applies patterns common in other interactive systems, such as the Model-View- Controller, and also identifies new patterns proper of the VR domain, such as the scene graph. In addition, in the proposed architecture we have identified the variability points needed for adapting and evolving such VR systems.
Rafael Capilla, Margarita Martínez
Generation and Enactment of Controllers for Business Architectures Using MDA
Abstract
Model Driven Architecture (MDA) is an initiative of the OMG in which the software development process is driven by various software-related models describing the software to be generated. Moreover, the new upcoming UML 2.0 standard promises to support the execution of models based on several types of actions as well as the inheritance of statecharts. We adapt this new technology in order to generate business controllers. By application of the popular Model View Controller (MVC) architecture, these controllers separate core business model functionality like database management from the presentation and control logic that uses this functionality (i.e., interactive user access). In particular, a controller translates user interactions realized by means of an interactive view into actions on the core business model.
This paper deals with the generation of business controllers applying MDA and UML 2.0 concepts and presents experiences gained in the background of a bigger industrial project. The focus is on statecharts and actions used for the specification and execution of controllers. In particular, in order to deal with the inheritance of statechart diagrams specified for business controllers, we define a couple of transformation rules. These rules support the transformation of abstract PIM statecharts modelling the functionality of business controllers to a flat PSM statechart describing a business controller in a more implementation-like fashion. We outline the application of the transformation rules by means of a business controller example application.
Günter Graw, Peter Herrmann
Formalization of an HCI Style for Accelerator Restart Monitoring
Abstract
In this paper we present a solution to design and implement a set of high-level standardized Human Computer Interfaces (HCI) for the monitoring of particle accelerators restart. We are developing a software tool, which will generate these HCIs from a predefined model. The architecture-oriented solution presented in the paper can be useful for the design of HCIs for the monitoring of any industrial process, indeed, the requirements are often very similar to those defined in our context. We expose how the architectural development techniques are used to specify and produce a family of process monitoring HCIs. Specifically, we have used an Architectural Description Language (ADL) to formalize an architectural style, which describes the common properties that the HCIs should satisfy in our specific activity domain. This paper presents the different steps of our architectural design process and the integration of the formalized style in a development environment.
Olivier Ratcliffe, Sorana Cîmpan, Flavio Oquendo, Luigi Scibile
Experiences Using Viewpoints for Information Systems Architecture: An Industrial Experience Report
Abstract
There has recently been an increase in interest, among information systems architecture practitioners, in using viewpoints for architectural definition and description. This has been caused by a number of factors including the publication of IEEE standard 1471 and the increasing adoption of RUP (and its “4+1” viewpoint set). This short experience report outlines the experiences that two software architects have had in evaluating and applying a number of viewpoint sets to information systems development. The strengths and weaknesses found with each viewpoint set are described and some general observations on viewpoint set use and definition are presented.
Eóin Woods

Position Papers

Software Architecture: The Next Step
Abstract
This position paper makes the following claims that, in our opinion, are worthwhile to discuss at the workshop. 1) The first phase of software architecture research, where the key concepts are components and connectors, has matured the technology to a level where industry adoption is wide-spread and few fundamental issues remain. 2) The traditional view on software architecture suffers from a number of key problems that cannot be solved without changing our perspective on the notion of software architecture. These problems include the lack of first-class representation of design decisions, the fact that these design decisions are cross-cutting and intertwined, that these problems lead to high maintenance cost, because of which design rules and constraints are easily violated and obsolete design decisions are not removed. 3) As a community, we need to take the next step and adopt the perspective that a software architecture is, fundamentally, a composition of architectural design decisions. These design decisions should be represented as first-class entities in the software architecture and it should, at least before system deployment, be possible to add, remove and change architectural design decisions against limited effort.
Jan Bosch
Using Architectural Models at Runtime: Research Challenges
Abstract
One crucial aspect of high quality software engineering is the development of a well- defined software architectural model. Such a model describes the runtime manifestation of a software system in terms of its high level components and their interconnections. A good architectural model can be used as the basis for design-time analysis to determine whether a software system will meet desired quality attributes.
David Garlan, Bradley Schmerl
Maintainability through Architecture Development
Abstract
This position paper investigates on the need to put software architecture evaluations for maintainability in a broader perspective than is done until now.
Bas Graaf
An Architecture Description Language for Mobile Distributed Systems
Abstract
Mobile software applications have to meet new requirements directly arising from mobility issues. To address these requirements at an early stage in development, an architecture description language (ADL) is proposed, which allows to manage issues like availability requirements, mobile code, security, and replication processes. Aspects of this ADL, Con Moto, are exemplified with a case study from the insurance sector.
Volker Gruhn, Clemens Schäfer
Model Checking for Software Architectures
Abstract
Software architectures are engineering artifacts which provide high-level descriptions of complex systems. Certain recent architecture description languages (Asls) allow to represent a system’s structure and behaviour together with its dynamic changes and evolutions. Model checking techniques offer a useful way for automatically verifying finite-state Adl descriptions w.r.t. their desired correctness requirements. In this position paper, we discuss several issues related to the application of model checking in the area of software architectures, underlining the aspects of interest for current and future research (construction of state spaces, expression and verification of requirements, state explosion).
Radu Mateescu
Distilling Scenarios from Patterns for Software Architecture Evaluation – A Position Paper
Abstract
Software architecture (SA) evaluation is a quality assurance technique that is increasingly attracting significant research and commercial interests. A number of SA evaluation methods have been developed. Most of these methods are scenario-based, which relies on the quality of the scenarios used for the evaluation. Most of the existing techniques for developing scenarios use stakeholders and requirements documents as main sources of collecting scenarios. Recently, architectures of large software systems are usually composed of patterns and styles. One of the purposes of using patterns is to develop systems with predictable quality attributes. Since patterns are documented in a format that requires the inclusion of problem, solution and quality consequences, we observed that scenarios are, though as informal text, pervasive in patterns description, which can be extracted and documented for the SA evaluation. Thus, we claim that the patterns can be another source of collecting quality attributes sensitive scenarios. This position paper presents arguments and examples to support our claim.
Liming Zhu, Muhammad Ali Babar, Ross Jeffery

Invited Papers: European Projects in Software Architecture

Towards an MDA-Based Development Methodology
Abstract
This paper proposes a development methodology for distributed applications based on the principles and concepts of the Model-Driven Architecture (MDA). The paper identifies phases and activities of an MDA-based development trajectory, and defines the roles and products of each activity in accordance with the Software Process Engineering Metamodel (SPEM). The development methodology presented in this paper is being developed and applied in the European 5th Framework project MODA-TEL, which aims at assessing the applicability and potential of MDA in the context of telecom services and applications. The paper claims that the proposed methodology is general enough to be applicable to distributed applications in other domains as well.
Anastasius Gavras, Mariano Belaunde, Luís Ferreira Pires, João Paulo A. Almeida
Correct Development of Embedded Systems
Abstract
This paper provides an overview on the approach of the Ist Omega project for the development of correct software for embedded systems based on the use of UML as modelling language. The main contributions of the project are the definition of a useful subset of UML and some extensions, a formal dynamic semantics integrating all notations and a tool set for the validation of models based on this semantics.
Susanne Graf, Jozef Hooman
Expressing Domain Variability for Configuration
Abstract
Ideally, product development in a product line context should consist of selecting the appropriate components, assembling them and setting their parameters. That is, configuring the components. In industrial contexts, component variability varies exponentially with the hundreds, even thousands of products that are realised. Even such a simple direct configuration process, when applicable, is daunting. The problem is compounded when potential modification of the components or component selection based on their effect on overall product capability are taken into account.
The EU-IST project ConIPF is defining a methodology to support product line product development under these conditions with product configuration methods from artificial intelligence. It has defined CKML (Configuration Knowledge Modelling Language) to combine the aspects of feature and component variability and interaction with the procedural aspects of configuring features and components. This language is used to specify the development support environment and to assess the applicability of commercial configuration tools for that development environment.
This paper describes key elements of the ConIPF methodology and shows its relevance to architectural considerations.
John MacGregor
ArchWare: Architecting Evolvable Software
Abstract
This paper gives an overview of the ArchWare European Project. The broad scope of ArchWare is to respond to the ever-present demand for software systems that are capable of accommodating change over their lifetime, and therefore are evolvable. In order to achieve this goal, ArchWare develops an integrated set of architecture-centric languages and tools for the model-driven engineering of evolvable software systems based on a persistent run-time framework. The ArchWare Integrated Development Environment comprises: (a) innovative formal architecture description, analysis, and refinement languages for describing the architecture of evolvable software systems, verifying their properties and expressing their refinements; (b) tools to support architecture description, analysis, and refinement as well as code generation; (c) enactable processes for supporting model-driven software engineering; (d) a persistent run-time framework including a virtual machine for process enactment. It has been developed using ArchWare itself and is available as Open Source Software.
Flavio Oquendo, Brian Warboys, Ron Morrison, Régis Dindeleux, Ferdinando Gallo, Hubert Garavel, Carmen Occhipinti
The FABRIC Project
Abstract
The FABRIC project aims at the integration of middleware standards used in home networks to provide high quality streaming over a heterogeneous network without introducing new standards.
Peter van der Stok, Jan Jelle Boomgaardt, Helmut Burklin, Gabriele Cecchetti, Jean-Dominique Decotignie, Hermann de Meer, Gerhard Fohler, Johan Lukkien, Gerardo Rubino
Backmatter
Metadaten
Titel
Software Architecture
herausgegeben von
Flavio Oquendo
Brian C. Warboys
Ron Morrison
Copyright-Jahr
2004
Verlag
Springer Berlin Heidelberg
Electronic ISBN
978-3-540-24769-2
Print ISBN
978-3-540-22000-8
DOI
https://doi.org/10.1007/b97879