7

TOWARDS A SEMIFORMAL DEVELOPMENT METHODOLOGY FOR EMBEDDED SYSTEMS

Lucas Cordeiro, Raimundo Barreto and Meuse Oliveira

In recent years, discrete control systems play an important role in the development and advancement of modern civilization and technology. This kind of system maybe classified as an embedded real-time system and requires rigorous methodologies to develop the software that is under stringent hardware constraints. Therefore, the proposed development methodology adapts agile principles and patterns in order to build embedded control systems focusing on the issues related to the system's constraints and safety. Moreover, platform-based design approach is used to balance costs and time-to-market in view of performance and functionality constraints. We conclude that the proposed methodology reduces significantly design time and cost as well as leads to better software modularity and reliability.

10

METRICS FOR A MODEL DRIVEN DEVELOPMENT CONTEXT

Motoshi Saeki and Haruhiko Kaiya

In a Model Driven Development context, in addition to the metrics of models themselves, the metrics of model transformation should be considered in order to measure its various characteristics such as quality. In this paper, we propose the technique to define the metrics of model transformation using a meta-modeling technique and a graph rewriting techniques. The meta-modeling technique is used for defining model-specific metrics, while graph rewriting rules formalize transformation. The values of model-specific metrics to be calculated are attached to graph rewriting rules, and can be evaluated and propagated between the models during the transformation. The evaluation and propagation methods can be defined within the graph rewriting rules, and their evaluation and propagation result in the metric values of the transformation. Furthermore the paper includes the example of transforming object models into relational DB models in order to show the usefulness of our approach.

13

PROGRAMMING IN PROTOCOLS - A Paradigm of Behavioral Programming

Ashley McNeile and Ella Roubtsova

We present work in the creation of a programming paradigm based on the event protocols of objects. Our claim is this results in a high level executable language that bridges the gap between behavioral models and code for a large class of systems. The language is based on the idea of composing partial behavioral descriptions using process algebraic techniques. We show that the concepts forming the basis of this language shed light on questions relating to the description of behavior in object models, particularly in the areas of reuse, abstraction, and behavioral conformance.

21

MODELING QUALITY ATTRIBUTE VARIABILITY

Eila Niemelä, Antti Evesti and Pekka Savolainen

Due to the emerging service orientation, the importance of quality aspects and the ability to manage the changing quality requirements of a service have raised the question of how to explicitly define quality requirements and how to assure that quality requirements are handled in the same way by all service developers. Variation related to evolution qualities is managed by applying appropriate styles and patterns at design time but there is no solution for describing variation of execution qualities, such as reliability and security, in architecture models. The contribution of this paper is a novel approach, which enhances quality-driven architecture design by ontology orientation and allows 1) to define metrics for quality attributes as quality ontologies, 2) to specify execution qualities as quality profiles according to a quality variability model and quality ontologies defined, and 3) to model quality properties as an integrated part of software architecture. The use of Unified Modeling Language (UML) and its extension mechanisms guarantees that the quality profiles are specified in a uniform, understandable and sharable way and that the design specifications can be used as service descriptions exploited in run-time service adaptation. The new approach is supported by an integrated tool chain developed on top of the Eclipse platform.

28

CASE STUDY: RUNNING TEST CASES FOR SEQUENTIAL PROGRAMS IN PARALLEL IN A CLUSTER ENVIRONMENT

P. Kroha and V. Vychegzhanin

Testing a software system consists of a test case construction and of running and evaluating them, i.e. comparing expected results with obtained results. Because the set of test cases is usually very large, some methods of automation may be used to run them. Usually, test cases run on the same machine where the tested software system should run later. In our case, we run the test cases of a software system for a sequential computer on a cluster in parallel. The goal is to accelerate the process of running and evaluating tests. In this paper we describe the architecture of our test execution tool, experiments, and obtained results concerning performance and efficiency of test automation of sequential programs in a cluster environment.

47

