ENASE 2013 Abstracts


Full Papers
Paper Nr: 1
Title:

Requirements Prioritization by End-users and Consequences on Design of a Virtual Reality Software - An Exploratory Study

Authors:

Emilie Loup Escande and Olivier Christmann

Abstract: This paper aims to understand the real contribution of end-users of a virtual reality software to the requirements prioritization step of the software process and to study how this contribution could influence design decisions. In our empirical study, we analyzed the lists of functionalities prioritized on a questionnaire basis and the functionalities evoked spontaneously by users, in the context of the design of a new software. Results show that several priority levels can be associated with a same functionality within a single user profile and that priority levels associated with the same functionality may be common or specific to user profiles. Results also highlight that the additional functionalities proposed by participants are new features or precisions. In conclusion, we present our research perspective which aims to understand how the participants perform the prioritization task.

Paper Nr: 6
Title:

Architecture Level Prediction of Software Quality Attributes

Authors:

Imen Derbel, Lamia Labed Jilani and Ali Mili

Abstract: The concept of software architecture emerged in the eighties as an abstraction of all the design decisions pertaining to broad system structure, component coordination, system deployment, and system operation. As such, software architecture deals less with functional attributes than with operational attributes of a software system. So much so that a sound discipline of software architecture consists in identifying and prioritizing important non functional attributes that we want to optimize in the software system, and using them as a guide in making architectural decisions. We know of no architectural description language that allows us to represent and reason about non functional quality attributes such as response time, throughput, failure probability, security, availability, etc. In this paper, we present a modified version of ACME, and present a compiler of this language that allows us to analyze and reason about non functional attributes of software systems.

Paper Nr: 9
Title:

Transparent Persistence Appears Problematic for Software Maintenance - A Randomized, Controlled Experiment

Authors:

Pietu Pohjalainen

Abstract: Information retrieval from a database is the backbone of many applications. For building object-oriented systems with a relational persistence engine, a common approach is to use an object-to-relational mapping library for handling the mismatch between object-oriented and relational data models. These components should make the application programmer oblivious to the choice of relational database. To study the effects of transparent persistence, we conducted a randomized, controlled study for 16 students, who were given a number of maintenance tasks on a sample software. For half of attendees, the sample software was written using the transparent persistence approach. For the second half the sample software used a self-configuring component for automatically generating database queries. We found out that the group using transparent persistence were performing worse than the group using self-configuring queries. Attendees in both groups were using the same amount of time for performing the given maintenance tasks, but the transparent persistence group was outperformed by a factor of three in the number of correct submissions. The use of transparent persistence turned out to be a major error source. This gives us a reason to doubt the usefulness of transparent persistence in the long run.

Paper Nr: 10
Title:

Analyzing UML Activity and Component Diagrams - An Approach based on COSMIC Functional Size Measurement

Authors:

Asma Sellami, Mariem Haoues and Hanêne Ben-Abdallah

Abstract: UML is a widely used modeling language that offers a set of complementary diagram types used to describe a system according to different views, such as the functional view, the dynamic view and the static view. This multi-view modeling can induce inconsistencies between UML diagrams. This paper presents a COSMIC-based approach for analyzing and checking the consistency between the activity diagram and the component diagram. First, it elaborates a set of procedures for the COSMIC Functional Size Measurement of each diagram. Secondly, it proposes a set of heuristics, based on the semantic relations between these two diagrams, to assist developers in predicting the range of the FSM values of the component diagram from those of the activity diagram. The set of measurement procedures and heuristics are illustrated through the "Rice cooker" case study.

Paper Nr: 12
Title:

Towards an MDE Methodology to Develop Multi-Agents Systems including Mobile Agents

Authors:

Tahar Gherbi, Isabelle Borne and Djamel Meslati

Abstract: There is a need for agent oriented software engineering methodologies that support the conceptual modeling of mobile-agents systems. For this reason, we have presented in a previous work, our meta-model to design multi-agents systems including mobile agents and we have discussed it versus some formalisms extending UML for mobile-agents modeling. The proposed meta-model serves as a platform independent meta-model in our model-driven engineering approach under elaboration as a methodology for the development of multi-agents systems including mobile-agents. This paper summarizes the different approaches for mobile-agent modeling and situates our meta-model particularly versus three works supporting mobility by extending a multi-agents systems methodology (MaSE, GAIA, and AALAADIN). It aims to justify the choices that have guided our meta-model construction.

