Aziz Salah

A framework for context-aware self-adaptive mobile applications SPL

Mobile Applications are rapidly emerging as a convenient medium for using a variety of services. Over time and with the high penetration of smartphones in society, self-adaptation has become an essential capability required by mobile application users. In an ideal scenario, an application is required to adjust its behavior according to the current context of its use. This raises the challenge in mobile computing towards the design and development of applications that sense and react to contextual changes to provide a value-added user experience. In its general sense, context information can relate to the environment, the user, or the device status. In this paper, we propose a novel framework for building context aware and adaptive mobile applications. Based on feature modeling and Software Product Lines (SPL) concepts, this framework guides the modeling of adaptability at design time and supports context awareness and adaptability at runtime. In the core of the approach, is a feature meta-model that incorporates, in addition to SPL concepts, application feature priorities to drive the adaptability. A tool, based on that feature model, is presented to model the mobile application features and to derive the SPL members. A mobile framework, built on top of OSGI framework to dynamically adapt the application at runtime is also described.

A service creation environment based on scenarios

Abstract Scenarios are often constructed for illustrating example runs through reactive system. Scenarios that describe possible interactions between a system and its environment are widely used in requirement engineering, as a means for users to communicate their functional requirements. Various software development methods use scenarios to define user requirements, but often lack tool support. Existing tools are graphical editors rather than tool support for design. This paper presents a service creation environment for elicitation, integration, verification and validation of scenarios. A semi-formal language is defined for user oriented scenario representation, and a prototype tool implementing an algorithm that integrates them for formal specification generation. This specification is then used to automatically find and report inconsistencies in the scenarios.

Merging partial system behaviours : composition of use-case automata

Modelling the behaviour of a system under development has proved to be a very effective way to ensure that it will be constructed correctly. However, building up this model is a difficult task that requires a significant time investment and a high level of expertise. Consequently, incremental approaches that construct a system model from partial behavioural descriptions have been widely adopted. The challenge in such approaches lies in finding both the adequate behavioural formalism that fits the needs of the analyst and a formal composition mechanism that facilitates the generation of the expected behavioural model and produces a verifiable model. Within this framework, use-case approaches have been also accepted in industry because they make the process of requirements elicitation simpler. Their main shortcoming is their lack of formalisation, which makes validation difficult. A formal approach for composing partial system behaviours where partial system behaviours are defined as finite state automata is proposed. Each automaton represents a use-case that describes a certain system concern, hence the name use-case automaton (UCA). The composition of different UCAs could be performed with respect to a set of states or transitions specified by the analyst, using certain composition operators. Each of these operators has a precise semantics, which is defined by how the composition is performed. The formalization of use-case composition is based on label matching between the UCAs to be composed. Our approach is fully automated and provides the advantage of generating a UCA that meets the intended behaviour without unexpected scenarios. Finally, the UMACT, which implements our composition approach, is presented.

Towards a framework for estimating system NFRs on behavioral models

Complete and precise software requirements description is critical in successful development of software systems. This description should specify both functional requirements (FRs), that define the different functionalities the system should perform, and non-functional requirements (NFRs), that define attributes of how the system should perform these functional requirements. Even though their satisfaction is of capital importance to the final product acceptance, little has been done in order to consider NFRs as early as possible in the development process. To date, NFRs are often dismissed in first stages, causing an eventual failure of the final product. In scenario-based approaches, behavioral models (BMs) representing formalization of different use cases are commonly generated. These BMs are composed to generate a formal specification of the system under development. In current practices, these BMs do not handle NFRs, a shortcoming of these approaches. We address this issue and we propose a framework where NFRs are defined as a set of non-functional goals. The framework assists the analyst to: (1) distribute the NFRs of the system among the partial behavioral models defining its specification (2) define estimations of the NFR goals each partial behavior should fulfill with respect to a system NFR goal (3) compose the different behavioral models and their NFRs. Afterward, the resulting NFR is verified against the NFR goal of the system to validate the estimations the analyst has made.

Introducing students to professional software construction: a "software construction and maintenance" course and its maintenance corpus

It is widely accepted that there is more to software construction than basic programming skills. Professional software construction involves not only understanding some theoretical concepts, but also mastering appropriate tools and practices. In this paper, we present an undergraduate course in Software Construction and Maintenance, developed with the goal of introducing students to those key concepts, tools and practices. We first outline the content of that course, explaining how it fits within our undergraduate program. We then present a key element of that course-namely, its maintenance corpus along with its testing frameworks-used to concretely introduce students to various tools and practices, e.g., automatic test execution, build and configuration management, source code documentation, use of assertions, etc.

Compiling Real-Time Scenarios into a Timed Automaton

In this paper, we aim at synthesizing an executable specification for a real-time system by integrating real-time scenarios into a timed automaton. A scenario represents a partial description of a system behavior. A formal semantics is given for the model of a scenario and is used to compile a scenario into a timed automaton. The compilation algorithm is generalized to integrate several scenarios into a single timed automaton which simulates the behaviors specified by the scenarios. The results of the compilation algorithm are independent of the order in which the scenarios are added.

Implicit integration of scenarios into a reduced timed automaton

Abstract We aim at synthesizing an executable specification for a real-time reactive system by integrating real-time scenarios into a reduced timed automaton (TA). A scenario is a part of the specification of a system behavior. The integration of scenarios into a single TA is based on its formal semantics. The TA, which results from the integration of a set of scenarios, is independent of the order in which the scenarios are added to. We also present an algorithm to reduce such resulting TA in order to prevent combinatorial explosion.

Formal Composition of Distributed Scenarios

Eliciting, modeling, and analyzing the requirements are the main challenges to face up when you want to produce a formal specification for distributed systems. The distribution and the race conditions between events make it difficult to include all the possible scenario combinations and thus to get a complete specification. Most research about formal methods dealt with languages and neglected the process of how getting a formal specification. This paper describes a scenario-based process to synthesize a formal specification in the case of a distributed system. The requirements are represented by a set of use cases where each one is composed of a collection of distributed scenarios. The architectural assumptions about the communication between the objects of the distributed system imply some completions and reorganizations in the use cases. Then, the latter are composed into a global finite state machine (FSM) from which we derive a communicating FSM per object in the distributed system.

Towards the automatic discovery of platform transformation templates of legacy object-oriented systems

Software modernization is needed to perform the evolution of a system when conventional practices can no longer achieve the desired evolution goal. In their initiative called architecture-driven modernization (ADM), the Object Management Group proposes to use MDA to perform this modernization. However, ADM needs new tools and techniques to migrate systems developed on a non-model-driven environment to a model-driven environment. One challenge to enable this migration is the discovery of a platform description model (PDM) from the implementation of a system. In this paper, we propose an approach to discover a view of the PDM from an object-oriented system source code. This view is given as a set of transformation templates parameterizing the source code of the systems implementation platform and expressed in the QVT language. The approach uses different analysis techniques and was validated on several systems written in Java and gives good results for a number of them.

Behavioral Interface Conformance Checking for WS-BPEL Processes

Web services can be described at various levels and using various notations, e.g., operations (WSDL), orchestration (WS-BPEL), multi-partners collaborations (WS-CDL). The first two provide descriptions similar to those found in typical programming languages, namely, syntactical description of service interface and operational description of service behavior. In this paper, we show how Web services descriptions can be extended with simple declarative behavior specification, using a form of regular expressions. We explain the relationships between such specifications and WS-BPEL abstract processes. We also describe how a concrete, thus executable, WS-BPEL process can be shown to satisfy its associated abstract specification, using the SPIN model-checker.