Minimizing the ripple effect of web-centric software by using the pheromone extension

Information Sciences 193 (2012) 218–232

Contents lists available at SciVerse ScienceDirect

Information Sciences

journal homepage: www.elsevier .com/locate / ins

Minimizing the ripple effect of web-centric software by usingthe pheromone extension

Soumya Banerjee a,⇑, Hameed Al-Qaheri b

a Department of Computer Science, Birla Institute of Technology, Mesra, Deoghar Campus, Indiab Department of Quantitative Methods and Information Systems, College of Business Administration, Kuwait University, Kuwait

a r t i c l e i n f o a b s t r a c t

Article history:Received 2 June 2010Received in revised form 19 September2011Accepted 2 January 2012Available online 12 January 2012

Keywords:Ripple-effectWeb-based softwareCross-codeWrapper interfaceAnt Colony OptimizationPheromone

0020-0255/$ - see front matter � 2012 Elsevier Incdoi:10.1016/j.ins.2012.01.007

⇑ Corresponding author.E-mail address: [email protected]

The ripple effect metric shows what impact changes to a software will likely have on therest of the system. In web-based data analysis, it has become a widespread practice todeploy both the script and the program developed with a high-level programming lan-guage software tool. Due to different vendors and the diversified philosophies behind dif-ferent software tools, it may be slightly difficult to cope with the ripple effect across them.This paper initiates an experimental idea to minimize the wrapper interface ripple for web-based script tools and high-level programming environments and also indicates manypotential research directions for the development of computationally intelligent tools inthe software engineering domain that demand lower cost and less complexity. This workincorporates Ant Colony Optimization (ACO) and its prime artifact pheromone, whichhas been modified as a pheromone extension module to minimize ripples when cross-coding. A standard benchmark data set has been taken to validate the performance ofthe proposed algorithm.

� 2012 Elsevier Inc. All rights reserved.

1. Introduction

The ripple effect metric shows what impact changes to software will likely have on the rest of the system. The com-putation of a ripple effect is based on the effect that a change to a single variable will have on the rest of a program, andthus, it provides a measure of the program’s complexity. Present practices of web-based software products and tools pro-vide ample opportunities for software development firms to seek a faster programming standard, and in turn, the alter-ation and migration of code to other platforms by its cross-compilation has become crucial. This phenomenon yieldsmany opportunities for the ripple effect to occur in a the web-based software environment, especially within the script-ing interface of a high-level language paradigm. The simplest application of scripting is to write short programs (scripts)that automate manual interactions with the computer [30]. A primary example is automating simulation and visualiza-tion: from an effective user interface, the script extracts information and generates input files for a simulation program,runs the program, archives data files, prepares input for a visualization program, creates plots and animations, andperhaps performs some data analysis. Considering the vistas of script language applications, we identify certain scientificapplications, which seldom invoke compiled languages, to perform string search operations on large array structures

. All rights reserved.

(S. Banerjee).

http://dx.doi.org/10.1016/j.ins.2012.01.007

mailto:[email protected]

http://dx.doi.org/10.1016/j.ins.2012.01.007

http://www.sciencedirect.com/science/journal/00200255

http://www.elsevier.com/locate/ins

S. Banerjee, H. Al-Qaheri / Information Sciences 193 (2012) 218–232 219

through the script itself. Hence, the combination of a mixed environment with script and high-level languageprogramming is highly desirable. We preferred to use Python as the preliminary script language because it could be com-bined with C++. Most languages offer the possibility to call code blocks written in other languages. In Python, however,this process is a simple and smooth. One reason is that Python was initially designed for integration with C and wasextended with new C code. The support for C implicitly provides support for closely related languages [28], like C++.There are different interfaces available, such as the Simplified Wrapper Interface Generator, to support the cross-compi-lation environment, but irrespective of the application, there are ripple effects observed on the development platformitself. The effect bogs down the rapid development saga of web-based practices, and more costs have been incurredin developing a wrapper interface.

To model and counter the effect on cross-compilation, we introduced a bio-inspired algorithm in the form of a modifiedAnt Colony Optimization, which was applied as an agent-based methodology to minimize the ripple in a Python to C++migration, caller and callee environment. The different artifacts of the Ant Colony Metaphor, such as the pheromone exten-sion, support the approach. The motivation behind the study and measure was triggered while developing a certain analysisof the large Social Network using Python Script.

The extension of basic Ant Colony Optimization techniques in terms of pheromone quantification helps users to organizeand store components in a repository and later can help in identifying the most appropriate component for a given context.Therefore, in the first stage, while searching, it makes use of keywords, their synonyms and their inter-relationships for theinitial or root language. It then makes use of the extended pheromone model; the initial pheromone of one is assigned to allof the domain representative terms of the components. By updating iteratively the pheromone for participating terms andnon-participating terms and by calculating the quality of each rule generated, we obtain quality rules to represent and re-trieve the reusable components.

The rest of the paper is organized as follows Section 1 describes the motivation behind the idea and also elaborates howthe ripple effect evolved from a mixed mode of programming for a social blog analysis. The approach behind the work isclearly defined in this section. Section 2 illustrates the problem of the ripple effect under web-based script languages. Section3 describes a modified bio-inspired algorithm to compensate for the ripple experienced during cross-coding, and it alsointroduces the innovative concept of Pheromone Extension (PE). Section 4 summarizes the results and implications of the pro-posed model and its advantages over the classical method for measuring the ripple effect. Finally, Section 5 provides the con-clusion with the further scope of research in this context.

1.1. Motivation behind the idea and Relevance of the Ant Colony Algorithm

During the blog analysis and sentiment mining of a commodity sales promotion house located in Mauritius, it wasobserved that one has to deploy both the script and the program developed with a high-level programming languageplot software tool. This implies that the analyst must return to the coding environment every time and would like tofind the compatibility among them. Due to different vendors and the presence of diversified philosophies behind soft-ware tools, it may be slightly difficult to cope with the ripple effect [11] across them. Hence, the idea of minimizing theripple arose. The work claims its originality by introducing an idea to minimize the wrapper interface ripple and byindicating potential research directions for the development of computationally intelligent tools in the softwareengineering domain of lower cost and lesser complexity. For optimization and search-based methodologies, in thelibrary of cross-code environments, certain primary optimization methods are sorted. Among them, Ant Colony Optimi-zation (ACO) and other evolutionary algorithms have been found to be attractive, and ACO has emerged as one of theprime tools for software testing by finding best test cases and optimizing different software metric measurements[6,12,18,20].