AUTOMATING WORKFLOWS IN MEDIA PRODUCTION - Building an Infrastructure for a Service Oriented Architecture with a Business Process Management System

Steven Van Assche, Dietrich Van der Weken, Bjorn Muylaert, Stein Desmet and Bruno Volckaert

This paper describes our experiences with building an infrastructure for automating workflows in media production based on service oriented architecture (SOA). An SOA deals with distributed software services that interact with each other. By adopting an SOA in cooperation with a Business Process Management System (BPMS) we aimed at increased efficiency and control, shorter setup times, and increased flexibility. We used open source or free products where possible, and the end result is a professional architecture suitable for small-scale to medium-scale media enterprises. Key concepts are the use of JMS as messaging layer for asynchronous, long-running service interactions (which are typical in a media production environment), the orchestration of services leading to processes with more business meaning, the graphical description of these business processes followed by the automatic generation of executable code (BPEL), support for human interactions in the processes and compliance with the WS-I Basic Profile 1.1. Our architecture is illustrated with a use case in which we automated a process that deals with the intake, review, transcoding and publishing of user-generated content.

52

WORKFLOW AUTOMATION FOR SYSTEM ARCHITECTING

Markku Turunen, Kari Leppänen and Sari Leppänen

Managing the ever-growing complexity of even mass-market products, such as mobile phones, is becoming increasingly hard without the adoption of improved system development methods, such as model-based development. To allow industrial use of such methods, tools that are able automate development tasks as far as possible are needed. In this paper, we present a partly automated system design flow based on the Lyra method with UML 2.0 language and Telelogic Tau G2 modeling tool. We discuss how the tool was extended to support automation of some central tasks in Lyra and show a running example of the design flow. In the example, a telephony functionality of a mobile device is modeled producing an executable specification for the system. The efficiency gains from the automation are promising.

54

SEMANTIC APPLICATION DESIGN

Philippe Larvet

This paper presents a process to determine the design of an application by optimizing the network of semantic components that compose the application. An application has to implement a given specification. We consider this specification is made of atomic requirements, logically linked together. On one hand, each requirement is expressed in natural language; this expression is seen as the semantic description of the requirement. On the other hand, the off-the-shelf components from which we want to build the application can also be described through a semantic description, which we call a "semantic card". Within this context, we consider the a component implements a requirement if the "semantic distance" between their two semantic descriptions is minimal. Consequently, building an application consists in building and optimizing the logical network of all the semantic optimal couples "requirement-component". The paper presents such a building and optimization automatic process, of which one of the main advantages is to derive systematically the finding and assembly of components from the written specification of the application.

58

EVALUATION OF BPMN MODELS QUALITY - A Family of Experiments

Elvira Rolón, Félix García, Francisco Ruiz, Mario Piattini, Corrado Aaron Visaggio and Gerardo Canfora

The design phase is of special importance in the development of a business process. This phase refers to the modeling, handling and redesigning of processes, but when maintenance tasks have to be performed, this stage can be rather complicated. It implies a heavy investment of time and resources, since it involves both technical developers and business analysts. Moreover, process modeling should permit not only the production of models which are understandable to the users, but also the early detection and correction of errors. All of this adds to the overall quality of the model. We therefore propose a set of measures with which to assess the structural complexity of conceptual business process models. Our aim is to obtain useful indicators for when we are carrying out maintenance tasks on these models. Another goal is to make it possible to carry out an early evaluation of given quality properties of the model. With the development of a family of experiments, it has been possible to discover a set of measures which may be useful in assessing the usability and maintainability of conceptual business process models.

63

IMPLEMENTING ORGANIC COMPUTING SYSTEMS WITH AGENTSERVICE

Florian Nafz, Frank Ortmeier, Hella Seebach, Jan-Phillip Steghöfer and Wolfgang Reif