Paper Nr: 16
Title:

An Application of Software Fault Injection for Assessment of Quality of Test Sets for Business Processes Orchestrating Web-Services

Authors:

Damian Grela, Krzysztof Sapiecha and Joanna Strug

Abstract: The paper presents an experiment of the application of software fault injection to assess quality of test sets for business processes orchestrating web-services. The mutation testing, usually used to this end, suffers from high computational costs of generating and running mutants. In contrast to mutation testing, faults injection can be performed at a run-time. Run-time changes are introduced by a Software Fault Injector for BPEL Processes (SFIBP). SFIBP is implemented as a special service that manipulates invocations of web-services and values of their internal variables. As for time requirements, the experiment proved high superiority of the application of the SFIBP over the mutation testing.

Paper Nr: 17
Title:

Composing Classes - Roles Vs Traits

Authors:

Fernando Barbosa and Ademar Aguiar

Abstract: Code replication has significant drawbacks in system maintenance. Code replication can have its origins in the composition limitations of the language. Several proposals have tried to overcome these limitations. A popular one is traits. However, traits do not support state or visibility control. Static roles are also a way of composing classes that has the benefits of traits and offers state, visibility control and other advantages as block renaming. We compare both approaches on how they are used to compose classes, and how they can be used to reduce code replication caused by composition limitations. As a case study we will compare how both approaches can reduce code replication by detecting and removing code clones within the JHotDraw framework. Results show that roles are capable of reducing a larger amount of replicated code than traits.

Paper Nr: 22
Title:

A Formal Passive Performance Testing Approach for Distributed Communication Systems

Authors:

Xiaoping Che and Stephane Maag

Abstract: Conformance testing of communicating protocols is a functional test which verifies whether the behaviors of the protocol satisfy defined requirements, while the performance testing of communicating protocols is a qualitative and quantitative test, aiming at checking whether the performance requirements of the protocol have been satisfied under certain conditions. It raises the interesting issue of converging these two kinds of tests by using the same formal approach. In this paper, we present a novel logic-based approach to test the protocol performance through real execution traces and formally specified properties. In order to evaluate and assess our methodology, we have developed a prototype and present experiments with a set of IMS/SIP properties. Finally, the relevant verdicts and discussions are provided.

Paper Nr: 23
Title:

Topics and Treatments in Global Software Engineering Research - A Systematic Snapshot

Authors:

Bilal Raza, Stephen G. MacDonell and Tony Clear

Abstract: This study presents an analysis of the most recent literature addressing global software engineering (GSE). The primary purpose is to understand what issues are being addressed and how research is being carried out in GSE – and comparatively, what work is not being conducted. We examine the current state of GSE research using a new Systematic Snapshot Mapping (SSM) technique. We analysed 275 papers published between January 2011 and June 2012 in peer-reviewed conferences, journals and workshops. Our results provide a coarse-grained overview of the very recent literature addressing GSE, by classifying studies into predefined categories. We also follow and extend several prior classifications to support our synthesis of the data. Our results reveal that, currently, GSE studies are focused on Management and Infrastructure related factors rather than Human or Distance related factors, using principally evaluative research approaches. Most of the studies are conducted at the organizational level, mainly using methods such as interviews, surveys, field studies and case studies. We use inter-country network analysis to confirm that the USA and India are major players in GSE, with USA-India collaborations being the most frequently studied, followed by USA-China. Specific groups of countries have dominated the reported GSE project locations (and the locations of research authors). In contrast, regions including Central Asia, South Asia (except India), Africa and South East Asia have not been covered in these studies. While a considerable number of GSE-related studies have been published they are currently quite narrowly focused on exploratory research and explanatory theories. The critical research paradigm has been untouched, perhaps due to a lack of criteria and principles for carrying out such research in GSE. An absence of formulative research, experimentation and simulation, and a comparative focus on evaluative approaches, all suggest that existing tools, methods and approaches from related fields are being tested in the GSE context. However, these solutions may not scale to cover GSE-related issues or may overlook factors/facets specific to GSE.

