A pervasive computing system (PCS) requires that devices be context aware in order to provide proactively adapted services according to the current context. Because of the highly dynamic environment of a PCS, the service adaptation task must be performed during device operation. Most of the proposed approaches do not deal with the problem in depth, because they are either not really context aware or the problem itself is not thought to be dynamic. Devices in a PCS are generally hand-held, that is, they have limited resources, and so, in the effort to make them more reliable, the service adaptation must take into account this constraint. In this paper, we propose a dynamic service adaptation approach for a device operating in a PCS that is both context aware and limited resources aware. The approach is then modeled using colored Petri Nets and simulated using the CPN Tools, an important step toward its validation.

Moeiz Miraoui

Chakib Tadj

Jaouhar Fattahi

Chokri Ben Amar

Dynamic Context-Aware and Limited Resources-Aware Service Adaptation for Pervasive Computing

This paper presents an economics-based approach for studying the problem of resource allocation among software development phases. Our approach is structured along two parallel axes: theoretical and empirical. We developed a general economic model for analyzing the allocation problem as a constrained profit maximization problem. The model, based on a novel concept of <i>software production function</i>, considers the effects of different allocations of development resources on output measures of the resulting software product. An empirical environment for evaluating and refining the model is presented, and a first exploratory study for characterizing the model's components and developers' resource allocation decisions is described. The findings illustrate how the model can be applied and validate its underlying assumptions and usability. Future quantitative empirical studies can refine and substantiate various aspects of the proposed model and ultimately improve the productivity of software development processes.

Peleg Yiftachel

Irit Hadar

Dan Peled

Eitan Farchi

Dan Goldwasser

The Study of Resource Allocation among Software Development Phases: An Economics-Based Approach

UML/OCL class diagrams provide high-level descriptions of
software systems. Currently, UML/OCL class diagrams are highly used
for code generation through several transformations in order to save time
and effort of software developers. Therefore, verification of these class diagrams is essential in order to generate accurate transformations. Verification of UML/OCL class diagrams is a quite challenging task when the
input is large (i.e., a complex UML/OCL class diagram). In this paper,
we present (1) a benchmark for UML/OCL verification and validation
tools, (2) an evaluation and analysis of tools available for verification
and validation of UML/OCL class diagrams including the range of UML
support for each tool, (3) the problems with efficiency of the verification process for UML/OCL class diagrams, and (4) solution for efficient verification of complex class diagrams.

Asadullah Shaikh

Uffe Kock Wiil

Nasrullah Memon

Evaluation of Tools and Slicing Techniques for Efficient Verification of UML/OCL Class Diagrams

Agent-systems can bring important benefits especially in applications scenarios where highly distributed, autonomous, intelligence, self-organizing, and robust systems are required. Furthermore, the high levels of autonomy and self-organizations of agent systems provide excellent support for developments of systems in which dependability is essential. Both Ubiquitous Computing and Ambient Intelligence scenarios belong in this category. Unfortunately, the lack of appropriate security mechanisms, both their enforcement and usability, is hindering the application of this paradigm in real-world applications. Security issues play an important role in the development of multiagent systems and are considered to be one of the main issues to solve before agent technology is ready to be widely used outside the research community. In this paper, we present a software based solution for the protection of multiagent systems concentrating on the cooperative agents model and the protected computing approach.

Antonio Mu&#241;oz

Pablo Anton

Antonio Ma&#241;a

Multiagent Systems Protection

The Property Specification (Prospec) tool uses patterns and scopes defined by Dwyer et al., to generate formal specifications in Linear Temporal Logic (LTL) and other languages. The work
presented in this paper provides improved LTL specifications for patterns and scopes over those originally provided by Prospec. This improvement comes in the efficiency of the LTL formulas as measured in terms of the number of states in the Büchi automaton generated for the formula. Minimizing the size of the Büchi automata for an LTL specification provides a significant improvement for model checking software systems using such tools as the highly acclaimed Spin model checker.

Salamah Salamah

Ann Q. Gates

Steve Roach

Matthew Engskow

Towards Support for Software Model Checking: Improving the Efficiency of Formal Specifications

Software development teams that use agile methodologies are increasingly adopting the test-driven development practice (TDD). TDD allows to produce software by iterative and incremental work cycle, and with a strict control over the process, favouring an early detection of bugs. However, when applied to large and complex systems, TDD benefits are not so obvious; manually locating and fixing bugs introduced during the iterative development steps is a nontrivial task. In such systems, the propagation chains following the bugs activation can be unacceptably long and intricate, and the size of the code to be analyzed is often too large. In this paper, a bug localization technique specifically tailored to TDD is presented. The technique is embedded in the TDD cycle, and it aims to improve developers' ability to locate bugs as soon as possible. It is implemented in a tool and experimentally evaluated on newly developed Java programs.

Massimo Ficco

Roberto Pietrantuono

Stefano Russo

Bug Localization in Test-Driven Development

Function Point Analysis (FPA) is a widely used technique for measuring software size. It measures software functionality from the user's perspective, usually based on a requirements description. In many software processes, these requirements are represented by UML models. 
Although there have been attempts to automate the measurement process, FPA counting requires a considerable amount of interpretation which, to be reliable, should be made by experts. On the other hand, fully manual counting methods usually fail to keep synchronized with the requirements model, since requirements frequently change during the development cycle. 
This paper describes an approach for counting FPA and a compliant tool. This approach makes use of UML requirement models. The tool, called ReMoFP (<i  >Requirement Model Function Point counter</i>), leaves all the counting decisions to the analyst, but supports him by ensuring consistency with the requirements represented in the models. The ReMoFP was developed by a software development laboratory in Brazil, and helped it to improve counting productivity, consistency, and maintainability. 


Vitor A. Batista

Daniela C. C. Peixoto

Eduardo P. Borges

Wilson P&#225;dua

Rodolfo F. Resende

Clarindo Isa&#237;as P. S. P&#225;dua

ReMoFP: A Tool for Counting Function Points from UML Requirement Models

About this journal

Journal profile

Meet the editorial board

Editor spotlight

Submit your proposal

Do you think there is an emerging area of research that really needs to be highlighted? Or an existing research area that has been overlooked or would benefit from deeper investigation? Raise the profile of a research area by leading a Special Issue.

Advances in Software Engineering