The Ant Colony (AC) algorithm has emerged recently as a new meta-heuristic method for solving NP-hard problems incombinatorial optimization [16]. Such meta-heuristic methods also include evolutionary algorithms, neural networks, andsimulated annealing, all of which belong to the class of problem-solving strategies derived from nature. Dorigo et al. intro-duced the first AC algorithm [9], representing the Traveling Salesman Problem (TSP). The AC algorithm is basically a multi-agent system, where low-level interactions between single agents, i.e. artificial ants, result in the complex behavior of thewhole ant colony. AC algorithms have been inspired by colonies of real ants, which deposit a chemical substance calledpheromone on the ground. This substance influences the choices they make: the larger the amount of pheromone is on aparticular path, the larger probability there is that an ant selects the path. Artificial ants in AC algorithms behave in a similarway. Thus, these ant colony behaviors construct a positive feedback loop, and the pheromone is used to communicate infor-mation among individuals and identify the shortest path from a food source to the nest. The Ant Colony algorithm simulatesthis mechanism of optimization, which can find the optimal solutions by means of communication and cooperation witheach other. Several interesting works establish the Ant Colony and its pheromone-updating and communication mechanismin detail [14,15,26].

The essence of the optimization process is given as follows:

� Learning mechanism: the more trail information an edge has, the more probability it has of being selected byevaporation

220 S. Banerjee, H. Al-Qaheri / Information Sciences 193 (2012) 218–232

� Updating mechanism: the intensity of trail information on the edge is increased by the ants passing it and decreased byevaporation.� Cooperative mechanism: communication and cooperation between individuals for trail information enable the Ant

Colony algorithm to have a strong capability for finding the best solutions.

The update mechanism and cooperation mechanism through pheromones has been envisaged in the present proposedmodel, which could reduce the overheads of developing a Wrapper Interface Generator for the cross-code environment.The prime parameter pheromone has been modified and extended to support the search for cross-code compatibility in asoftware library in a recursive fashion. Hence, pheromone extension is a newly introduced metaphor derived from the classicAnt Colony Optimization.

1.2. The ripple in social blog analysis

Blogs are commonly referred to as ‘‘frequently modified web pages in which dates are positioned in reverse chronolog-ical sequence’’ [27]. Blog data is social, temporal, and more generally, multi-faceted. Moreover, blogs are an amalgam be-tween a diary, a web site, and an online community. Categorically, they are personal in nature, published online, and arefrequently updated with links to similar and related topics, often from other bloggers. This interplay of blogs is describedas ‘the blogosphere’. The term ‘blog’ comes from an early description of the medium as a log or diary which is publishedon the internet, hence the contracted term ‘blog’ came from Web Log [21]. The information is important because of itstimely publication, ease of use, and wide availability. Practically, blogs seldom create new captions by exploring evidencesabout political events and facts. Structurally, blogs link to one another, creating a publicly available record of how infor-mation and influence propagate through an underlying social network. Aggregating links from several blog posts generatesa directed graph, which could be analyzed to mine the patterns of information propagation in blogspace [39] and therebyrealize the impact of the underlying social network. We initiated the primary work for the analysis of blogs and we expe-rienced a typical problem in determining the blog attributes, because those documents were no longer full Hyper TextMarkup Languages (HTML) pages. A blog post was an element in a feed or a subpart of an HTML page. In addition tothe grabbing of link hits, other information was extracted using a Python script, and an analysis of the data had to be fol-lowed by using C++ code. Using different languages for different tasks in a software system requires a sound strategy.Dynamically typed languages are normally implemented in C and therefore have well-documented recipes for how to ex-tend the language with new functions written in C. Similarly, C++ also can be mixed with Python script. The official elec-tronic Python documentation (see link from doc.html) has a tutorial for the C/C++ Application Program Interface (API), called‘‘Extending and Embedding the Python Interpreter’’ [41]. Simplified Wrapper Interface Generator (SWIG), originally devel-oped by David Beazley, automates the generation of wrapper code for interfacing C and C++ software from dynamicallytyped languages [28]. For the social blog analysis, the number-crunching ability of Python and finding its compatibilityin C++ for plotting the graphical attributes was a challenge. There are several tools available to support this part of SWIG[28], such as Instant. Instant allows for the lining of C or C++ functions in strings in Python script. The functions are auto-matically compiled and interfaced with SWIG to form an extension module. Hence, to use Instant, we need to have SWIGinstalled. The use of Instant is very simple. We write a C or C++ function for processing array data and store the code in aPython string source [29]. Thereafter, we call instant.inline_with_numpy [29] with the source as the argument, to-gether with an argument describing the relation between array pointers and integers holding the array dimensions inthe C or C++ function.

If we write the Socialloop function with a single pointer, it is possible to use tools to automatically wrap the C function.The relevant version of Socialloop takes the following form [29]:

typedef double (⁄Fxy)(double x, double y);

/⁄ function ptr Fxy ⁄/#define index (a, i, j) a[j⁄ny + i]void Socialloop (double ⁄a, double ⁄xcoor, double ⁄ycoor, int nx, ny, Fxy, func1)

{int i, j;

for (i = 0; i < nx; i++)for (j = 0; j < ny; j++)

index (a, i, j) = func1(xcoor[i], ycoor[j]);

}}

}

In the SocialloopDef class, we can add a method that creates access to a gridloop1 function in C using Instant. Becausewe wrote the C and C++ code in the Python program, it is natural to avoid callback to Python functions and instead call either


a C function or insert the function expression directly in the loop. The latter approach is the more efficient of the two and isused in this example [29]:

def ext_Socialoop_instant (self, fstr):

if not isinstance (fstr, str):

raise TypeError, n‘fstr must be string expression, not %s’, type(fstr)

/⁄ generate C++ source (fstr must be valid C++ code): ⁄/source = ’’’’’’void Socailoop (double ⁄a, int nx, int ny, double ⁄xcoor, double ⁄ycoor){# define index (a,i,j) a[i⁄ny + j]

int i,j;double x,y;

for (i = 0;i < nx;i++){for (j = 0;j < ny;j++){x = xcoor[i];y = ycoor[i];

index (a,i,j) = %s

}}

}

‘‘‘‘‘‘ %fstrtry:

from instant import inline_with_numpya = zeros ((self.nx, self.ny))

arrays = [[’nx’,’ny’,’a’],

[’nx’,’xcoor’], [’ny’,’ycoor’]]

self.Socialoop_instant = ninline_with_numpy (source, arrays = arrays)

except:self.Socialoop_instant = None