Paper Nr: 28
Title:

Involving End-users in Domain-Specific Languages Development - Experiences from a Bioinformatics SME

Authors:

Maria Jose Villanueva, Francisco Valverde and Oscar Pastor

Abstract: Involving end-users in software development is a goal envisioned by the Software Engineering community. As they have the domain knowledge, it is feasible to develop software applications that really fulfil their requirements. Domain-specific languages (DSL) are widely applied to accomplish this vision. However, end-users collaboration in DSL development is also important to ensure that their needs are well understood and represented. This research work proposes a DSL development process that combines methodological guidelines for DSL development with good practices from agile methods to encourage end-user involvement. In this paper, we overview the complete process and we focus on the two first stages: Decision and Analysis. In order to illustrate the proposal, it is applied in the development of a DSL for a bioinformatics SME that works on genetic disease diagnosis.

Paper Nr: 31
Title:

Testware Visualized - Visual Support for Testware Reorganization

Authors:

Artur Sosnówka

Abstract: The majority of formal description for software testing in the industry is conducted at the system or acceptance level, however most formal research has been focused on the unit level. This paper propose formal test selection criteria for system or integration test based on visualization analysis for low level test cases. Visual analysis for low level test case selection is to be based on inputs from available Test Management system. Presented analysis criteria shows a subset of test metrics which has been used in pilot projects in the industry as a base for testware reorganization.

Short Papers
Paper Nr: 4
Title:

Toward an Integrated Framework for Declarative and Interactive Spreadsheet Debugging

Authors:

Dietmar Jannach, Arash Baharloo and David Williamson

Abstract: Spreadsheet applications can nowadays be found nearly everywhere in companies and are used for a variety of purposes. Because of the high risk that arises when business decisions are based on faulty spreadsheets, in recent years new approaches for spreadsheet quality assurance have been proposed. Among them are techniques that allow for more intelligent tool support during the spreadsheet test and debugging process. The design and evaluation of such new methods and tools, which are for example based on model-based techniques is however challenging. On the one hand, real-world spreadsheets can be large and complex, thus requiring highly efficient and scalable error-location algorithms. On the other hand, as spreadsheets are usually developed by non-programmers, special care has to be taken when designing the debugging user interface. In this paper, we discuss these challenges and present the design and architecture of an integrated framework for spreadsheet debugging called Exquisite. Furthermore, we report details and first experimental results of a constraint-based debugging approach implemented in the framework, which supports the automated identification of possible spreadsheet errors based on user-provided test cases and model-based diagnosis techniques.

Paper Nr: 7
Title:

Defect Bash - Literature Review

Authors:

Xuejiao Zhou and Mika Mäntylä

Abstract: Defect bash is a co-located testing session performed by a group of people. We performed a systematic review of the academic and grey literature, i.e. informally published writings, of the defect bash. Altogether, we found 44 items (17 academic and 27 grey literature sources) that were identified useful for the review. Based on the review the definition of defect bash is presented, benefits and limitations of using defect bash are given. Finally, the process of doing defect bash is outlined. This review provides initial understanding on how defect bash could be useful in achieving the software quality and lays foundation for further academic studies of this topic.

Paper Nr: 14
Title:

Overview of an Approach Describing Multi-views/ Multi-abstraction Levels Software Architecture

Authors:

Ahmad Kheir, Hala Naja, Mourad Oussalah and Kifah Tout

Abstract: Views and abstraction levels are two major concepts introduced in the software engineering domain in order to enhance the architectural organization of complex systems’ requirements. Despite numerous and substantial works that built and refined those concepts, they still less secure and less standardized to be part of a rough software architecture. This paper begins with a survey of evolution of the role and usage of those concepts in software architecture, and ends with an overview of an approach integrating the views and abstraction levels concepts within a single rough multi-views/multi-abstraction levels software architecture and respecting their usage in an evolutionary architectural specification analysis. The main benefits of this contribution was to allow system architects to solve more efficiently the complexity problems; and allow them to build a complex, organized and coherent architecture; and finally enhance the communication and harmony among different stakeholders.

Paper Nr: 15
Title:

Nested Web Application Components Framework - A Comparison to Competing Software Component Models

Authors:

Svebor Prstačić and Mario Žagar

