nach oben

2008 | Buch

Kapitel lesen Erstes Kapitel lesen

Software Engineering Research, Management and Applications

herausgegeben von: Roger Lee

Verlag: Springer Berlin Heidelberg

Buchreihe : Studies in Computational Intelligence

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten

Über dieses Buch

The 6th ACIS International Conference on Software Engineering, Research, Management and Applications (SERA 2008) was held in Prague in the Czech Republic on August 20 – 22. SERA ’08 featured excellent theoretical and practical contributions in the areas of formal methods and tools, requirements engineering, software process models, communication systems and networks, software quality and evaluation, software engineering, networks and mobile computing, parallel/distributed computing, software testing, reuse and metrics, database retrieval, computer security, software architectures and modeling. Our conference officers selected the best 17 papers from those papers accepted for presentation at the conference in order to publish them in this volume. The papers were chosen based on review scores submitted by members or the program committee, and underwent further rounds of rigorous review.

Inhaltsverzeichnis

Frontmatter

A Variability Management Strategy for Software Product Lines of Brazilian Satellite Launcher Vehicles

Summary

The Product Line approach offers to the software development benefits such as savings, large-scale productivity and increased product quality. The management of variability is a key and challenging issue in the development of the software product line and product derivation. This work presents a strategy for the variability management for software product line of Brazilian Satellite Launcher Vehicles. After modeling the variability, extracting them from use case diagrams and features, the proposed strategy uses a variation mechanism based on a set of Adaptive Design Patterns as support in the creation of variants. The proposed strategy uses as case study the software system of an existing specific vehicle, the Brazilian Satellite Launcher (BSL).

Luciana Akemi Burgareli, Selma S. S. Melnikoff, Mauricio G. V. Ferreira

Use of Questionnaire-Based Appraisal to Improve the Software Acquisition Process in Small and Medium Enterprises

Summary

This paper aims to show the application of a “Maturity Questionnaire” in a disciplined way. A Maturity Questionnaire typically is based on the Software Engineering Institute (SEI) published questionnaire; it represents a rigorous technique to collect data in a facilitated manner. The proposed questionnaire focuses in Supplier Agreement Management Process Area of the Capability Maturity Model Integration for Development v1.2. The objective is to obtain a snapshot of the Supplier Agreement Management Process (as a part of a process improvement program), to get a quick judgment of the capability level, and/or a precursor to a full assessment. It is expected that the application of the questionnaire will help to identify those practices that are performed but not documented, which practices need more attention and which are not implemented due to bad management or unawareness.

Ivan Garcia, Carla Pacheco, Pavel Sumano

Deploying Component–Based Applications: Tools and Techniques

Summary

Software deployment comprises activities for placing an already developed application into its operational environment and making it ready for use. For complex component-based applications that constitute many heterogeneous components with various hardware and software requirements, this deployment process can become one of the most burning challenges. In this situation, it is difficult to manually identify a valid deployment configuration that satisfies all constraints. Thus, automated tools and techniques are required to do the complex process of software deployment. To address this requirement, a variety of tools and techniques that support different activities of the deployment process have been introduced in both industry and academia. This paper aims to provide an overview of these tools and techniques.

Abbas Heydarnoori

Towards Improving End-to-End Performance of Distributed Real-Time and Embedded Systems Using Baseline Profiles

Summary

Component-based distributed real-time and embedded (DRE) systems must be properly deployed and configured to realize an operational system that meets its functional and quality-of-service (QoS) needs. Different deployments and configurations often impact systemic QoS concerns, such as end-to-end response time. Traditional techniques for understanding systemic QoS rely on complex analytical and simulation models, however, such techniques provide performance assurance at design-time only. Moveover, they do not take into account the complete operating environment, which greatly influences systemic performance.

This paper presents a simple technique for searching for deployments that improve performance along a single dimension of QoS concern, such as response time. Our technique uses baseline profiles and experimental observations to recommend new deployments. The results indicate that we are able to use baseline profiles to converge towards solutions that improve systemic performance.

James H. Hill, Aniruddha Gokhale

Preserving Intentions in SOA Business Process Development

Summary

Business processes play an important role in Service-Oriented Architectures. Commonly, the business processes are designed in the Business Process Modeling Notation (BPMN), which allows their development even by persons without programming skills. Being abstract and high-level BPMN is not suitable for direct execution, though. The natural choice for implementing business processes is the Business Process Executable Language (BPEL), which is directly executable, but it is also a programming language that requires programming skills in order to be used. This dichotomy is typically solved by transforming BPMN into BPEL. However, this transformation is a complex task. There have been developed a number of transformation methods but their common problem is either incompleteness or loss of intentions, which makes BPEL rather difficult to modify and debug as well as to propagate changes back to BPMN. In this paper we address this problem by presenting a non-trivial enhancement of the existing transformation algorithm [14]. Our approach provides a complete transformation while preserving a large set of intentions expressed in the BPMN description, which makes it also suitable in the context of model-driven development.

