International audience

A Fuzzy Inference System (FIS) is a way of mapping an input space to an output space using the fuzzy logic. FISs are widely used to solve classification problems. The Shuffled Frog Leaping Algorithm (SFLA) is a metaheuristic inspired by the natural evolution of frogs in searching for the largest source of food. By using local and global searches simultaneously, SFLA is effective in solving various optimization problems. This paper first proposes a new method to create zero-order Sugeno Fuzzy Inference Systems using SFLA. Then, the paper introduces an approach to use resulting SFLA-based Fuzzy Inference Systems to build test oracles. Test oracle is a mechanism for determining whether a test on a software program has passed or failed. The experimental results show that SFLA creates fuzzy systems more efficiently than three other evolutionary algorithms, including Genetic Algorithm (GA), Ant Colony Optimization (ACO) and Particle Swarm Optimization (PSO). Moreover, with respect to the accuracy and convergence speed criteria, SFLA and PSO outperform other evolutionary algorithms, while their performances are comparable to each other. At last, the experimental results indicate that SFLA-based FISs can be used to create test oracles with acceptable accuracy.

Software piracy has been known as unauthorised reconstruction or illegal redistribution of a licenced software. Detecting pirated from base software is a major concern since pirated software can lead to significant financial losses as well as serious security vulnerabilities. To detect software piracy, we have recently proposed Metamorphic Analysis for Automatic Software Piracy Detection (MetaSPD) with a proof-of-concept evaluation. The core idea of MetaSPD was inspired from metamorphic malware detection due to its similarity of software piracy detection. MetaSPD works primarily based on mining the opcode graph of the base software to extract micro-signatures. Then, it leverages a classifier model to decide whether a given suspicious file is a pirated version of the base software. This paper extends our prior work in several respects. First, we present a retrospective appraisal of the main literature aiming at laying bare the status quo of software piracy detection and arguments on the current problems of the field to motivate our work. We then elaborate on MetaSPD itself and the constituent components. We provide two extensive experiments to evident the effectiveness of MetaSPD. The experiments have been carried out on two different datasets. Each dataset comprises 1300 morphed variants of the respective base software that act as pirated versions of that software. We conducted our experiments using three different classifiers. The paper is also enriched with a detailed discussion of the different properties and concerns of MetaSPD. The results corroborate that an attacker, who is using a pirated version of the given software, can hardly hide illegal usage of the software even by applying superabundant obfuscations to the code.

The search space of potential inputs of a program is very large, even for the very small one, while this size is a key determining factor affecting the performance of any search-based test data generation approach. However, despite the large volume of work on search-based test data generation, the literature contains little work that concerns this problem. In this paper, by analysis of the clauses of the program, in addition to proposing a new search space reduction strategy, a new seeding approach is introduced.

In human-based computation, the machine outsources certain steps of an algorithm to humans to optimize computation by making an equilibrium of human and machine computation advantages. Software testing is an important part of the software development life cycle that aims to reveal failures in software. One of the most important activities in the software testing is test data generation. Although many automatic methods have been introduced to generate effective test data, humans are still extensively used in the software industry, due to the challenges of the proposed automatic methods. Assuming that software companies still need the help of humans, in this research, we hypothesize that a game with a purpose can be utilized to improve the process of human-based test data generation by making test data generation more cost-effective and fun. To investigate this hypothesis, we implemented a game with a purpose, Rings, to improve the process of human-based test data generation for program units. We also performed an experiment to evaluate this idea as entertainment as well as a mean for test data generation. The results show that by crowd-sourcing test data generation of program units to typical players of a game, we can make test data generation more cost-effective and fun.

One of the key activities in the service-oriented solution is the identification of services according to a set of predefined design principles. Existing service identification approaches are often prescriptive and are based on the architect’s experience, and therefore might lead to non-optimal designs which result in lower performance, reduced scalability, and complicated dependencies between services. In this paper, an automated method, called ABSIM, is proposed to identify business services by adopting design metrics based on top-down decomposition of business processes. ABSIM first gets a set of business goals along with business processes as its input and then produces a set of non-dominant solutions using a multi-objective genetic algorithm. Since each produced non-dominant solution corresponds to a set of services, in the next step of the method, fuzzy logic is used to rank the obtained solutions according to the business goals specified at the first stage. In this way, using ABSIM, a set of services which are based on the enterprise business processes and goals and are appropriate in terms of qualitative attributes is obtained. We use two case studies to show the applicability of ABSIM. Also, we demonstrate the appropriateness of ABSIM results through comparing them with outputs of expert’s experiences based on a proposed formal approach.

In our previous work, we presented a Z-based formalism, called NZ, by which one can explicitly specify bounded, unbounded, erratic, angelic, demonic, loose, strict, singular, and plural nondeterminism. The NZ notation is mainly based on a new notion of operation schemas, called multi-schema. Since the operations of the Z schema calculus do not work on multi-schemas anymore, in this paper we augment NZ with a new set of schema calculus operations that can be applied on multi-schemas as well as ordinary operation schemas. To demonstrate the usability of the resulting formalism, we show how this formalism can assist to model game-like situations and concurrent systems as two well-known classes of nondeterministic systems.

Software systems development nowadays has moved towards dynamic composition of services that run on distributed infrastructures aligned with continuous changes in the system requirements. Consequently, software developers need to tailor project specific methodologies to fit their methodology requirements. Process patterns present a suitable solution by providing reusable method chunks of software development methodologies for constructing methodologies to fit specific requirements. In this paper, we propose a set of high-level service-oriented process patterns that can be used for constructing and enhancing situational service-oriented methodologies. We show how these patterns are used to construct a specific service-oriented methodology for the development of a sample system.

It is now widely accepted that programming concurrent software is a complex, error-prone task. Therefore, there is a big interest in the specification, verification and development of concurrent programs using formal methods. In our work-in-progress project, we are attempting to make a constructive framework for developing concurrent programs formally. In this paper, we first demonstrate how one can apply an intermediate artifact of our work, a Z-based formalism, to specify the dynamic behavior of a concurrent system. More precisely, we show how one can use this formalism to explicitly specify the nondeterministic interleaving of processes in a concurrent system. Such a specification will constructively result in a functional program involving all allowable interleaved executions of concurrent processes. As the second contribution of the paper, we introduce a verification method to prove safety properties of concurrent systems specified in the proposed Z-based formalism.