Abstract: There are many approaches and component models for Web application component development, of varying complexity, for different platforms using different technologies. All of which have a common problem – constrained component reusability. In this article, we summarize common software component reusability shortcomings of the most popular frameworks and component models they provide, and compare against the solution our own approach “framework as a component” provides to improve reusability.

Paper Nr: 24
Title:

Identifying Critical Areas for Improvement in Agile Multi-site Co-development

Authors:

Raoul Vallon, Klaus Bayrhammer, Stefan Strobl, Mario Bernhart and Thomas Grechenig

Abstract: Agile processes potentially ease distributed software development by demanding regular communication and self-management of virtual team members. However, being designed for collocated teams, extensions to the regular process need to be made. We investigate critical areas of improvement based on a case of distributed Scrum involving two unaffiliated Austrian IT organizations that collaborate to build software. We identified eight critical areas for improvement originating from interviews, retrospective meetings and an in-depth case analysis. Key suggestions for practice include the establishment of long-lived single-site Scrum teams and the application of Behavior Driven Development (BDD) to make implicit requirement knowledge explicit and transparent to all of the distributed parties.

Paper Nr: 25
Title:

The G.O.A.L. Approach - A Goal-Oriented Algebraic Language

Authors:

Jérôme Dantan, Yann Pollet and Salima Taibi

Abstract: In a global context of sharing information, such as Big Data and cloud computing paradigms, researchers are developing many means to deal with new data models and algorithms. However, the development and reuse of these ones is complex because of the heterogeneity of environments, data formats and contexts of use all around of the world. That's why a way to share and reuse algorithms and treatments through a common formalism is needed, for both machines and computers. The ultimate goal of our work is to provide a collaborative platform for not only experts but also machines automatically develop, reuse and chain treatments, computations and models. For this, we rely on a goal-oriented approach which is associated with the Semantic Web, to establish a common formalism to design models for worldwide researchers. In this article, we propose the formalization of our approach thanks to an algebra which is linked to the Semantic Web standards. Finally, we provide a high-level language dedicated to both computers and experts, illustrated with examples that are linked to the agriculture domain.

Paper Nr: 27
Title:

Framework for Enabling Scalable Learning Game AI

Authors:

Gabriel Iuhasz, Victor Ion Munteanu and Viorel Negru

Abstract: The video game industry is a multibillion-dollar industry in which, due to general short deadlines, game visuals as well as gameplay elements are worked in parallel up until the very last minute. This means that even if the AI system has been designed in parallel with the other game elements, once a change has been made in the late stages of the game development, the AI may prove to be inadequate to the given job. Our article covers some of the existing frameworks for game AI and proposes a multi-agent system which serves as a framework for scalable learning game AI through integration of existing machine learning techniques.

Paper Nr: 35
Title:

Supporting Service Versioning - MDE to the Rescue

Authors:

Iván Santiago, Juan M. Vara, Jenifer Verde, Valeria de Castro and Esperanza Marcos

Abstract: In the field of Service-Oriented Architecture (SOA), evolution is a key issue given the non-trivial nature of updating widely distributed and heterogeneous systems. In particular, the evolution of a service is expressed through the creation and decommissioning of different service versions during its lifetime. These versions must be aligned with each other in such a way as to allow a service developer to track the various modifications introduced over time and whether the resulting service version is compatible with existing consumers. Having all this in mind, this work aims at define a plan to provide a complete framework to support service evolution by means of Model-Driven Engineering techniques.

Paper Nr: 36
Title:

Module Isolation for Efficient Model Checking and its Application to FMEA in Model-driven Engineering

Authors:

Vladimir Estivill-Castro and René Hexel

Abstract: Model-driven development results in directly runnable implementations, and therefore it is of utmost importance to formally verify and validate such models. However, model-checking usually faces the challenge of concurrent modules generating a state space equal to the Cartesian product of the state spaces of all modules. This is even more dramatic as recent trends in model-driven-engineering aim at not only modelling the software in question, but other components of the system as well, in order to perform Failure Mode Effects Analysis (FMEA). These additional components further enlarge the collective state space. We provide an algorithm that identifies the sections of the system that are independent, enabling verification of separate sections of the system. As a consequence, formal verification of the system as well as the corresponding FMEA can be performed much more efficiently.

