Somayeh Malakuti

Applying the Composition Filter Model for Runtime Verification of Multiple-Language Software

Complex software, especially the embedded one, is composed of multiple collaborating subsystems that are possibly developed in multiple languages. To verify the behavior of such software, a run-time verification system must deal with multiple-language environments both in its specifications and in its generated runtime verification modules. In this paper, we present the E-Chaser runtime verification system, whose front-end provides language-independent specifications, and whose backend provides an extendable toolset with new implementation languages. E-Chaser is built based on the Composition Filter Model and extends it with the notion of synchronization messages and synchronization filters to verify the synchronization properties of multiple subsystems. The first prototype of EChaser was successfully used to verify various properties

A design method for modular energy-aware software

Nowadays reducing the overall energy consumption of software is important. A well-known solution is extending the functionality of software with energy optimizers, which monitor the energy consumption of software and adapt it accordingly. To make such extensions manageable and to cope with the complexity of the software, modular design of energy-aware software is necessary. Therefore, this paper proposes a dedicated design method for energy-aware software.

Event modules - modularizing domain-specific crosscutting RV concerns

Runtime verification (RV) facilitates detecting the failures of software during its execution. Due to the complexity of RV techniques, there is an increasing interest in achieving abstractness, modularity, and compose-ability in their implementations by means of dedicated linguistic mechanisms. This paper defines a design space to evaluate the existing domain-specific languages for implementing RV techniques, and identifies the shortcomings of a representative set of these languages with respect to the design space. This paper advocates the need for a language composition framework, which offers the necessary mechanisms to achieve abstractness, modularity, and compose-ability in the implementation of domain-specific crosscutting concerns such as the concerns of RV techniques. We explain event modules as novel linguistic abstractions for modular implementation of domain-specific crosscutting concerns. This paper discusses the implementation of event modules in the EventReactor language, and illustrates the suitability of event modules to implement RV techniques by means of two complementary examples.

Event-Based Modularization of Reactive Systems

There is a large number of complex software systems that have reactive behavior. As for any other software system, reactive systems are subject to evolution demands. This paper defines a set requirements that must be fulfilled so that reuse of reactive software systems can be increased. Detailed analysis of a set of representative languages reveals that these requirements are not completely fulfilled by the current programming languages and as such reuse of reactive systems remains a challenge. This paper explains Event Composition Model and its implementation the EventReactor language, which fulfill the requirements. By means of an example, the suitability of the EventReactor language in creating reusable reactive systems is illustrated.

Detecting Emergent Interference in Integration of Multiple Self-Adaptive Systems

A system of systems (SoS) is a large-scale concurrent and distributed system whose components are complex systems. An example of SoS is in the domain of self-adaptive systems, where multiple self-adaptive systems must be integrated with each other. As for any other kind of SoS, we face the following question: is there any emergent interference as the result of such integration, which prevents the constituent self-adaptive systems to achieve their goals? Due to the inherent complexity of an SoS, it is not easy to detect emergent interference manually, if possible at all. We study the suitability of formal modeling and verification for detecting emergent interference in an example of SoS, i.e. integration of multiple self-adaptive systems. Model checking reveals that although constituent systems behave correctly when executed individually, they fail to provide correct behavior in an SoS context due to unforeseen interference that emerges.

Towards modular resource-aware applications

Resource optimization is an increasingly important requirement in the design and implementation of software systems. It is applied to improve both environmental sustainability and usability of resource-constrained devices. This paper claims that to achieve more modular resource-aware applications, the resource utilization of components must explicitly be modeled. Due to shortcomings of existing modeling languages, we propose a notation for the resource consumption of components and we illustrate the suitability of this notation by means of two real-world examples. We observe that explicitly modeling resource consumption has as result that resource consumption information is scattered across and tangled with the functional services of components.

Checking the correspondence between UML models and implementation

UML class and sequence diagrams are used as the basis for runtime profiling along with either offline or online analysis to determine whether the execution conforms to the diagrams. Situations where sequence diagrams are intended to characterize all possible executions are described. The approach generates an execution tree of all possible sequences, using a detailed collection of graph transformations that represent a precise operational semantics for sequence diagrams, including treatment for polymorphism, multiple activations, reference to other diagrams, and the use of frames in sequence diagrams. The sequence diagrams are also used to determine the information that should be gathered about method calls in the system. Aspects that can follow the flow of messages in a distributed system, are generated and the results of execution are recorded. The execution tree is used to automatically check the recorded execution to detect operations that do not correspond to any of the diagrams. These represent either new types of sequence diagrams that should be added to the collection, or implementation errors where the system is not responding as designed. In either case, it is important to identify such situations.

Emergent gummy modules: modular representation of emergent behavior

Emergent behavior is generally defined as the appearance of complex behavior out of multiplicity of relatively simple interactions. Nowadays, there are various kinds of software systems that deal with detecting the emergence of certain behavior in environment, representing it in the software and providing means to manipulate the behavior. Where significant amount of research has been dedicated to develop algorithms for detecting emergent behavior, there is no dedicated attempt to provide suitable linguistic abstractions to modularize emergent behavior and its related concerns. This results in implementations that are complex and hard to maintain. In this paper, we identify three characteristic features of emergent behavior, and outline the shortcomings of current languages to properly program and modularize emergent behavior. We introduce emergent gummy modules as dedicated linguistic abstractions, which facilitate defining the appearance and disappearance conditions of emergent behavior as well as its utilization operations as one holistic module. We explain the implementation of emergent gummy modules in the GummyJ language, and illustrate that they improve the modularity of implementations. We represent the event processing semantics of GummyJ programs in UPPAAL model checker and verify their correctness.

Event-based modularization: how emergent behavioral patterns must be modularized?

Nowadays, detecting emergent behavioral patterns in the environment, representing and manipulating them become the main focus of many software systems such as traffic monitoring systems, runtime verification techniques and self-adaptive systems. In this paper, we discuss the need for dedicated linguistic constructs to modularly represent emergent behavioral patterns and their lifetime semantics. We explain the shortcomings of current languages with this regard. Inspired from the evolution of procedural languages to object-oriented and aspect-oriented languages, we explain the concept of event-based modularization, which can be regarded as the successor of the aspect-oriented modularization for representing emergent behavioral patterns and their lifetime semantics. We report on our work on event modules and their successor gummy modules, which facilitate representing behavioral patterns as a holistic module that encapsulates its lifetime semantics.

A tool-supported approach for modular design of energy-aware software

The reduction of energy usage by software-controlled systems has many advantages, including prolonged battery life and reduction of greenhouse gas emissions. Thus, being able to implement energy optimization in software is essential. This requires a model of the energy utilization---or more general resource utilization---for each component in the system. Optimizer components, then, analyze resource utilization of other components in terms of such a model and adapt their behavior accordingly. We have devised a notation for Resource-Utilization Models (RUMs) that can be part of a components application programming interface (API) to facilitate the modular implementation of optimizers. In this paper, we present tools for extracting such RUMs from components with an existing implementation.