The shaded portion represents the interface part of the Python call. It becomes a complex wrapper generation program,and we have identified a ripple in social blog analysis in the form of the mixed programming environment. This part is anumber crunching module of a social blog with Python with a C++ interpretation for further analysis. In the next section,we elaborate the ripple in further detail and try to initiate a methodology to minimize it.

2. Ripple effect from Python script

Most languages offer the possibility to call code blocks written in other languages. In Python, this is a simple processwith a certain amount of ripple in between. Thus far, research built on the work of Black [2] has focused on the auto-matic computation of ripple effect measures within a practical timescale for procedural software, using the C program-ming language. Ripple Effect and Stability Tool (REST) was developed using an approximation algorithm to compute theripple effect for the C programming language [2]. To describe the compatibility of Python with C++ and its ripple, weexplain how the cross-compilation should be accomplished with the help of the Simplified Wrapper Interface Generator.And subsequently, we describe how computational intelligence could take care of the ripple effect during codemigration.

Suppose a Python script wants to call a C function that takes two doubles as arguments and returns a double:

extern double Test ðdouble t1;double t2Þ;

This C function will be available in a module; we call it Test. In the Python script, we can then write

from import test t1 = 1.2;

t2 = �1.2;s = Test (t1, t2);


The Python code must call a wrapper function (otherwise, it will create a ripple in the declaration itself) written in C,where the contents of the arguments are analyzed; the double precision floating-point numbers are extracted and storedin straight C double variables. The wrapper function can then call our C function Test. Since the Test function returns adouble, we need to convert this double to a Python object that can be returned to the Python code calling it which couldbe referred to by the objects [28].

A wrapper function looks like the following [28]:

Case 1: Primary Wrapper to prevent Ripples from Python to C++