Paper Nr: 40
Title:

Intelligent Agile Method Framework

Authors:

Marko Janković, Marko Bajec, Ghazaleh Khodabandelou, Rebecca Deneckere, Charlotte Hug and Camille Salinesi

Abstract: The paper addresses the problem of the low usage of software development methods in software development practice. This has been recognized as one of the key reasons for failures in software development projects and a contributor to the low quality of software. We introduce a novel approach that could help to improve the maturity of software development processes. The approach is based on the method engineering principles taking into account the limitations that hinder its use in practice. The main objective of our research is to show that the method engineering concepts are applicable in real settings and that could contribute to the higher quality of software development processes and their products.

Paper Nr: 41
Title:

Automatically Generating Tests from Natural Language Descriptions of Software Behavior

Authors:

Sunil Kamalakar, Stephen H. Edwards and Tung M. Dao

Abstract: Behavior-Driven Development (BDD) is an emerging agile development approach where all stakeholders (including developers and customers) work together to write user stories in structured natural language to capture a software application’s functionality in terms of required `behaviors.' Developers can then manually write `glue' code so that these scenarios can be translated into executable software tests. This glue code represents individual steps within unit and acceptance test cases, and tools exist that automate the mapping from scenario descriptions to manually written code steps (typically using regular expressions). This paper takes the position that, instead of requiring programmers to write manual glue code, it is practical to convert natural language scenario descriptions into executable software tests %{\it fully automatically}%. To show feasibility, this paper presents preliminary results from a tool called Kirby that uses natural language processing techniques to automatically generate executable software tests from structured English scenario descriptions. Kirby relieves the developer from the laborious work of writing code for the individual steps described in scenarios, so that both developers and customers can both focus on the scenarios as pure behavior descriptions (understandable to all, not just programmers). Preliminary results from assessing the per-formance and accuracy of this technique are presented.

Paper Nr: 44
Title:

Integrating Validation Techniques for Process-based Models

Authors:

Andreas Speck, Sören Witt, Sven Feja, Sören Feja and Elke Pulvermueller

Abstract: Model checking has been established as an appropriate technology to validate behavioral properties of (business) process based systems. However, further validation technologies (e. g. for structural properties) may be of interest for process models. We propose a concept to integrate validation technologies in a unique system with a common user interface.

Paper Nr: 47
Title:

Continuous Test-Driven Development - A Novel Agile Software Development Practice and Supporting Tool

Authors:

Lech Madeyski and Marcin Kawalerowicz

Abstract: Continuous testing is a technique in modern software development in which the source code is constantly unit tested in the background and there is no need for the developer to perform the tests manually. We propose an extension to this technique that combines it with well-established software engineering practice called Test-Driven Development (TDD). In our practice, that we called Continuous Test-Driven Development (CTDD), software developer writes the tests first and is not forced to perform them manually. We hope to reduce the time waste resulting from manual test execution in highly test driven development scenario. In this article we describe the CTDD practice and the tool that we intend to use to support and evaluate the CTDD practice in a real world software development project.

Posters
Paper Nr: 8
Title:

Yet, Another Method for Detecting API Deadlock

Authors:

Suvarin Ploysri and Wanchai Rivepiboon

Abstract: Currently, developing a multithreading Application Programming Interface (API) for special use is extensive. Defects that are the most concern are deadlocks since the deadlock causes the application developed on top of the API stops working. The deadlock detection algorithm has been developed widely. We present another deadlock detection algorithm using the concept of static analysis. The algorithm detects potential deadlocks in the source code of the multithreading API. Finally, it reports deadlock sites. The result assists the developer to be aware of code synchronization that potentially encounters deadlocks. Moreover, it is related information to find the root cause of the deadlock in the future.

Paper Nr: 18
Title:

How Do Globally Distributed Agile Teams Self-organise? - Initial Insights from a Case Study

Authors:

Sherlock A. Licorish and Stephen G. MacDonell