Lucia Kapová, Tomáš Bureš, Petr Hnětynka

Quality Aware Flattening for Hierarchical Software Architecture Models

Summary

Software architecture (SA) models play an important role in model-driven development for complex software systems. A platform-independent SA model (PIM) is usually organized as a hierarchical model via composite components for complexity control and recursive composition. However, platform-specific SA models (PSM) have to be flat because many platforms (e.g. CORBA and J2EE) do not support composite components directly. Therefore, flattening hierarchical SA models becomes a challenging step when transforming PIM to PSM. Current efforts only care about preserving the functionality of composite components during the transformation; little attention is paid to the qualities of the resulting PSM (e.g. comprehensibility, redundancy and consistency) and those of the transformation process (e.g. cost and automaticity). This paper presents a systematic approach to flattening hierarchical SA models while controlling the qualities of the resulting models and the transformation process. Our quality model can also be used as criteria to compare existing flattening approaches.

Gang Huang, Jie Yang, Yanchun Sun, Hong Mei

Case Study on Symbian OS Programming Practices in a Middleware Project

Summary

In this case study, we provide practical guidelines for Symbian OS software development by analyzing our experiences from a three-year mobile software research project focused on the creation of networking middleware and collaborative applications. The practices that we either conducted in the project or conceived in retrospect are summarized, and re-applicable patterns of activity in development work are identified. Based on the observations, guidelines for essential design and implementation activities are derived and potential pitfalls are addressed through example cases to provide experience-backed information for Symbian OS software developers. Among other things, the guidelines advocate the use of platform-independent solutions, the minimization of project dependencies, and the representation of complex activity sequences in a human-readable form as a routine practice.

Otso Kassinen, Timo Koskela, Erkki Harjula, Mika Ylianttila

Automatic Extraction of Pre- and Postconditions from Z Specifications

Summary

Formal methods are especially useful in writing requirements specification of safety-critical systems due to their unambiguous and precise syntax and semantics. They also hold a special place in software testing phase because formal specifications provide a good opportunity for automation of the testing process. Many formal specification based software testing techniques use Finite State Machines (FSMs) because they are quite useful in test sequencing, test case generation and test case execution. Therefore, extraction of a FSM from the formal specification is an interesting problem. Although some techniques for FSM generation from formal specifications exist in the literature but none of them is fully automated. A major challenge in automatic generation of a FSM from Z specification is the identification and extraction of pre- and postconditions, since it is difficult to separate the input and output predicates when intermediate variables are used in the specification. In this paper, we present an automated approach to separate input and output predicates and extract pre- and postconditions from these predicates for a given Z operation schema. The proposed approach is supported by a tool and is also demonstrated on an example.

Muhammad Bilal Latif, Aamer Nadeem

Towards a SPEM v2.0 Extension to Define Process Lines Variability Mechanisms

Summary

Software organizations need to adapt their processes to each new project. Although Software Process Lines are the most suitable approach for the design of processes which are adapted to different contexts, SPEM does not include the appropriate mechanisms for modelling them. The objective of this paper is to suggest a SPEM extension which will support the variability implied in a Software Process Line. New variability mechanisms based on the use of Variation Points and Variants, by means of which the variability necessary in a Process Line is represented, have been proposed. The new mechanisms that we shall introduce into SPEM, will allow it to model Software Process Lines. From these lines, the generation of processes adapted to each context will simplify the selection of the appropriate variants for each variation point.

Tomás Martínez-Ruiz, Félix García, Mario Piattini

Genetic Algorithm and Variable Neighborhood Search for Point to Multipoint Routing Problem

Summary

Routing of data in a telecommunication network is important due to the vast amount of data flow in the network. Message Scheduling Problem (MSP) is an important aspect of data routing. It is the process of scheduling a set of requests where each set has a single source and multiple destinations. In this paper, we propose a hybrid Genetic Algorithm to determine the order of request to be scheduled. The proposed algorithm embeds a different Steiner Tree algorithm than those reported in [3]. The second part of the study involves designing three algorithms based on the Variable Neighborhood Search. These algorithms differ in the local search heuristics employed in searching the neighborhood. The performance of these algorithms are compared on a modified set of data taken from the OR library.

Noor Hasnah Moin, Huda Zuhrah Ab. Halim

Observation-Based Interaction and Concurrent Aspect-Oriented Programming

Summary

In this paper we propose the use of event observation as first class concept for the composition of software components. The approach can be applied to any language based on concurrent components, and we illustrate it with examples on a concrete language (Omega UML) used in the specification of real-time systems. To motivate the proposal, we discuss how it may be used to support a very general form of aspect-oriented programming.

Iulian Ober, Younes Lakhrissi

Modular Compilation of a Synchronous Language

Summary