static PyObject⁄_wrap_Test (PyObject ⁄self, PyObject ⁄args){double arg1, arg2, result;

if (!PyArg_ParseTuple (args, ‘‘Its a Test. ", & arg1, & arg2))

{return NULL; /⁄ wrong arguments provided ⁄/

}result = Test (arg1, arg2);

return Py_BuildValue (‘‘Its a test.", result);

}

All objects in Python (refer to Case 1 above) are derived from the PyObject ‘‘class’’. A wrapper function typically takestwo arguments, self and args. The first is of relevance only when dealing with instance methods, and args holds a tuple ofthe arguments sent from Python, here t1 and t2, which we expect to be two double,s. A third argument to the wrapperfunction may hold keyword arguments. We use the utility PyArg_ParseTuple [29] in the Python C library for convertingthe args object to two double variables (specified as the string ‘‘Its a Test’’). The doubles are stored in the help variablesarg1 and arg2. With these variables, we can call the Test function. The Py_BuildValue function from the Python C librarypacks a C variable (here of type double) as a Python object, which is returned to the calling code and appears there as astandard Python float object [28].

The above illustration shows that writing a wrapper code is error-prone because each C and C++ function should have itsown corresponding wrapper code. Beazley realized important breakthroughs in automating wrapper code for C and C++ [3].We move to Case 2 to illustrate the prevention of ripples when combining functions of C++ and Python script, which is sub-stantially more complex in nature. Functionally, a C++ version of Python code semantically follows from the following steps:

� Definition of interface with Python for C++ in library.� Compilation and linking.

Case 2: C++ version of Python code

#include < iostream>#include < math.h>double Test1(double t1, double t2)

{double s = sin (t1 + t2);

return s;

}void Test2(double t1, double t2)

{double s = sin (t1 + t2);

std::cout �"It’s a test ! sin ("�t1 �"+" �t2�")=" �s�std::endl;

}void Test3(double t1, double t2, double ⁄s){⁄s = sin (t1 + t2);

}

The Test3 function will normally use a reference instead of a pointer for the s argument. This version of Test3 is calledTest4 in the C++ code:


void Test4(double r1, double r2, double & s)

{s = sin (r1 + r2);

}

Defining interface

/⁄ file:Test.i ⁄/%module Test

%{/ ⁄ include C++ header files necessary to compile the interface ⁄/

#include "Test.h"

%}%include "typemaps.i’’%apply double ⁄OUTPUT {double ⁄s}%apply double ⁄OUTPUT {double & s}%include "Test.h"

Using % to handle the output argument in Test4 enables us to define the interface by just including the header fileTest.h, where all the C++ functions in Test.cpp are listed. The interface file then takes the following form:

/⁄ file:Test.i ⁄/%module Test

%{/⁄ include C++ header files necessary to compile the interface ⁄/#include "Test.h"

%}%include "typemaps.i’’%apply double ⁄OUTPUT {double ⁄s}%apply double ⁄OUTPUT {double &s}% apply extern void t4 (double t1, double t2, double &s);%include "Test.h"

Here, we have two modules. The first is a C++ wrapper code Test_wrap.cxx and a Python module file Test.py. The nextstep is to compile the wrapper code and the C++ functions and then link the pieces together as a shared library _Test.so. AC++ compiler is used for this purpose.

2.1. Related work on ripple minimization: a survey

The ripple effect measurement and measure of prevention was initiated using the primitive ripple effect algorithm pro-posed by Yau and Collofello [47]. The ripple effect measures the impact or how likely it is that a change to a particular mod-ule may cause problems in the rest of a program. It can also be used as an indicator of the complexity of a particular moduleor program. In the 1980s, the general emphasis for software measurement extended from source code measurement to mea-surement of design. The thinking behind this was that, if design measurement gave feedback earlier in the software lifecycle,problems could be identified and eliminated or controlled before the source code was actually written, thus saving time andmoney [7].

Recently, several modified propositions have been suggested for the reformulation of Yau and Collofello’s ripple effectalgorithm focusing on the computation of an intramodule change propagation information matrix [9]. This work basicallyaims to put forward and validate the approximated ripple effect as a replacement for Yau and Collofello’s original ripple ef-fect measure. In addition, this paper introduces the intramodule change propagation matrix and, in this context, intramoduleand inter-module change propagations are explained, and exhaustive details are given of how they are calculated withexample code fragments to clarify their semantics. Continuing the analysis and measurement of the ripple effect, it has beenobserved that code migration and software platform dependency become phenomenal, and thus ripple minimization hasbeen contemplated as a major issues in complex or web-centric environments. The relationship between the approximatedripple effect and a programmer’s intuitive idea of the ripple effect has also been studied [8]. In this paper, the psychology andtendency of the programmer is established in the form of the correlation between the approximated ripple effect and theprogrammer’s predicted ripple effect. The two broader effects, e.g., the stabilizing effect and the scaling effect, are mentioned,and thus, the relevance and impact of the ripple are presented. The present work also solicits certain important softwaremeasurement policies pertaining to the maintenance of quantitative metrics and models for predicting the web applications’

Fig. 1. A methodology for software maintenance [47].


maintainability. It has been identified that the maintenance of software is affected by the ripple [4] and its post processes. Inthe context of the classical software maintenance process (see Fig. 1), the ripple effect [35] is identified in Phase 3.3.

Recent research has empirically explored the relationships between existing UML design metrics based on Conallen’sextension for web applications and maintenance effort. These efforts are good examples of an analysis of the side effectsof code complexity and migration [24].

Ripples signify an important role in finding order and dependencies in program-slicing techniques [1]. Because the rippleeffect has a dirct impact on the measurement of control dependencies, there is a simple transformation-based analysis algo-rithm for measuring the global impact of dependence [5]. Finally, the algorithm evaluates clusters. Recent works also dem-onstrate complex impacts related to requirements volatility on a software development project, and they also envisage theripple effect [23]. Serious considerations are given to combine the agile and formal methods for the software application do-main, where ripple is again a major concern [10]. Software maintenance efforts improvise the cost aspect of software and theeffect of ripple in cross-coding, and platform migration broadly depicts the importance of maintenance engineering [46].Hence, the minimization of ripples takes care off the attribute with respect to the relationship between the metrics andthe time needed for understanding and modification [17,33].

Collective intelligence has been emerged as prime vertical to constitute swarm intelligence, from where the mapping ofpheromone could be initiated. Several illustrated examples of modeling collective intelligence are cited as multi-player gameand collaborative robotics [43] and the scope of collective and hybrid intelligence has been extended from the single robotcontrol to multiple collaborative robots. Thus relevant software artifacts are expressed in terms of operational morphology


and control [22]. The phenomena of multiple robots and their control definitely improvises the adaptive framework for ser-vice ecosystem. There are sound research initiatives where it can be applied at any scale, from work teams to huge networksor even to our whole species. Collective intelligence is a determining factor in competitiveness, creativity and human devel-opment in a knowledge based economy, or in an information economy [45]. With the help of Hidden Markov model (HMM)we can explore various techniques of accurate metadata extraction. The research led to the development of a trigram,introducing new soothing techniques for transition probabilities and proposal of techniques for emission probabilities. Mea-suring the size of the data sets on training procedure and comparing the result with related works, it was found to be moreaccurate and precise than 95% measures, giving it a cutting edge [38]. The Information Economy Meta Language (IEML) is aregular language providing new methods for semantic interoperability, semantic navigation, collective categorization andself-referential collective intelligence. The language has voluminous potential implications for the growth of collective intel-ligence in cyberspace [31]. To minimize the losses of software industry due to poor project implementation skills, experi-ences of project managers can be in the form of narratives aggregated together to form an Experience Exchange Library.The set of design principles can be evaluated theoretically and empirically to ensure the technology serves as a mediumfor facilitating experience reuse [40]. To support program execution over multiple Prolog processes with constraints, a pro-gramming language called CSPCONS is used. It is an extended version of CSP-II, which supports channel based communica-tion and TCP/IP communication, and inherits all its features. Additionally it possesses constraint solving abilities where eachsolver functions independently but are attached to each other. Such a model is used to facilitate the implementation of dis-tributed constraint satisfaction problem [42]. And in order to provide users with a shared space, collaborative platform forpublishing multi-dimensional geo-data and for stimulating and analyzing complex geo-phenomena, a Distributed VirtualGeographic Environment needs to be designed. This can be constructed by web service technology due to its ability to sup-port multi-platform, multi-architecture, multi-program-language interoperability and share programs, data and software[48]. Centralized approach of simply classifying projects which envision knowledge dissemination holds inconsistenciesleading many users to abandon this kind of system. Moreover, due to the incoherence much of tacit knowledge and inter-action possibilities are also lost. Thus, on the basis of the advantages of distributed approach and improvement of interac-tion, a Mobile Exchange of Knowledge has been designed, which enables exchanging of knowledge amongst people sharingsame interests [37]. With the emergence of ubiquitous computing technology, the birth of ubiquitous robotics has come intopicture. To aid this, a Ubiquitous Robotic Framework needs to be designed and implemented such that a robotic system canbe interoperable in any service environments automatically rather than statistically pre-programmed for its environment.This can be achieved by Semantic Web Services Technologies [25]. At times a mismatch may arise due to early design deci-sion in software architecture between the quality attribute levels and those realized by object oriented materializations thattake place during detailed designing levels. Since materialization activities are mainly driven by past developers experiences,we propose a Case-based Reasoning (CBR) approach that, through the codification of design experiences, permits to establishlinks between software architecture structures and object-oriented counterparts [44].

3. Pheromone extension: definition and implementation

We started a prototype study to incorporate computational intelligence to keep track of the ripple during code migrationin the form of a bio-inspired natural algorithm. Nature shows us examples of intelligence in groups of beings (agents) withlimited cognitive capacity, such as ants, bees and termites. Communication in insect societies may occur directly or indi-rectly (e.g. pheromones). This indirect communication via the environment is referred to as stigmergy [47]. Pheromone-com-munication is the basis for Ant Colony Optimization (ACO) [34], where positive and negative feedback (via the addition andthe evaporation of the pheromone already in the environment, respectively) lead to the formation of spatial–temporal struc-tures that converge to optimal or near-optimal solutions [13].

To prevent the ripple effect introduced in the cross-code, we propose an experimental model of metaheuristics inspiredby natural ants. ACO [19,36,11] is a paradigm for designing metaheuristic algorithms for combinatorial optimization (CO)problems like the Traveling Salesperson Problem, Graph Coloring Problem [6], Quadratic Assignment Problem, etc. The algo-rithms are inspired by the trail-laying and following behavior of natural ants. While roaming from food sources to their des-tinations or vice versa, some of the ant species mark their paths by a chemical called pheromone. Other foraging ants can

Fig. 2. Conceptual representation of pheromone extension on ripple.

Fig. 3. Search scheme for ant on cross-code graph structure.


detect pheromone and choose, in probability, paths marked by stronger pheromone concentrations. Thus pheromone trailshelp ants find the way traced by their team members towards food sources or nests. Any optimization problem can be rep-resented as a triple (S, f,X), where S is the set of candidate solutions; f(s, t) is the objective function over the elements s 2 S,and X(t) represents the problem constraints. The objective in such problems is to find a globally optimum solution s⁄ suchthat f(s⁄, t) 6 f(s, t) for all s 2 S. To solve such problems using the ACO metaheuristic, the problem is mapped to an environ-ment that can be represented by a connected graph GC = (C,L) [11], where C = {c1,c2, . . . ,cN} is the finite set of components,and L is the set of links that connects fully the components in C. The states of the problem are defined in terms of sequencesx = hci,cj, . . . ,cn, . . .i of finite length over the elements of C. X is the set of all possible states. The set of candidate solutions S is asubset of X. S� specifies the set of feasible candidate solutions, which is again a subset of S.

We initially follow a bi-focal approach for the simulation:

� Coverage terrain of pheromone for the ripple [13]: This implies a pheromone indicator (marked as green patch) that willmove along with a ripple dynamically on the C++ to Python caller or callee situation (Refer Fig. 2). We define it as pher-omone Extension (PE), denoted as s + .� With the help of pheromone extension, the ripple produced in the cross-code is optimized, and a library search of the test

string for compatibility of code is minimized. The deposition of pheromone in the direct graph interpreted for the cross-code depends on a predefined probability vale, and hence, the traversal of ant from one node to another node in the direc-ted graph is controlled by the pheromone extension parameter.

The stepwise approach for compensating the ripple and incorporating computational intelligence in the wrapper inter-face could be described as follows:

� The caller and callee for the cross-code (e.g. from C++ to Python) is interpreted into a node-based connected graph rep-resentation including the terminal symbol and Boolean operators (Refer Fig. 3).� The entire caller-callee code that need to be migrated could form a cluster in a symbolic graph, and from the graph, an

approximate number of terminal symbols are segregated for the target platform (shown in Fig. 3). This traversal followsthe optimized rule to find the interface of compatibility for the wrapper class.� When a wrapper interface generator wraps a C++ class, the wrapper functions are stand-alone functions, not member

functions of a class. Therefore, when PyObject (Refer Case 1) is derived, there is scope of proxy class interfaces; hence,the string in the C++ function It’s a Test could be tested whether it falls under the predefined production rules. Here,we introduce the artificial ant with pheromone and its extension module on the code for a string search. The productionrules are marked by the pheromone mark. In the process, the proxy class interface will be easier to search and overheadwill be reduced.� A single node is connected to the other nodes, which implies that there is a provision of traversing from one node to any

other node. Artificial ants are endowed with some attributes to move through this connected graph. Each ant is providedwith the starting string, which may be the test string given in the example code. This string is stored in a stack in the ant’smemory.� The core of this approach relates to the ability of an ant to choose the next destination j based on how good j is compared

to all the allowed locations in a neighborhood N. The probabilistic equation used to simulate the ants choice of locations isfound below [13]:

pijðtÞ ¼½sij�a½gij�

b

P8k2N½sij�a½gij�

b ð1Þ

The equation above depends on two components: s is a learned parameter indicating the amount of pheromone in a given
location, while s is static information such as the (inverse of the) distance to a given location. The importance of the com-ponents can be regulated with the factors a and b. To completely understand the above formula, we need to describe thepheromone update rule of s which is formulated as follows [13]:

sij ¼ q � sij þ ð1� qÞ � Dsij; ð2Þ

where Dsij refers to the amount of pheromone dropped since the last iteration and the factor q represents the evaporationrate applied to the old pheromone sij.

� From Eqs. (1) and (2), the Pheromone Extension (PE) indicated as s+ is defined as follows:

Ssþ ¼ Eð�Þ½ð1� qÞ � ðSsþÞi�1� þ Dsðx0Þ; ð3Þ

where Dsðx0Þ ¼Pn

i¼1 exp� dðxi ;x0 Þ2

2d2 .

Ds(x0) is the total density of pheromone covered by the terrain (of n ants and production rules) where the test string of thecross-code is tested. d denotes the spread of Gaussian function (used for mapping purposes). If the total aggregation pher-omone density at the 1st position is greater than at its previous position, then the movement of an ant is governed by theamount of pheromone deposited at different points in the search space of the directed graph for the cross-code. Ss+ is a recur-sive function, and it finally helps in building Py_BuildValue.

4. Results and implications

To evaluate the goodness of our approach, we have developed a simulation model where ants traverse an environmentusing the pheromone extension approach to minimize the search compatibility of the wrapper interface of C++ to Pythoncall. The stepwise algorithm is coded with a Microsoft F# script. The choice of another scripting language is only to testthe proposed concept and to avoid extra complexity in the solution code itself. To show a uniform coverage, we used thestandard deviation of how many times an ant visits each cell. Parameters such as the number of ants, number of pheromoneunits used by each agent, evaporation rate of the pheromone, pheromone update rule, a, b, the weights for pheromone con-centration and visibility can be initialized according to Table 1.

The relevance of the parameter settings in Table 1 has been referenced from different benchmark applications of ACO.There is a single parameter setting that performs best during most of the available runtime. Hence, there does not appearto be a clear benefit in varying the parameter settings at run-time. Because the present application offers more search timein the compatible wrapper search for the target platform, the conclusion remains the same if the Ant Colony System (ACS) isrun without a local search. The main difference is that the performance is more variable and more dependent on specificparameter values.

Medium range values of b equal to 2 or 5 produce the best results during most of the runtime. Smaller values of b areinitially worse but, after enough computation time, they eventually match the results of the default value. Much larger val-ues (e.g., b = 10) are quickly outperformed by smaller ones.

The default value of 10 ants results in very good performance at any time. Interestingly, very small values (notably n = 1)make the algorithm’s performance slightly worse during the entire runtime, whereas much larger values (n = 50) lead toinsignificant results. The latter effect is probably due to too much diversification because of the application of the local pher-omone update rule in ACS. Surprisingly, the differences among different settings of q are almost non-perceptible. Without alocal search, large q values produce a faster convergence. However, after a short time, small values close to the default(q = 0:1) produce progressively better results. However, in the present case, a 0.16 value is impressive.

The value of d and g have been fixed as the search on the terminal symbol of the given code (to be migrated) should not bestagnant until the target platform wrapper is found.

In all simulations, the environment is a 2D toroidal grid. That means that each cell has 8 neighbors independent of itslocation in the grid [13]. This was initially possible as code structure supports function calls, e.g. void Test 2() or void

Table 1Initial parameter of ACO in simulation.

Initial parameters Tested value

n 5, 10, 20, 50b 2, 3, 4, 5, 6q 0.16, 0.25, 0.33, 0.42d [0, 1]g 0–0.5

Table 2Experimental results for pheromone extension.

Pheromone extension Update Proportion on string search Evaporation on search Threshold error for C++ to Python call (%)

Iteration 1 6 units 0.75 0 0.5Iteration 2 12 units 0.10 0.3 0.048Iteration 3 18 units 0.81 0.03 0.2

Pheromone Distribution Towards Wrapper Class Construction

0.0 0.2 0.4 0.6 0.8 1.0 1.2Theoritical Cumulative Distribution of Pheromone

-0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

Em

peri

cal C

umul

ativ

e D

istr

ibut

ion

ofP

hero

mon

e

Fig. 4. Pheromone distribution index.

Fig. 5. Searching for a wrapper class through the pheromone extension for cross-code.


Test 3(), and this is interpreted as a directed graph with cells (Refer Fig. 2). For Eqs. (1) and (2), we used a = 1 and b = 1,which means that we are giving the same importance to information about food and information regarding the exiting pher-omone. The different values of d (for mapping) in the range [0,1] have been considered for pheromone extension (s+). Valuesof g and threshold density are kept to a minimum of 0–0.5. At each step of the simulation (all ants perform one move), anevaporation factor is applied. Each cell is initialized with 20 units of food, which are consumed one by one as the ants walk tothat location. The minimum amount of pheromone per cell is one, and the same is true for the food; otherwise, the proba-bility of choosing a cell could reach zero. Every time an ant visits a cell, it consumes 1 unit of food and leaves double the unitsof pheromone (6 ? 12 ? 18) [refer Table 2]. The results shown are the average of 10 runs and 3 iterations for each code seg-ment of the C++ call from the Python library. At the end of each simulation (all with the same number of execution steps), weused the counter in each cell (number of times an ant passed the location) and calculated the standard deviation for the en-tire environment.

Table 3Ripple-free function list on pheromone extension.

No. of iterations forpheromone extension

No. of functionevaluations

Best ripple freefunction value

250 1889 2189.03224 1463 2189.03137 754 2189.18

65 445 2189.1838 273 2189.18


It is observed that the pheromone extension update on the 1st deposition demonstrates 0.75 units of pheromone, and theaccuracy of the string search is 0.5%. On iteration 3, the result is slightly better, and conventionally, the proposed algorithm iscomputationally less expensive and complex.

In Fig. 4, we demonstrate a plot that shows both the theoretical and empirical values of pheromone deposition on thedirected graph of cross-code (from C++ to Python call). Initially, the deposition overlaps in the form of the compatible stringsearch (already shown in the 1st iteration in Table 2), and slowly, both are on same value of convergence. Finally, the pher-omone evaporates, and it does not continue a fresh search of strings; otherwise, the process would have to be initiated again.

4.1. Experimental representation of the model

The proposed simulation also performed a simple pattern search using the pheromone extension, and the algorithm takesat least two input arguments, namely the objective function and a starting point. Direct search methods require many func-tion evaluations, compared with derivative-based optimization methods. The proposed pheromone extension algorithm canquickly find the neighborhood of an optimum point where the wrapper interface is exactly located for cross-coding, butit may be slow in detecting the minimum itself. This is the cost of not using derivatives. Hence, the proposed pheromoneextension algorithm can reduce the number of function evaluations by using an accelerator. When the accelerator is ‘on’the mesh size is contracted rapidly until some minimum mesh size is reached. This option is recommended only for smoothproblems; in this problem of social blog analysis, the ripple is initially at the minimum except for the calculation of the socialblog hit. The accelerator is ‘off’ by default. Here, we set the accelerator to ‘on’ because we know that our objective function issmooth and is limited to Socialloop. Additionally, the algorithm can use an additional search at every iteration against thecross-code library. This option is called the ‘SearchMethod’. When a ‘SearchMethod’ is provided, that search is done first be-fore the 2D toroidal grid search. If the ‘SearchMethod’ is successful, the mesh search, commonly called the ‘PollMethod’ isskipped. If the search method is unsuccessful in improving the current point, the poll method is performed [32]. The simu-lation yields the following.

� Identification of an optimized or a minimized ripple-free function value.� Iteration of the pheromone extension.� Ripple minimization per interval in cross-code.

Using MATLAB and Microsoft F# script, Fig. 5a demonstrates the result in details. For the first set of the curve plottedagainst an iteration of the pheromone extension value and ripple-free function value after 250–273 iterations, the best rip-ple-free function appears to be at a value 2189.18, indicated by a black arrow mark in fig. (Refer Table 3), which is a quiteimpressive search from one code compatibility to another.

Subsequently, Fig. 5b plots the pattern of search for a compatible wrapper function from Python to C++ during a socialblog analysis. It is plotted against the ripple minimization per interval in cross-code versus the iteration of the pheromoneextension from Python to C++ code migration. It must be noted that, as the number of iterations of pheromone extensiondecreases, the search for compatible functions decreases as well and becomes steady at a value of 2189.18 (Refer to Table3). This is an optimized and a minimized value of the ripple-free function value searched and directed through the phero-mone extension, instead of searching the appropriate wrapper class interface.

The general observations regarding the ripple effect from C++ to Python are as follows:

� Use virtual methods for A::f (), B::f (), C::f () where we can put a large chunk of code, but we often later have to makesame changes in each of the virtual methods A::f (), B::f (), C::f (). Therefore, the ripple still persists.� Use one A::f (), but implement helper hook methods (virtually). That is, A::f () calls helper hook methods h1(), h2(),

etc., and subclasses B and C implement the right hook methods. The slight disadvantage caused by the ripple here is justbecause B::h1() and C::h2() are needed, and in that case, we need to declare A::h1(), A::h2() and B::h2(). The pro-cess is cumbersome and creates overheads. The hooking methods usually access data members of the subclasses, which iswhy one cannot simply use if statement blocks inside A::f () to accommodate the needs of the subclasses.� Using the function pointer is not recommended, but in Python, it minimizes the problem of ripple. To add a new hook, we

can write the following:

Fig. 6. Performance analysis with No. of communication to find a wrapper interface.


if hasattr (object, ‘f’):

x = object.f ()

The user can modify the code at only two points, exactly where it is required to modify, and there are no ripple effects atany other places in the code. Moreover, in Python, the argument list of methods is flexible, so the hooks can be implementedwith different argument lists in different subclasses.

if object._class_ == B:

x = object.f (y)

elif object._class_ == C:

x = object.f (y, z)

The proposed pheromone extension model can be used for the hooking purpose for C++ code instead of creating an alter-native wrapper class. The pheromone extension module also has a flexible argument list, and moreover, the probabilistic Eq.(1) demonstrates the control parameters. Hence, the computational effort will be less for a more cost-effective code migra-tion without the ripple effect, and a wrapper interface can be achieved.

4.2. Functional benefits of the proposed approach

When the studies and simulation presented in this paper were performed, no published work existed on ripple minimi-zation using bio-inspired algorithms or evolutionary algorithms. However, it was not the primary goal of this work to onlyintroduce the algorithm. Additionally, an issue had to be solved during this study and that was the usage of the extension ofan existing ant colony and the pheromone deposition mechanism, on a larger scale, for a cross-code and code migration envi-ronment. The solution chosen is a very pragmatic one, and it is not a general solution to the subject. The suggested minimi-zation offers the following broad solutions.

� It is especially related to Python to C++ cross migration, therefore it could tackle the periphery of the ripple easily. Here,only function migration from one code to another is discussed, and the ripple generated through handling the class inboth environments can also be addressed with the pheromone extension mechanism.� The solution is logical and cost-effective as ACO comprises a very simple concept, and the ideas can be implemented in a

few lines of code. It requires only primitive mathematical operators and is computationally inexpensive in terms of bothmemory requirements and speed. Hence, a suitable compatibility of code from the library can be easily searched out.� Furthermore, an ant colony system has memory and learning ability, which we have not incorporated in this proposed

model. Therefore, the search capability and convergence of cross-code compatibility will be higher if the proposed pher-omone extension is supported by the learning and memory parameters.

Table 4Comparison with benchmark data sets.

TSP benchmark Conventional ACS/ACO Proposed pheromone extension Optimum

Best Average Worst Best Average Worst

ulysses16 74.16 74.11 74.09 74.16 74.14 74.11 74eil76 545.39 546.22 551.93 544.43 552.54 557.45 538eil101 642.66 652.30 684.19 640.17 649.48 662.24 629


4.2.1. Efficiency analysisThe proposed pheromone extension module to minimize the ripple effect and to find an effective cross-code wrapper inter-

face has been validated both theoretically and empirically. It has been mentioned that there is so far no evolutionary algo-rithm to minimize the ripple effect. Therefore, to draw a comparison between the pheromone extension and its counterpartACO, we used standard symmetric TSP benchmark problems to conduct experiments.

We found a number of effective communications in the pheromone update module to find an ideal wrapper for targetcode, and we also compared two elapses, e.g. the normal elapse in run and elapses occurring due to ripples (refer Fig. 6).For the three benchmark instances taken, the proposed pheromone extension found near-optimal and better solutions (Table4), and it is expected that more fine-tuning of parameters could converge more efficient results in the pheromone extensionmodule.

5. Conclusion and further scope of research

This paper proposes an alternative mechanism to minimize the ripple effect experience during web-based programmingenvironment. The proposal incorporates an ant colony-based optimization and its prime components in the model with cus-tomized modifications. The modifications have been suggested as a pheromone extension module to track the ripple effectbased on the pheromone deposition and evaporation mechanism. It has been noticed that the proposed method well suitedfor a cross-coding platform in the form of a string search and acts as a probabilistic production rule for searching for com-patibility in the target code. The example code is cited through a C++-Python script interface. Natural heuristics and bio-in-spired algorithms are cost-effective and less complex solutions for guided search. Hence, instead of developing bulk-compatible interfaces, certain plug-in tools for cross-coding can be created to prevent the ripple and to assist the fast paceof the software development paradigm using the ant colony metaphor and its several other verticals. The work can also beperformed for bio-inspired parser development for cross-coding, where it can bypass or eliminate left-recursion, because oneant will invariably find the correct path and, when one does, the others will soon follow. Therefore, our approach does notrequire working with context-free or non-redundant grammar. This is a substantial simplification of the parsing problem.Subsequently, the visualization of the proposed solution could be simpler, compared to complex wrapper interfaceconstruction.

The prototype limitation is primarily because of the non-availability wrapper benchmark data set, and the testing para-digm is also limited. It has been realized that a more cross-code complex structure could form a better perspective to incor-porate bio-inspired and evolutionary agents with these categories of library and wrapper search problems. The cost of thesearch path is less expansive; hence, more trials and iterations can be performed on the cross-code, and the automation ofevolutionary cross-code parsing can be significant.

Acknowledgement

The present case study and data was taken from a commodity sales promotion house located in Mauritius. The work ispartially supported by the Department of Computer Science, Birla Institute of Technology, International Center, Mauritius,and Mauritius Research Council, Govt. of Mauritius. The authors are also grateful to Dr. Partha Dey for his invaluable tech-nical comments while preparing the text.

References

[1] T. Amtoft, K. Androutsopoulos, D. Clark, M. Harman, Z. Li, An alternative characterization of weak order dependence, Information Processing Letters 110(21) (2010) 939–943.

[2] B. Baudry, F. Fleurey, Y.L. Traon, J.-M. Jézéquel, An original approach for automatic test cases optimization: a bacteriologic algorithm, IEEE Software 2(22) (2005) 76–82.

[3] D. Beazley, Python Essential Reference, third ed., SAMS, 2006.[4] P. Bhatt, G. Shroff, A. Misra, Dynamics of software maintenance, ACM SIGSOFT Software Engineering Notes 29 (04) (2004) 1–5.[5] D. Binkley, M. Harman, Y. Hassoun, S. Islam, Z. Li, Assessing the impact of global variables on program dependence and dependence clusters, The

Journal of Systems and Software 83 (2010) 96–107.[6] S.E. Black, Computation of ripple effect measures for software, Ph.D. thesis, London South Bank University, London, UK, 2001.[7] S.E. Black, Computing ripple effect for software maintenance, Software Maintenance: Research and Practice 13 (4) (2001).[8] S.E. Black, Is ripple effect intuitive? A pilot study, in: Innovations in Systems and Software Engineering, A NASA Journal, vol. 2, Springer-Verlag, London,

2006, pp. 88–98.[9] S.E. Black, Deriving an Approximation Algorithm for Automatic Computation of Ripple Effect Measures, Information and Software Technology, vol. 50,

Elsevier, 2008. 723–736.[10] S.E. Black, P. Boca, J.P. Bowen, J. Gorman, M. Hinchey, Formal vs agile: survival of the fittest, IEEE Computer (2009) 37–45.[11] S.E. Black, P.E. Rosner, Measuring ripple effect for the object oriented paradigm, in: IASTED International Conference on Software Engineering,

Februaray 2005.[12] L. Bottaci, Use of branch cost functions to diversify the search for test data, in: Third UK Testing Workshop University of Sheffield Computer Science

Technical Report, 2005, pp. 151–163.[13] M. Braga, A model for terrain coverage inspired by ant’s alarm pheromones, in: Proceedings of the 2007 ACM Symposium on Applied Computing – SAC

07, 2007.[14] K.W. Chau, Application of a pso-based neural network in analysis of outcomes of construction claims, Automation in Construction 16 (5) (2004) 63–76.[15] S.C. Chau, J.F. Roddick, J.S. Pan, Ant colony system with communication strategies, Software Engineering 167 (4) (2004) 63–76.[16] D. Costa, A. Hertz, Ants can color graphs, Journal of the Operational Research Society 48 (3) (1997) 295–305.


[17] E. DGhosheh, S. Black, J. Qaddour, An introduction of new uml design metrics for web applications, Journal of Computer & Information Science 8 (4)(2007) 600–609.

[18] M. Dorigo, M. Birattari, T. Stiizle, Ant colony optimization: artificial ants as a computational intelligence technique, IEEE Computational IntelligenceMagazine 01 (4) (2006).

[19] M. Dorigo, C. Blum, Ant colony optimization theory: a survey, Theoretical Computer Science 344 (1) (2005) 243–278.[20] M. Dorigo, V. Maniezzo, A. Colorni, The ant system: optimization by a colony of cooperating agents, IEEE Transactions on Systems, Man, and

Cybernetics Part B: Cybernetics 26 (1) (1996).[21] M. Dorigo, T. Stiizle, Ant Colony Optimization, MIT Press, Cambridge, 2004.[22] R.J. Duro, M. Grana, J. de Lope, On the potential contributions of hybrid intelligent approaches to multi component robotic system development,

Information Sciences 180 (2010) 2635–2648.[23] S. Ferreira, J. Collofello, D. Shunk, G. Mackulak, Understanding the effects of requirements volatility in software engineering by using analytical

modeling and software process simulation, The Journal of Systems and Software 82 (10) (2009) 1568–1577.[24] E. Ghosheh, S. Black, E. Kapetanios, M. Baldwin, Exploring the relationship between uml design metrics for web applications and maintainability,

Journal of Object Technology 9 (3) (2010) 125–144.[25] Y.-G. Ha, J.-C. Sohn, Y.-J. Cho, H. Yoon, A robotic service framework supporting automated integration of ubiquitous sensors and devices, Information

Sciences 177 (2007) 657–679.[26] A.-Q. Hameed, A. Mustafi, S. Banerjee, Digital watermarking using ant colony optimization in fractional fourier domain, Journal of Information Hiding

and Multimedia Signal Processing 1 (3) (2010).[27] M. Jones, I. Alony, Blogs – the new source of data analysis issues, Informing Science and Information Technology 5 (2008).[28] Langtangen, Texts in Computational Science and Engineering, vol. 3, Chapter: Combining Python with Fortran, C, and C++, 2008, pp. 189–226.[29] Langtangen, Texts in Computational Science and Engineering, vol. 3, Chapter: C and C++ Programming with NumPy Arrays, 2008, pp. 483–528.[30] H.P. Langtangen, Python Scripting for Computational Science, Springer-Verlag, 2008.[31] P. Lvy, From social computing to reflexive collective intelligence: the IEML research program, Information Sciences 180 (2010) 71–94.[32] Mathworks, Global optimization toolbox, 2011. <http://www.mathworks.de/products/gads/demos.html?file=/products/demos/shipping/gads/

psoptionsdemo.html>.[33] P. McMinn, D. Binkley, M. Harman, Testability transformation for efficient automated test data search in the presence of nesting, in: Third UK Testing

Workshop University of Sheffield Computer Science Technical Report, 2005, pp. 165–182.[34] P. McMinn, M. Holcombe, Hybridizing evolutionary testing with the chaining approach, in: Genetic and Evolutionary Computation Conference, GECCO

2004, vol. 3103, Springer-Verlag, 2004, pp. 1363–1374.[35] G. Mishne, M. de Rijke, Effect analysis of software maintenance, in: Proceedings COMPSAC-78, 1978, pp. 60–65.[36] G. Mishne, M. de Rijke, Capturing global mood levels using blog posts, in: AAAI Spring Symposium on Computational Approaches to Analyzing

Weblogs, 2006.[37] R. Monclar, A. Tecla, J. Oliveira, J.M. de Souza, Mek: using spatial-temporal information to improve social networks and knowledge dissemination,

Information Sciences 179 (2009) 2524–2537.[38] B. Ojokoh, M. Zhang, J. Tang, A trigram hidden markov model for metadata extraction from heterogeneous references, Information Sciences 181 (2011)

1538–1551.[39] I. Ounis, C. Macdonald, I. Soboroff, On the TREC blog track, in: Proceedings of AAAI, 2008.[40] S. Petter, V. Vaishnavi, Facilitating experience reuse among software project managers, Information Sciences 178 (2008) 1783–1802.[41] G.v. Rossum, F.L. Drake, Extending and embedding the python interpreter, 2011. <http://docs.Python.org/ext/ext.html>.[42] I. Sakellariou, I. Vlahavas, I. Futo, Z. Pasztor, J. Szeredi, Communicating sequential processes for distributed constraint satisfaction, Information Sciences

176 (2006) 490–521.[43] M.C. Schut, On model design for simulation of collective intelligence, Information Sciences 180 (2010) 132–155.[44] G. Vazquez, J.A.D. Pace, M. Campo, Reusing design experiences to materialize software architectures into object-oriented designs, Information Sciences

180 (2010) 971–983.[45] M. Viroli, A biochemical approach to adaptive service ecosystems, Information Sciences 180 (2010) 1876–1892.[46] G. Walia, J.A. Carver, Systematic literature review to identify and classify software requirement errors, Information and Software Technology 51 (7)

(2009) 1087–1109.[47] S.S. Yau, J.S. Collofello, Some stability measures for software maintenance, Software Engineering 6 (6) (1980) 545–552.[48] J. Zhang, J. Gong, H. Lin, G. Wang, J. Huang, J. Zhu, B. Xu, J. Teng, Design and development of distributed virtual geographic environment system based

on web services, Information Sciences 177 (2007) 3968–3980.

http://www.mathworks.de/products/gads/demos.html?file=/products/demos/shipping/gads/psoptionsdemo.html

http://www.mathworks.de/products/gads/demos.html?file=/products/demos/shipping/gads/psoptionsdemo.html

http://docs.Python.org/ext/ext.html

Documents

Minimizing the ripple effect of web-centric software by using the pheromone extension