Designing and implementing Organic Computing systems is typically a difficult task. To facilitate the construction a design pattern for Organic Computing systems has been developed. This organic design pattern (ODP) helps in modeling and designing a broad class of Organic Computing systems. This paper focuses on the implementation of Organic Computing systems with the help of this pattern. The core idea is to provide a generic implementation by mapping ODP artifacts to artifacts of a multi-agent framework. The used framework -- AgentService -- is one of the few C# multi-agent frameworks. In this paper a possible implementation as well as benefits and limitations are described.

64

ON-THE-FLY INTERPRETATION OF TEST CASES IN AN AUTOMATICALLY GENERATED TTCN-3 TEST SUITE

Winfried Dulz

The TestUS framework (Statistical Testing based on use case scenarios), developed at the University of Erlangen-Nuremberg, offers unique techniques and tools to obtain a TTCN-3 test suite starting from UML 2.0 requirement definitions. Use case diagrams that contain functional and non-functional requirements are transformed to a Markov Chain usage model (MCUM) in a completely automatic approach. The annotation of outgoing MCUM transitions by probabilities in the derived UML2 protocol state machine enables the generation of TTCN-3 test cases according to the expected occurrence frequencies of the specified usage pattern. One drawback in our previous approach resulted from the fact that there exist numerous test cases for a realistic SUT (System under Test). Creating and in particular compiling the TTCN-3 test suite took a long time. Consequently, we decided for the TestUS framework to map the MCUM directly into the executable test suite. Thus, the previous generation of test cases to derive the test suite is no longer necessary. Test cases and the evaluation of test verdicts are now interpreted on-the-fly in an executable TTCN-3 test suite that represents the MCUM. We also proved the new concept by means of a realistic case study for testing a DECT communication system. The previous compilation time for the dedicated DECT test suite in the order of 20 hours was reduced to only 15 minutes and we got a TTCN-3 test suite at the end that interprets as many test cases as one likes for the DECT system on-the-fly.

65

AGILE METHODS AND REQUIREMENTS ENGINEERING IN CHANGE INTENSIVE PROJECTS

Martin Fritzsche

In this paper we discuss how well agile methods can deal with requirements related issues in change intensive projects. Five agile methods are considered: eXtreme Programming, Scrum, Crystal, Dynamic Systems Development Method and Adaptive Software Development. We analyze how well these methods implement the basic goals of requirements engineering, how they counteract or support the occurrence of requirements changes and how they cope with problems arising from changing requirements. We show that agile methods provide a valid approach for requirements related issues, but also identify their weaknesses.

68

EVALUATING MAS ENGINEERING TOOLS

Emilia Garcia, Adriana Giret and Vicente Botti

Recently a great number of methods and frameworks to develop multiagent systems have appeared. Nowadays there no an established framework to evaluate environments to develop multiagent system and choosing between one framework or another is a difficult task. The main contributions of this paper are: (1) an analysis of the state of the art in the evaluation of MAS engineering; (2) a complete list of criteria that allows the evaluation of multiagent system development environments;(3) a quantitative evaluation technique;(4) an evaluation of the methodology Ingenias and its development environment using this evaluation framework.

70

PROCESS-CENTRIC ENTERPRISE MODELING & MANAGEMENT (ProCEM®)

Erich Ortner

The shortage of skilled IT-staff as well as the technological possibilities offered by Service-oriented Architectures (SOA) and Web 2.0 applications, leads us to the following consequences: working processes, job engineering and labor organization are going to be modeled and therefore made digital in the sense of IT-support. This goes along with modeling working processes being independent from the individual employee in areas to be rationalized resp. not to be staffed by qualified specialists. Hence, there will be a worldwide net based selection of those who are able and skilled to fulfill modeled work like e.g. “handling a damage event” or “creating an optimized data structure for master data” by means of the Unified Modeling Language (UML) in the most effective and efficient way. An enterprise will therefore neutrally manage its IT-services (application programs) taking place as computer supported work equipment in any working process being located anywhere in the world without assigning it first to a specific performer. By doing so it is possible to control and dynamically execute working processes globally based on the division of labor, and on a data base supported administration of “bills of activities” by means of the World Wide Web. All that requires new and dynamic – in the sense of component based – job descriptions exceeding today’s established skill and task management by far.