Abstract: Agile software developers are required to self-organize, occupying various informal roles as needed in order to successfully deliver software features. However, previous research has reported conflicting evidence about the way teams actually undertake this activity. The ability to self-organize is particularly necessary for software development in globally distributed environments, where distance has been shown to exacerbate human-centric issues. Understanding the way successful teams self-organise should inform distributed team composition strategies and software project governance. We have used psycholinguistics to study the way IBM Rational Jazz practitioners enacted various roles, expressed attitudes and shared competencies to successfully self-organize in their global projects. Among our findings, we uncovered that practitioners enacted various roles depending on their teams’ cohort of features; and that team leaders were most critical to IBM Jazz teams’ self-organisation. We discuss these findings and highlight their implications for software project governance.

Paper Nr: 26
Title:

Heterogeneous Models Matching for Consistency Management

Authors:

Mahmoud El Hamlaoui, Sophie Ebersold, Bernard Coulette, Adil Anwar and Mahmoud Nassar

Abstract: The overall goal of our approach is to relate models of a given domain. Those models are manipulated by different actors, and are thus generally heterogeneous, that is, described with different DSLs (Domain Specific Languages). Instead of building a single global model, we propose to organize the different source models as a network of models, which provides a global view of the system through a virtual global model. The matching of these models is done in a unique correspondence model composed of relationships that are instantiated from a correspondence meta-model. This meta-model is composed of a generic part – common to all the domains – and of a specific part which depends on the specific domain modelled. In this paper, we focus on the elaboration of the correspondence model based on a correspondence meta-model, through a vertical relationship named “refine”. The approach is illustrated on a representative use case (a Bug Tracking System).

Paper Nr: 32
Title:

A Model for Software Contexts

Authors:

Diana Kirk and Stephen G. MacDonell

Abstract: It is widely acknowledged by researchers and practitioners that software development methodologies are generally adapted to suit specific project contexts. Research into practices-as-implemented has been fragmented and has tended to focus either on the strength of adherence to a specific methodology or on how the efficacy of specific practices is affected by contextual factors. We submit the need for a more holistic, integrated approach to investigating context-related best practice. We propose a six-dimensional model of the problem-space, with dimensions organisational drivers (why), space and time (where), culture (who), product life-cycle stage (when), product constraints (what) and engagement constraints (how). We test our model by using it to describe and explain a reported implementation study. Our contributions are a novel approach to understanding situated software practices and a preliminary model for software contexts.

Paper Nr: 34
Title:

QReal DSM platform - An Environment for Creation of Specific Visual IDEs

Authors:

Anastasiia Kuzenkova, Anna Deripaska, Timofey Bryksin, Yurii Litvinov and Vladimir Polyakov

Abstract: This article describes a technology for rapid creation of domain-specific languages called QReal. Domain-specific modelling is promising new paradigm, as it provides a serious boost to productivity of developers (3 to 10 times in some cases, compared to common development methodologies), so support tools for it are worth studying. QReal is a research project and a prototype of such tool to support domain-specific modelling. Overview of QReal basic metamodelling capabilities, like abstract and concrete syntax definition, is given, some advanced capabilities like defining semantics of visual language, constraints and refactoring support are described. Two cases of successful use of this technology to create domain-specific solutions are presented, some promising future work directions are given.

Paper Nr: 39
Title:

Extracting Behavioral Models from Service Implementations

Authors:

Ioana Şora and Doru-Thom Popovici

Abstract: Formal behavioral models of software services are used as input by analysis tools which check their properties on hand of the given models. However, there is a gap between the real systems which have to be validated and their abstract models. This work proposes to bridge this gap by tools which extract behavioral models from software services implementations. The method proposed here aims at ensuring a general solution, applicable to several service technologies. The core of this solution consists of transforming the control flow graph of a communicating system into its corresponding behavioral model represented as an EFSM (Extended Finite State Machine). The extracted EFSM model can be automatically translated into an entity description in a formal security specification language for distributed systems. This will enable the use of formal analysis tools for real service implementations.

Paper Nr: 45
Title:

Requirements Engineering with Agent-Oriented Models

Authors:

Tanel Tenso and Kuldar Taveter

Abstract: This paper provides a solution how to gather requirements using modified principles of agent-oriented modeling. By simplifying the concepts of agent-oriented modeling for requirements engineering we have found that this kind of modeling can be used in various software development projects including agile software development for agile requirements engineering. To verify our theories, we’ve used our practice in two real-life projects. This paper contains summary of ideas and practices developed during these projects.