nach oben

2013 | Buch

Kapitel lesen Erstes Kapitel lesen

Evaluation of Novel Approaches to Software Engineering

7th International Conference, ENASE 2012, Warsaw, Poland, June 29-30, 2012, Revised Selected Papers

herausgegeben von: Leszek A. Maciaszek, Joaquim Filipe

Verlag: Springer Berlin Heidelberg

Buchreihe : Communications in Computer and Information Science

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

Einloggen, um Zugang zu erhalten

Über dieses Buch

This book constitutes the thoroughly refereed proceedings of the 7th International Conference on Evaluation of Novel Approaches to Software Engineering, ENASE 2012, held in Wroclaw, Poland, in June 2012. The 11 full papers presented were carefully reviewed and selected from 54 submissions. The papers cover various topics in software engineering and focus on the comparison of novel approaches with established traditional practices and by evaluating them against software quality criteria.

Inhaltsverzeichnis

Frontmatter

Papers

Frontmatter

Dynamic Symbolic Execution Guided by Data Dependency Analysis for High Structural Coverage

Abstract

Dynamic symbolic execution has been shown to be an effective technique for automated test input generation. When applied to large-scale and complex programs, its scalability however is limited due to the combinatorial explosion of the path space. We propose to take advantage of data flow analysis to better perform dynamic symbolic execution in the context of generating test inputs for maximum structural coverage. In particular, we utilize the chaining mechanism to (1) extract precise guidance to direct dynamic symbolic execution towards exploring uncovered code elements and (2) meanwhile significantly optimize the path exploration process. Preliminary experiments conducted to evaluate the performance of the proposed approach have shown very encouraging results.

TheAnh Do, A. C. M. Fong, Russel Pears

Using Roles as Units of Composition

Abstract

A single decomposition strategy cannot capture all aspects of a concept, so we need to extend Object Oriented Decomposition (today most used strategy). We propose roles as a way to compose classes that provides a modular way of capturing and reusing those concerns that fall outside a concept’s main purpose, while being a natural extension of the OO paradigm. Roles have been used successfully to model the different views a concept provides and we want to bring that experience to the programming level. We discuss how to make roles modular and reusable. We also show how to compose classes with roles using JavaStage, our role supporting language. To validate our approach we developed generic and reusable roles for the Gang of Four patterns. We developed reusable roles for 10 out of 23 patterns. We also were able to use some of these roles in JHotDraw framework.

Fernando Barbosa, Ademar Aguiar

Extending Service Selection Algorithms with Interoperability Analysis

Abstract

Application development by integration of existing, atomic services reduces development cost and time by extensive reuse of service components. In Service Oriented Architecture, there exist alternative versions of services supplying the same functionality but differing in Quality of Service (QoS) attributes, which enables developers to select services with optimal QoS. Existing algorithms of service selection focus on the formal model of the composite service refraining from interoperability issues that may affect the integration process. In this paper, the author proposes a methodology that extends existing service selection algorithms by introducing additional constraints and processing rules representing interoperability. Two computational models are considered: the graph-based model and the combinatorial model. The extensions enable a straightforward application of a wide range of existing algorithms. The paper also describes a system that implements chosen service selection algorithms together with appropriate extensions for interoperability analysis.

Paweł Kaczmarek

Correlation of Business Activities Executed in Legacy Information Systems

Abstract

Reverse engineering techniques are commonly applied for discovering the underlying business processes. These techniques often rely on event logs recorded by process-aware information systems. Apart from these, there are many non-process-aware systems without mechanisms for recording events. Certain techniques for collecting events during the execution of non-process-aware systems have been proposed to enable the discovery of business processes from this kind of systems. In these techniques the correlation of events into their execution instance constitutes a big challenge since the business process definitions supported by non-process systems are implicit. This paper presents a correlation algorithm which works together a technique for obtaining event logs from non-process-aware systems. The event correlation algorithm is applied to the events dataset collected at runtime to discover the best correlation conditions. Event logs are then built using such conditions. The applicability of the proposal is demonstrated through a case study with a real-life system.

Ricardo Pérez-Castillo, Barbara Weber, Mario Piattini

Detection of Infeasible Paths: Approaches and Challenges

Abstract

Each execution of the program follows one path through its control flow graph. In general, a program has a large number of such paths. Most of the programs have an infinite number of these paths. Regardless of the quality of the program and the programming language used to develop it, in general, a sizable number of these paths are infeasible—that is no input can exercise them. Detection of these infeasible paths has a key impact in many software engineering activities including code optimization, testing and even software security. This paper reviews the approaches for detecting infeasible paths, discusses the challenges and proposes to revisit this important problem by considering also empirical aspect in conjunction to formal program analysis.

Sun Ding, Hee Beng Kuan Tan

A Formal Monitoring Technique for SIP Conformance Testing

Abstract