71

CHALLENGES FOR AGILE DEVELOPMENT OF COTS COMPONENTS AND COTS-BASED SYSTEMS - A Theoretical Examination

Iva Krasteva, Per Branger and Rikard Land

Component-based software engineering has had great impact in the desktop and server domain and is spreading to other domains as well, such as embedded systems. Agile methods is another approach which have gained much attention in recent years, mainly for smaller-scale, not so critical development on commission. Both promise to increase system quality, development speed and flexibility, but so far little or nothing has been published on the combination of the two approaches. This paper presents a comprehensive analysis of the applicability of the agile approach in the development processes of COTS and COTS-based systems. The study method is a systematic theoretical examination and comparison of the fundamental concepts and characteristics of these approaches. The findings are: first, an enumeration of identified contradictions between the approaches, and solution suggestions how to bridge these incompatibilities to some extent. Second, the paper provides some more general comments, considerations, and application guidelines concerning the introduction of agile principles into the development of components or component-based systems. This study thus forms a framework which will guide further empirical studies.

72

SOFTWARE SEMANTIC PROVISIONING - Actually Reusing Software

Savino Sguera, Philippe Ombredanne, Armando Stellato and Maria Teresa Pazienza

Delivering component-oriented architectures is a well-established trend in software engineering and development. Assessing software reuse scenarios goes much beyond the usual “build vs buy” dilemma that so often occurs in early stages of a software process: scouting, comparing, choosing and integrating the right set of components meeting project’s requirements is still an ad-hoc and error-prone task, performed by developers with little or no frameworks and tools to support them. This paper describes the SSP (Semantics-Driven Software Provisioning) project, funded in its early stages by GoogleTM Inc., developed during the Google Summer of CodeTM 2007 program, and incubated by the Eclipse Software Foundation; the project aims to provide an ontological description of the software domain to underlie a semantic web framework for supporting developers in scouting and provisioning software components. A prototypical RESTful semantic repository, and an Eclipse plug-in consuming the repository services have been implemented and will be discussed.

77

BALANCED GOALCARDS - Combining Goal Analysis and Balanced Scorecards

Alberto Siena, Alessio Bonetti and Paolo Giorgini

Today's Information Systems are complex systems that have to deal with a variety of different and potentially conflicting needs. Capturing their strategic requirements is a critical activity, as it must answer at the same time to software and corporate goals. In this paper, we introduce the economic foundations of strategic requirements. We propose a novel conceptual framework for requirements modeling and validation, based on economic and business strategy theory. The soundness of the framework is also evaluated, by presenting the result of its application to a real case study.

84

RANDOM VS. SCENARIO-BASED VS. FAULT-BASED TESTING - An Industrial Evaluation of Formal Black-Box Testing Methods

Martin Weiglhofer and Franz Wotawa

Given a formal model of a system under test there are different strategies in order to systematically derive test cases from such a model. These strategies are based on different underlying testing objectives and concepts. Obviously, their usage has impact on the generated test cases. In this paper we evaluate random, scenario-based and fault-based test case generation strategies in the context of an industrial application and assess the advantages and disadvantages of these three strategies. The derived test cases are evaluated in terms of coverage and in terms of the detected errors on a commercial and on an open source implementation of the Voice-Over-IP Session Initiation Protocol.

85

ON THE PERFORMANCE OF FAULT SCREENERS IN SOFTWARE DEVELOPMENT AND DEPLOYMENT¤

Rui Abreu, Alberto González, Peter Zoeteweij and Arjan J. C. van Gemund

