14th Asia-Pacific Software Engineering Conference
Approximation Algorithms for Software Component Selection Problem Nima Haghpanah Department of Computer Engineering Sharif University of Technology Tehran, Iran
[email protected]
Shahrouz Moaven Department of Computer Engineering Sharif University of Technology Tehran, Iran
[email protected]
Jafar Habibi Department of Computer Engineering Sharif University of Technology Tehran, Iran
[email protected]
Mehdi Kargar Department of Computer Engineering Sharif University of Technology Tehran, Iran
[email protected]
Soheil Hassas Yeganeh Department of Computer Engineering Sharif University of Technology Tehran, Iran
[email protected]
Abstract
gorithms.
Today’s software systems are more frequently composed from preexisting commercial or non-commercial components and connectors. These components provide complex and independent functionality and are engaged in complex interactions. Component-Based Software Engineering (CBSE) is concerned with composing, selecting and designing such components. As the popularity of this approach and hence number of commercially available software components grows, selecting a set of components to satisfy a set of requirements while minimizing cost is becoming more difficult. This problem necessitates the design of efficient algorithms to automate component selection for software developing organizations. We address this challenge through analysis of Component Selection, the NP-complete process of selecting a minimal cost set of components to satisfy a set of objectives. Due to the high order of computational complexity of this problem, we examine approximating solutions that make the component selection process practicable. We adapt a greedy approach and a genetic algorithm to approximate this problem. We examined the performance of studied algorithms on a set of selected ActiveX components. Comparing the results of these two algorithms with the choices made by a group of human experts shows that we obtain better results using these approximation al-
1530-1362/07 $25.00 © 2007 IEEE DOI 10.1109/ASPEC.2007.38
1. Introduction Component based software engineering is achieving more popularity in today’s software development community due to the increasing complexity of software systems, increasing costs of maintenance, and decreasing costs of underlying hardware. This causes software community to follow Brook’s famous ”buy versus build” colloquy [5]. Business organizations therefore prefer to build their systems from previously built components which means they should concentrate more on selecting and composing components than manually adopt software systems. As the popularity of such approaches grows, commercial software vendors tend to develop more commercial software components and connectors. Using such Commercial of The Shelf (COTS) components and connectors, organizations can decrease upfront cost, development time, maintenance and modification costs. Considering these economic benefits, organizations prefer to select and compose COTS components into a working software system to meet their functional and quality requirements. Time and effort can be saved using Component-Based
159
2. Related Work
Development (CBD) by reusing existing assets to build new systems. These components may be preexisting intraorganization components or commercially purchased ones. A component may be any reusable and independent unit of functionality, such as a class or a library. The process of development of a software system thus changes to combining components through selection of components, adaptation of components, composing them with each other and existing system and testing of the developed system. Since all activities in such process is influenced by the first step of selecting components, the process of component selection becomes an important aspect of CBD.
Several researchers have been working on componentbased software architectures, component integration; OffThe-Shelf (OTS) based system development and architecture mismatch analysis. Software component composition is defined by Szyperski [27] as ”assembly of parts (components) into a whole (a composite) without modifying the parts.” By software composition, we usually mean the composition of components to satisfy functional requirements, where each component possesses a clearly defined interface and functional description [4]. Component selection methods are traditionally done in an architecture-centric manner, i.e they aim to answer the question: given a description of a component needed in a system, what is the best existing alternative available in the market? Researchers have proposed several COTS component selection approaches [8][18][1]. Of these approaches, [8],[1] are largely geared towards the selection and implementation of COTS based on business and functional criteria. The approach presented by Mancebo et al. in [18] focuses on a COTS-selection process based architectural constraints, and does not address the interoperability issue. Ballurio et al. [3] provide a detailed but time intensive and manual method for assessment of COTS component interoperability, making it inappropriate for assessing large number of COTS combinations. Another type of component selection approaches is built around the relationship between requirements and components available for use. The goal here is to recognize the mutual influence between requirements and components in order to obtain a set of requirements that is consistent with what the market has to offer. This is done by merging requirements engineering and component selection techniques. Examples of these methods include PORE [20] and CRE [2] In any component selection method, it is unrealistic to expect a perfect match between components needed and components available. A group of components that compose a system may have overlaps and gaps in required functionality. A gap represents a lack of functionality; an overlap can cause a confusion of responsibility and degrade nonfunctional properties like size and performance. However, in our approach we does not consider this problem for simplicity. Complexity of component selection and algorithms to approximate this problem has been also studied by several researchers. Fox et al. define component selection as the problem of choosing the minimum number of components from a set of components such that their composition satisfies a set of objectives [10]. It is an NP-complete opti-
In this paper, we consider the problem of component selection. It is the problem of selecting a set of components with minimum cost to satisfy a set of requirements. To build a component based system, there may exist a huge subset of candidate commercial products which may partially fulfill expected requirements. From the set of all available components, the manager must search for a subset that satisfies requirements while minimizing the cost of purchasing or adopting components. For systems with more than a few simple components the search space is unmanageably large and complex, with the consequence that no manager can be expected to find optimal choices that balance the constraints without some form of automated support. For the NP-complete problem of component selection to be achievable in reasonable time, the selection of a set of components must be accomplishable in polynomial-time. In this paper we adapt two approximation algorithms for component selection and compare their results. We use a genetic algorithm and a greedy algorithm for this purpose. We choose to study Greedy on component selection because Greedy is one of the best polynomial-time algorithms for approximating Minimum Set Cover (MSC) and Set Cover Problem (SCP), closely related NP-complete problems shown to be related to component selection [26]. This paper presents the study results of the application of automated approaches to the stated problem. The paper formulates the problem in terms of a series of feature subset selection problems and presents algorithms for its solution using search based software engineering. The experimental results shows the power of automated tools in helping humans in the real world and frequently occurring problem of component selection. The rest of this paper is organized as follows: section 2 includes related work on component selection and related NP-complete problems. Section 3 defines the problem formally and section 4 describes our studied solutions. After presenting experimental results of our algorithm and a comparison between them and human judgment in section 5, we conclude our paper in section 6.
160
of a set of requirements R and a set of components X. A candidate subset of X does not have to meet all target requirements fully. Given sufficient time and effort, any component can be adapted to meet any requirement, so all components are potential candidates to meet some or all target requirements. Each component can satisfy up to θ requirements. They allow for the possibility that the utility of a component xi satisfying requirement rj might be a function of the number of other requirements xi also satisfies. The goal is to maximize the aggregate utility of the selected set of components. This situation is much more applicable for simulation than software engineering since it insists on adapting every component for any requirement.
mization problem formally shown to be embedded within composability [24]. It was conjectured to be NP-complete in [21] and proven to be so in [24]. Actually, this problem, cardinality set cover problem, is an especial case of the problem we will consider here in that it assumes equal costs for all components. Several Genetic and Heuristic algorithms have been proposed for the Set Cover Problem, which is equal to our definition of component selection problem [25][16][15]. Carlson [6] defined component selection differently and used a genetic algorithm to solve the problem. It defines the process of designing an engineering system from offthe-shelf components and combining them to form a functional system. There exists a set of generic components and for each of these components there exists a set of components that can be chosen for its implementation. Carlson defines Component selection as the process of selecting specific components from manufacturers’ catalog considering the effects choosing a component would possibly have on other components. To evaluate each design generated by the genetic algorithm, a simulation for each phase of the system is run, and a fitness value is calculated based on how well the design performs. It uses the objective: obj(xi ) =
n
wj sj
3. Formal Statement of the Problem In this paper we are working with a model of software development in which software systems are constructed as an agglomeration of sets of components with well defined behaviors and interfaces. This model of software development is becoming more prevalent with the advent of component-based software engineering and with the increasing reliance of large organizations upon out-sourcing of software development, service-based approaches and the construction of architectures into which trusted and semitrusted components are assembled. Informally, our problem is to select a set of components from available component set which can satisfy a given set of requirements while minimizing sum of the costs of selected components. To achieve this goal, we should assign each component a set of requirements it satisfies. Each requirement can be satisfied by more than one component and each component may satisfy more than one requirement. Each component is assigned a cost which is the overall cost of acquisition and adaptation of that component. We simplified our problem by assigning a cost value to each component whereas the cost value in a more general situation can be assigned to any subset of components which reflects the dependency of cost of adopting components to the set of components meant to be combined. Total cost of a set of selected components (a subset of whole component set) is sum of the costs of the member components. Set of requirements a component set can satisfy is union of sets of satisfied requirements over all components. Actually, every subset of these requirement set can be assumed satisfied by this component set. Symmetrically, every superset a set of components which satisfy a requirement set R can also satisfy R. Assuming that each requirement can be satisfied by at least one component, there can be multiple component sets that can satisfy each specific set of requirements. Our goal is to choose the set with minimum cost among these candidate sets. It should be noted that only functional requirements can
(1)
j=1
Where wj is the weight for each criterion, sj is a numerical score for that criterion, and n is the total number of optimization criteria. A comparison of the algorithm is performed using two industrial design problems. Baker et al. [23] present two algorithms for component selection and prioritization for the next release problem where components will determine special, additional features or functions of the next release in the evolution of the software. Each component is characterized by a set of values, including estimates of the cost of acquisition, customer desirability and expected development time and revenue. They associate a weight (or score) with each component where they combine the cost of acquisition and development time to a single cost value ci , and customer desirability and expected revenue to a weight value wi , and the value of the item, xi where i is an index of the components. The goal is to maximize n wj xj , subject to j=1 n j=1 cj xj ≤ K, xj ∈ {0, 1}. The knapsack problem is known to be NP-hard. However, it can be solved by a pseudo-polynomial algorithm using dynamic programming [22]. Bartholet et al. [4] studied the computational complexity of component selection in simulation reuse. They propose their definition of component selection and prove the following problem NP-complete. They assume the existence
161
Table 1. Illustration of GA Algorithm Input: (R, X) Step 0: Give parameter settings, e.g. population size sp , crossover rate rc , mutation rate rm and the maximum number of population generation npg . Step 1: Randomly generate sp individuals as an initial population p0 , k ← 0. Step 2: while k < npg do Evaluate pk , i.e. compute the fitness of every individual in pk produce a new generation, pk+1 , using the following steps : 1) Select (1 − rc ) × sp members of pk with the highest fitness value and add them to pk+1 . 2) Select (rc × sp )/2 pairs of individuals from pk . for each pair of (S1 , S2 ), produce two individuals by crossover operator and add them to pk+1 . 3) Select rm percentage of the individuals in pk , apply mutation operator on them and add them to pk+1 . k ←k+1 Step 3: return the individual with the highest fitness, S, as the result
4. Applied Algorithms
be incorporated into our problem. This is because we assumed the set of requirements a set of components can satisfy is the union of the sets of requirements each individual component from component set satisfies. This assumption is true only for functional requirements. If a component can satisfy a functional requirement, each component set containing that component can do that too. However, this is obviously not possible for nun-functional requirements. For example, a component that satisfies our availability requirement can not guarantee this requirement to be satisfied by every component set containing this component.
This section presents details description of our two studied algorithms. First we discuss a genetic algorithm and then a greedy algorithm to solve component selection problem. Pseudocodes of these algorithms are also presented. the Genetic Algorithm is from [25] with little modifications and the Greedy Algorithm is from [7],[13],[17].
4.1. Genetic Algorithm Genetic algorithms (GA) are derivative-free, stochasticoptimization methods based loosely on the concepts of natural selection and evolutionary processes. They were first proposed and investigated by John Holland at the University of Michigan in 1975. The basic idea of genetic algorithms was revealed by a number of biologists when they used computers to perform simulations of natural genetic systems. In these systems, one or more chromosomes combine to form the total genetic prescription for the construction and operation of some organism. The chromosomes are composed of genes, which may take a number of values called allela values. The position of a gene (its locus) is identified separately from the gene’s function. Thus, we can talk of a particular gene, e.g., an animal’s eye-color gene with its locus at position 10 and its allela value as blue eyes.
A formal definition of the problem is as follows. Consider R, the set of ρ requirements to be satisfied (target requirements) as R = {r1 , r2 , . . . , rρ } and X, the set of γ components available for selection as X = {x1 , x2 , . . . , xγ }. Each component xi can satisfy up to ρ requirements. In addition cost(xi ), is the cost of component xi . Each component xi is assigned with a set of requirements, say Ri = {r1i , r2i , . . . , rki }, it can satisfy. The goal is to find a set of components S in such a way that every requirement rj from the set R can be assigned a component xi from S where rj is in Ri , while minimizing xi ∈S cost(xi ). In the next section, a metaheuristic genetic algorithm and a greedy algorithm for this optimization problem are presented.
162
Table 2. Illustration of Greedy Algorithm Input: (R, X) Step 1:S = N U LL U =R Step 2: while U = N U LL do choose an xi from X such that |Ri ∩ U |/cost(xi ) is maximal S = S + xi U = U − Ri Step 3: return S, as the result
Genetic Algorithms are inspired by biological systems’ improved fitness through evolution [12]. A solution to a given problem is represented in the form of a string, called ’chromosome’, consisting of a set of elements, called ’genes’, that hold a set of values for the optimization variables [11].
follows. In mutation, a random position i is chosen and the component that satisfies ith requirement would be randomly substituted by another component that can satisfy this requirement. Thus, mutating a solution S = {c1 , c2 , . . . , ci , . . . , cρ } by its ith position would result a new solution S = {c1 , c2 , . . . , ci , . . . , cρ }, where both ci and ci are components satisfying ith requirement.
Genetic Algorithms work with a random population of solutions (chromosomes). The fitness of each chromosome is determined by evaluating it against an objective function. To simulate the natural survival of the fittest process, best chromosomes exchange information (through crossover or mutation) to produce offspring chromosomes.
In crossover, two solutions A and B are joined to produce another valid solution T . Having A = {a1 , a2 , . . . , aρ } and B = {b1 , b2 , . . . , bρ }, A random position j is chosen and A and B are combined to produce T = {a1 , a2 , . . . , aj , bj+1 , bj+2 , . . . , bρ }.
A genetic algorithm for a particular problem must have five components [19]. A genetic representation for potential solutions to the problem, A way to create an initial population of potential solutions, An evaluation function that plays the role of the environment rating solutions in terms of their ”fitness”, Genetic operators that alter the composition of children during reproduction, and values for various parameters that the genetic algorithm uses (population size, probabilities of applying genetic operators, etc.). Mutation and Crossover are operators that are used for genetic algorithms. Crossover is a two operand operator which simulates coupling of two fit individuals to produce another individual which inherits characteristics from both parents. Mutation takes one individual as input and simulates genetic change in one individual.
The fitness is the sum of the costs of the distinct components used in that solution and the objective is to minimize this value. The pseudocode of the GA algorithm is illustrated in Table 1.
4.2. Greedy Algorithm In contrast to previous component selection problems in [10],[24],[21], our problem considers a more realistic case in which cost of components may be different. The greedy approach proposed in [2] can no more be used since it is only considered with minimizing the number of components used. Using that algorithm for this problem will neglect the fact that a component which can satisfy the most number of requirements may not be a suitable heuristic choice since its cost may be much more than the other alternatives. The solution is to consider the proportion of number of requirements satisfied to the cost of the component as a measure to maximize for our heuristic decision. In this way, a component that costs 1 units and satisfies 1 requirement will be preferred to the one which satisfies 2 requirements but costs 100 units. The pseudocode of our greedy algorithm is illustrated in Table 2.
One of the primary decisions to be made concerning any genetic algorithm is encoding. For the component selection problem, candidate solutions are represented using an integer encoding scheme specific to the application. Each possible solution in the community would be of the form S = {c1 , c2 , . . . , cρ } , where each ci is component number that satisfies requirement ri in present solution. Considering that a single component can be assigned to more than one requirement (up to the number of requirements it can satisfy), a ci may be repeated in a solution. Design of mutation and crossover operators for this problem are as what
163
0.109 0.112 0.2 0.1150.18 0.1180.16 0.1180.14 0.1230.12 0.129 0.1 0.1330.08 0.1330.06 0.1360.04 0.1380.02 0.14 0 0.143 0.143 0.144
5. Experiments
Score
5.1. The Environment For the experimental study, we use a set of ActiveX controls as the set of components. In this paper the terms ActiveX control and ActiveX component are interchangeable. ActiveX is a wide set of technologies based on Microsoft’s Component Object Model (COM)[9],[14]. Each ActiveX control is a software component, developed in one of a number of programming languages. Thus, ActiveX is language independent. It can be embedded in a web page or downloaded from a web page. An ActiveX control is in fact an object which is defined as an instance of a class, combining both data and procedures (e.g. an ActiveX control on a running form is an object). ActiveX controls may have visual elements and are controlled by a programming language. But it might not have any visual element. Each ActiveX control has a set of properties. In this study, each ActiveX control property is assumed to be a requirement which can be satisfied by it. Thus, a component, say xi , which is an ActiveX control has a set of requirements, say Ri , that can be satisfied by it. It should be mentioned that some AciveX controls may satisfy the same requirements. In other words, the set of requirement that each component can satisfy, has overlap with the set of requirements that other components can satisfy. The set of requirements, R, is assumed to be the set of all properties of all ActiveX controls. An example is presented here to clarify the process of preparing the dataset. Consider an AcitveX control which performs the Fast Fourier Transform (FFT) of a given input sequence; also it can multiply two input matrixes. This AcitveX control has no visual interface. Now consider another AcitveX control which performs the Fast Fourier Transform (FFT) of a given input sequence with a visual interface. Each of these components has two properties. In this study these properties are assumed to be the set of requirements that they can satisfy. Therefore first component can satisfy calculating FFT and multiply two matrixes. The second one can satisfy calculating FFT with a visual interface. Thus these two components can satisfy a same requirement, calculating FFT. Also they can satisfy other requirements that the other one can not. Thus, the set of requirements that an AcitveX control can satisfy, could be extracted from its properties. A cost value, cost(xi ), is assigned to component xi using a normal distribution with mean proportional to |Ri |. I.e. there exists a constant k so that the mean of a random variable cost(xi ) is k.|Ri | for every component i. In this way a component which satisfied more requirements probably has a higher cost, which is considered true in real world. We generated our dataset using a set of 60 components
0.094 0.099 0.099 0.099 0.1 0.102 0.103 0.103 0.104 0.109 0.109 0.111 0.114 41 43 0.115 0.115
43 44 45 46 47 48 49 50 Genetic Algorithm 51 Greedy Algorithm 52 53 Expert Judgment 54 55 45 47 49 51 53 55 57 59 56 Number of Components 57
Figure 1. Score achieved by each algorithm with fixed requirement set of size 16 and different component sets of sizes 41 to 60
downloaded form the Internet. We analyzed the component set to extract a set of 16 requirements from it. The number of requirements each component satisfies varies from 1 to 6 for different components. Several experiments were designed using the dataset to compare the performance of the different approaches. These approaches are automated greedy and genetic algorithms, and expert judgement. For the third approach, we arranged a team of five human software experts. This group is provided a number requirements to satisfy and a set of components each associated a set of satisfied requirements and a real valued cost, and asked to select a minimum cost subset of this components to satisfy all the requirements based on their knowledge and experience. In each experiment, we selected a subset of the component dataset with regard to different components and the requirements satisfied, and compared the cost of the result generated by each method.
5.2. Results Figure 1 shows outcome of our two algorithms on a component set of size varying from 40 to 60 associated with a requirement set of size 16 which did not change during the experiment. In addition to our implemented algorithms, we included the outcome achieved by a group of human experts from the same input to compare performance of our algorithm with expert judgment. To improve accuracy, for each k from 41 to 60, we selected 3 independent subsets of size k of components, ran each algorithm (and expert judgment) of each of these three sets, and averaged them. The score of each algorithm of each input size, shown by vertical line, is 1/cost where cost is the sum of the costs of the selected components. As can be seen in the figure, since the set of requirements was kept unchanged, algorithms would achieve
164
0.143 0.128 0.125 0.123 0.123 0.123 0.123
10 11 12 13 14 15 16
0.109 0.208 0.5 0.112 0.223 16 0.115 0.229 11 0.118 0.247 6 0.4 0.118 0.264 0.123 0.273 0.3 0.129 0.277 0.133 0.282 0.133 0.285 0.2 0.136 0.288 0.138 0.293 0.14 0.295 0.1 0.143 0.298 0.143 0.299 0.144 0 0.3 0.144 410.301 43 0.145 0.301 0.145 0.301
Genetic Algorithm Greedy Algorithm Expert Judgment
Score
Score
211 0.35 0.163 201 0.156 182 0.3 0.152 183 0.152 0.25 181 0.148 176 0.2 0.145 173 0.145 0.15 0.1 0.05 0 7
9
11
13
15
Number of Requirments
Figure 2. Score achieved by each algorithm with fixed component set of size 60 and different requirement sets of sizes 7 to 16
Score
0.23 0.342 0.6 0.237 0.359 16 0.237 0.375 11 0.268 0.394 0.5 0.273 0.441 6 0.279 0.461 0.4 0.293 0.473 0.304 0.487 0.3 0.311 0.499 0.319 0.515 0.2 0.324 0.522 0.333 0.538 0.1 0.341 0.551 0.3440 0.553 0.348 41 0.557 43 45 0.349 0.559 0.35 0.561
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 49 47 51 53 55 58 Number of Components 59
0.322 43 0.358 44 0.372 45 0.396 46 0.413 47 0.422 48 0.435 49 0.449 50 0.467 51 0.472 52 0.477 53 0.483 54 0.487 55 0.489 56 0.493 57 0.49647 45 49 58 51 53 55 0.499 59 Number of Components 0.499 60
57
59
Figure 4. Performance of Greedy Algorithm Regarding Different Requirement and component numbers
cost. On the other hand, increasing the input component set size results in better results in both algorithms.
6. Conclusion and Future Work
57
This paper has shown how ideas from search based software engineering can be applied to problems of software component selection, producing results which ourperform those produced by expert judgment alone. The paper reports on the application of both greedy and genetic algorithms to this component selection problem. The results were compared to expert judgment for a largescale real world set of features, representing a set of components in a software component base. The results show that both of the automated techniques outperform the expert ranking, with the genetic approach providing superior results to the greedy approach. One line of future work on component selection would be designing approximation algorithms for this problem for more general cases in which utility of a component regarding a requirement could take values from [0..1], instead of the discrete zero or one values assumed here. Moreover, including non-functional requirements in the set of requirements can be a challenging problem which could be a subject for future research.
59
Figure 3. Performance of Genetic Algorithm Regarding Different Requirement and component numbers
better results if run of input component sets of larger size. Another point is the greedy nature of human behavior of such problem which makes human results similar to greedy algorithm for small inputs, although increasing input size results in less accurate results by human experts. Figure 2 shows results of three approaches on an input set of 60 components with assigned requirement sets of sizes 7 to 16. Selecting a number of components to satisfy 6 requirements is obviously easier than selecting them to satisfy 16 requirements. This point can be seen in decreasing trends of all algorithms as the number of requirements grows. Like previous experiment, the results of three algorithms are similar for small inputs whereas the difference grows for larger input sets. The effect of sizes of input requirement and component sets can be seen in figures 3 and 4. As expected, decreasing the number of requirements to satisfy by a fixed set of components results in output component sets with lower overall
References [1] C. Albert and L. Brownsword. Evolutionary process for integrating cots-based systems (epic). CMU/SEI Technical Report CMU/SEI, 2002. [2] C. Alves and J. Castro. Cre: A systematic method for cots component selection. In Brazilian Symposium on Software Engineering, 2001.
165
[3] K. Ballurio, B. Scalzo, and L. Rose. Risk reduction in cots software selection with basis. In Proc. ICCBSS, 2003. [4] R. Bartholet, D. Brogan, and P. Reynolds. The computational complexity of component selection in simulation reuse. In Proceedings of the 37th Conference on Winter Simulation, pages 2472–2481, 2005. [5] F. Brooks. No silver bullet: Essence and accidents of software engineering. Computer, 20:10–19, 1987. [6] S. E. Carlson. Genetic algorithm attributes for component selection. Research in Engineering Design, 8(1):33–51, January 1996. [7] V. Chvatal. A greedy heuristic for the set covering problem. Mathematics of operations research, 4:233–235, 1979. [8] S. Comella-Dorda, J. Dean, G. Lewis, E. Morris, P. Oberndorf, and E. Harper. A process for cots software product evaluation. In Proc. ICCBSS, 2002. [9] M. Corporation. Visual Basic 5, Component Tools Guide. Microsoft Press, 1997. [10] M. Fox, D. Brogan, and P. Reynolds. Approximating component selection. ACM/IEEE Winter Simulation Conference, 2004. [11] D. Goldberg. Genetic algorithms in search, optimization and machine learning. MA: Addison-Wesley Publishing Co, 1989. [12] J. Holland. Adaptation in natural and artificial systems. Ann Arbor, MI: University of Michigan Press, 1975. [13] D. Johnson. Approxiation algorithms for combinatorial problems. Journal of Computer and System Sceinces, 9:256–278, January 1974. [14] D. Kruglinski, G. Shepherd, and S. Wingo. Programming Microsoft Visual C++. Microsoft Press, 1998. [15] G. E. Liepins, M. R. Hilliard, M. Palmer, and M. Monow. Greedy genetics. J. J. Grdenstettc, editor, Genetic Algorithm and Their Applications: Proceedings of the Snd Internationd Conference on Genetic Algorithms,, July 1987. [16] G. E. Liepins, M. R. Hilliard, J. Richardson, and M.Palmer. Genetic algorithms applications to set covercing and traveling salesman problems. Brown (ed), Operations Research and Artificial Intelligence: The Integration of ProblemSolving Stmtegies, Kluwer Academic Publishers, 1990. [17] L. Lovasz. On the ratio of optimal integral and fractional covers. Discrete Mathematics, 31(7):383–390, January 1975. [18] E. Mancebo and A. Andrews. A strategy for selecting multiple components. In Proc. ACM SAC, 2005. [19] Z. Michalewicz and C. Janikow. Genocop: a genetic algorithm for numerical optimization problems with linear constraints. commun. ACM 39, 1996. [20] C. Ncube and N. Maiden. Pore: Procurement-oriented requirements engineering method for the component based systems engineering development paradigm. In Int’l Conf. Software Eng. CBSE Workshop, 1999. [21] E. Page and J. M. Opper. Observations on the complexity of composable simulation. In Proceedings of the 1999 Winter Simulation Conference New York: ACM Press, pages 553– 560, 1999. [22] C. H. Papadimitriou and K. Steiglitz. Combinatorial optimization: Algorithms and complexity. Dover, 1998.
[23] K. S. Paul Baker, Mark Harman and A. Skaliotis. Search based approaches to component selection and prioritization for the next release problem. ICSM 2006, pages 176–185, 2006. [24] M. Petty, E. Weisel, and R. Mielke. Computational complexity of selecting components for composition. Proceedings of the Fall 2003 Simulation Interoperability Workshop, pages 14–19, September 2003. [25] S. Sen. Minimal set covering using probabilistic methods. In Proceedings of ACM/SIGAPP Symposium of Applied Computing, pages 157–164, 1993. [26] P. Slavik. A tight analysis of the greedy algorithm set cover. Proceedings of the Twenty-eighth Annual ACM Symposium on Theory of Computing, 1996. [27] C. Szyperski. Component software: Beyond objectoriented programming. Addison-Wesley, Erewhon, NC, 2002.
166