Formal approaches provide many keys to efficiently test the conformance of communicating protocols. Active and passive testing techniques are two main sets of these approaches. Compare to active testing, passive testing techniques are used whenever the system cannot be interrupted, or its interfaces are unavailable to access. Under such conditions, communication traces are extracted from points of observation and compared with the expected conformance requirements formally specified as properties. This paper presents a novel monitoring approach, aiming at formally specifying protocol properties in order to check them on real execution traces. A prototype is developed and experienced based on the algorithms defined in a previous paper. Experiments are presented through a set of IMS/SIP properties and numerous execution traces in order to evaluate and assess our technique. The relevant verdicts and discussions are provided at the end.

Xiaoping Che, Felipe Lalanne, Stephane Maag

Unified Modeling of Static Relationships between Program Elements

Abstract

Reverse engineering creates primary models of software systems, representing their program elements and the relationships between them. According to the programming language or paradigm, these program elements are functions, variables, classes, methods, etc. The primary models are then used for different analysis purposes such as: impact analysis, modularization analysis, refactoring decisions, architectural reconstruction. Particularities of the programming language or paradigm do not affect the essence of these higher-level analysis tasks. Thus, having a unitary way of modeling program elements and their relationships is essential for the reuse and integration of higher-level analysis tools.

This work proposes a meta-model which provides a unitary way of describing static relationships between program elements. It defines a set of abstract concepts that can be mapped to program elements of both the object-oriented as well as the procedural programming paradigms. The proposed meta-model is validated by the implementation of model extraction tools from programs written in Java, C# (CIL) and ANSI C. The utility of the proposed meta-model has been shown by a number of different analysis applications that use it successfully.

Ioana Şora

Social Adaptation at Runtime

Abstract

One of the main goals of software adaptation is that users get their dynamic requirements met efficiently and correctly. Adaptation is traditionally driven by changes in the system internally and its operational environment. An adaptive system has to monitor and analyse such changes and, if needed, switch to the right behaviour to meet its requirements. In this paper, we advocate another essential driver for adaptation which is the collective judgement of users on the different behaviours of a system. This judgement is based on the feedback iteratively collected from users at run-time. Users feedback should be related to their main interest which is the ability and quality of the system in reaching their requirements. We propose a novel approach to requirements-driven adaptation that gives the collective judgement of users, inferred from their individual feedback, a primary role in planning and guiding adaptation. We apply our approach on a case study and report on the results.

Raian Ali, Carlos Solis, Inah Omoronyia, Mazeiar Salehie, Bashar Nuseibeh

An Agent Oriented Development Process for Multimedia Systems,

Abstract

Requirements elicitation is a very difficult task when designing multimedia systems because of its special characteristics. The usual requirements specification process in multimedia development starts with the codification of prototype. After, it is analyzed by the customer to decide whether the application is to be constructed or not. This paper proposes a process specially defined for multimedia development that provides an initial prototype without human codification. The process combines the use of an agent oriented methodology and Alice (a multimedia oriented tool). In addition, a tool that provides support to this process is introduced. Both the process and its supporting tool are used in a simple example which demonstrates the suitability of the approach for multimedia prototype development.

Alma M. Gómez-Rodríguez, Juan Carlos González-Moreno, David Ramos-Valcárcel, Francisco Javier Rodriguez-Martinez

A Semi-automated Approach towards Handling Inconsistencies in Software Requirements

Abstract

Software Requirements expressed in the form of natural language are often informal and possibly vague. The need for formal representation of the requirements has been explored and addressed in various forms earlier. Of several recommended approaches, logical representation of requirements has been widely acknowledged to formalize the requirements languages. In this paper, we present courteous logic based representations for software requirements. We report the benefits of courteous logic based representations for handling inconsistencies in software requirements and take into account views of multiple stakeholders and the presuppositions. We show how courteous logic based representations can be used to ensure consistency as well as to uncover presuppositions in the requirements.

Richa Sharma, K. K. Biswas

Deduction-Based Formal Verification of Requirements Models with Automatic Generation of Logical Specifications

Abstract

This work concerns requirements gathering and their formal verification using deductive approach. The approach is based on temporal logic and the semantic tableaux reasoning method. Requirements elicitation is carried out with some UML diagrams. A use case, its scenario and its activity diagram may be linked to each other during the process of gathering requirements. Activities are identified in the use case scenario and then their workflows are modeled using the activity diagram. Organizing the activity diagram workflows into design patterns is crucial and enables generating logical specifications in an automated way. Temporal logic specifications, formulas and properties are difficult to specify by inexperienced users and this fact can be a significant obstacle to the practical use of deduction-based verification tools. The approach presented in this paper attempts to overcome this problem. Automatic transformation of workflow patterns to temporal logic formulas considered as a logical specification is defined. The architecture of an automatic generation and deduction-based verification system is proposed.

Radosław Klimek

Backmatter

Titel: Evaluation of Novel Approaches to Software Engineering
herausgegeben von: Leszek A. Maciaszek
Joaquim Filipe
Verlag: Springer Berlin Heidelberg
Electronic ISBN: 978-3-642-45422-6
Print ISBN: 978-3-642-45421-9
DOI: https://doi.org/10.1007/978-3-642-45422-6