Synchronous languages rely on formal methods to ease the development of applications in an efficient and reusable way. Formal methods have been advocated as a means of increasing the reliability of systems, especially those which are safety or business critical. It is still difficult to develop automatic specification and verification tools due to limitations like state explosion, undecidability, etc... In this work, we design a new specification model based on a reactive synchronous approach. Then, we benefit from a formal framework well suited to perform compilation and formal validation of systems. In practice, we design and implement a special purpose language (le ) and its two semantics : the behavioral semantics helps us to define a program by the set of its behaviors and avoid ambiguousness in programs’ interpretation; the execution equational semantics allows the modular compilation of programs into software and hardware targets (C code, Vhdl code, Fpga synthesis, Verification tools). Our approach is pertinent considering the two main requirements of critical realistic applications : the modular compilation allows us to deal with large systems, the model-driven approach provides us with formal validation.

Annie Ressouche, Daniel Gaffé, Valérie Roy

Describing Active Services for Publication and Discovery

Summary

Services in contemporary SOA are typically considered to be of passive nature, providing functionality that solely executes upon invocation, while active services contain functionality that cannot be limited to initiative in a one direction only. We have earlier introduced the notion of active services in the context of SOA, concentrating on modeling these using UML 2 Collaborations. Here we suggest how active services and their behavior can be described for publication and discovery in the context of SOA, focusing on the service description as a behavioral contract.

Haldor Samset, Rolv Bræk

Refactoring-Based Adaptation of Adaptation Specifications

Summary

When a new release of a component replaces one of its older versions (component upgrade), changes to its interface may invalidate existing component-based applications and require adaptation. To automate the latter, developers usually need to provide adaptation specifications. Whereas writing such specifications is cumbersome and error-prone, maintaining them is even harder, because any evolutionary component change may invalidate existing specifications. We show how the use of a history of structural component changes (refactorings) enables automatic adaptation of existing adaptation specifications; the latter are written once and need not be maintained.

Ilie Şavga, Michael Rudolf

Resolving Complexity and Interdependence in Software Project Management Antipatterns Using the Dependency Structure Matrix

Summary

Software project management antipatterns are usually related to other antipatterns and rarely appear in isolation. This fact introduces inevitable interdependence and complexity that can not be addressed using existing formalisms. To reduce this complexity and interdependence, this paper proposes the Dependency Structure Matrix (DSM) as a method that visualizes and analyzes the dependencies between related attributes of software project management antipatterns. Furthermore, DSM provides a methodology that can be used to visualize three different configurations that characterize antipatterns and resolve cyclic dependencies that are formed between interdependent antipattern attributes. The proposed framework can be used by software project managers in order to resolve antipatterns that occur in a software project in a timely manner. The approach is exemplified through a DSM of 25 attributes of 16 related software project management antipatterns that appear in the literature and the Web.

Dimitrios Settas, Ioannis Stamelos

An Embedded System Curriculum for Undergraduate Software Engineering Program

Summary

There is an increasing demand for well trained software talents in embedded application fields. Because embedded systems usually have complex requirements, higher standards are set for qualified embedded engineers’ technical and soft skills. Considering the challenges imposed to the embedded system education, and given the resource constraints in universities, in this paper, we propose a practical embedded system curriculum for software engineering undergraduate programs. This curriculum consists of software engineering fundamentals, domain fundamentals and embedded system core courses. The two-phase embedded system core courses are aimed at improving students’ abstracting and hands-on abilities in solving embedded system problems. The contents of these courses are selected according to the requirements from industry on the qualifications of embedded engineers. The implemented curriculum provides an proactive learning setting accepted by students. Close cooperation with industry is essential to the successful implementation of this curriculum.

Gang Shen

Model Checking for UML Use Cases

Summary

A use case driven approach is one of the most practical approaches in object orientation. UML use case diagrams and their descriptions written in a natural language are used in this modeling. Even though this approach provides us with convenient ways to develop large scale software and systems, it seems difficult to assure the correctness of the models, because of insufficient formalization in UML. This paper proposes a formal model verification process for UML use case models. In order to exclude ambiguity from the models, they are firstly formalized using the first order predicate logic. These logic based models are then transformed in the form of Promela code, so that they can be verified using the Spin model checker. A Promela code must be composed based on state transitions, whereas the logic based use case models do not explicitly include the states and their transitions. Therefore we introduce a state identification process in the logic based use case models. A supermarket checkout system is used to show how the proposed process works.

Yoshiyuki Shinkawa

Backmatter

Titel: Software Engineering Research, Management and Applications
herausgegeben von: Roger Lee
Verlag: Springer Berlin Heidelberg
Electronic ISBN: 978-3-540-70561-1
Print ISBN: 978-3-540-70774-5
DOI: https://doi.org/10.1007/978-3-540-70561-1

Premium Partner

Marktübersichten

Die im Laufe eines Jahres in der „adhäsion“ veröffentlichten Marktübersichten helfen Anwendern verschiedenster Branchen, sich einen gezielten Überblick über Lieferantenangebote zu verschaffen.

Zur Marktübersicht