Fault screeners are simple software (or hardware) constructs that detect variable value errors based on unary invariant checking. In this paper we evaluate and compare the performance of two low-cost screeners (Bloom filter, and range screener) that can be automatically integrated within a program, while being automatically trained during the testing phase. While the Bloom filter has the capacity of retaining virtually all variable values associated with proper program execution, this property comes with a much higher false positive rate per unit training effort, compared to the more simple range screener, that compresses all value information in terms of a single lower and upper bound. We present a novel analytic model that predicts the false positive and false negative rate for both type of screeners. We show that the model agrees with our empirical findings. Furthermore, we describe the application of both screeners, where the screener output is used as input to a fault localization process that provides automatic feedback on the location of residual program defects during deployment in the field.

88

VISUAL COMPOSITION OF COMPONENT SYSTEMS

Hans Albrecht Schmid and Christian Martin Baranowski

Component composition has been over a decade a concept that supplements classical reference-based programming, but does not replace it to a larger extent. Though a new generation of component languages like ArchJava has pushed forwards composition from subcomponents, these languages fall back into class-based programming of methods when Java program code is to be written e.g. as a filter among subcomponents. To allow for a seamless composition process, we have developed the component language CompJava that introduces component fragments and plugs as means for composing a component both from subcomponents and structured units of code. In parallel, we have extended UML 2 component diagrams by the newly introduced concepts. This allows visualizing the compositional structure of components in order to better understand and communicate it. A graphical editor, called CompJava Designer, allows constructing relatively complex and distributed component systems by a seamless visual composition process.

94

MODELING OF SERVICE ORIENTED ARCHITECTURE - From Business Process to Service Realisation

Marek Rychlý and Petr Weiss

This paper deals with modeling of Service-Oriented Architecture (SOA). SOA is an architectural style for analysis, design, maintaining and integration of enterprise applications that are based on services. Services are autonomous platform-independent entities that enable access to one or more capabilities, which are accessible by a provided interface. The goal of SOA is to align business and IT architectures. Hence, a new designed service has to meet business requirements that are traditionally specified by a business process diagram. The approach, presented in this paper, helps to bridge the semantic gap between business requirements and IT architecture by using a method for transformation of business processes diagrams into services diagrams. In particular, the method deals with process realisation based on services, and it describes choreographing of services towards fulfilling business goals.

115

BUSINESS PROCESS MODELING AWARE TO THE ENVIRONMENT CHANGES - A Pattern Driven Approach

Nicola Boffoli, Daniela Castelluccia, Fabrizio Maria Maggi and Roberto Rutilo

Nowadays enterprises perform in an extremely competitive business environment, therefore business processes, although complex, must be highly flexible to react to the new demands. This purpose implies that these processes should be continuously maintained through a flexible modeling. This paper addresses this problem and provides a process modeling approach able to govern the high variability of the environment parameters affecting the processes in use, through the well known pattern paradigm and the decision tables formalism. Furthermore, the authors discuss the experience of the proposed approach in a real case. Results are encouraging and drive further investigations in such a way.

119

TYPED ABSTRACTIONS FOR CLIENT-SERVICE INTERACTIONS IN OSGI

Sven De Labey and Eric Steegmans

The Open Services Gateway initiative (OSGi) is a successful attempt to bridge the gap between Java and Service Oriented Computing. OSGi provides an LDAP-based query language for fine-tuning service retrieval and offers an eventing mechanism that signals changes to a service’s lifecyle to all clients depending on that service. Nonetheless, a number of challenges remain unsolved. OSGi’s service query language, for instance, bypasses important compile-time guarantees on the syntactical correctness of queries and the language works only for properties that never change during the lifetime of a service. What programmers need, however, is a statically type-checked, robust query language that takes into account dynamically evolving, volatile service characteristics. A second problem is that the lifecycle management system requires programmers to write a considerable amount of boilerplate logic for reacting to service events. This obfuscates the business logic, which in turn decreases code comprehension and increases the odds for introducings bugs when implementing client-service interactions. This paper evaluates OSGi as a platform for programming client-service interactions in Java. After focusing on a number of shortcomings of OSGi’s integrated service query language and its lifecycle management system, we propose a solution based on a programming language extension. After the conceptual definition of these new language concepts, we show how they can be transformed to regular Java code without losing interoperability with the OSGi standard.