Mining Reusable Software Components from Object-Oriented Source Code using Discrete PSO and Modeling Them as Java Beans

Object-based software development in the IT-industry during the last decade has focused on reusing the already developed elements. Current software development models and technologies promote software reuse by utilizing component-oriented programming. Component-oriented programming provides more effective reuse as compared to its object-oriented language counterpart. This is because a component provides more abstractness in terms of the functionality in contrast to the object-oriented software element (e.g. class/ interface). The component-based development is highly dependent on the availability of the component library that contains well-defined and already tested functionality in terms of the available components. However, the suitable availability of such component library is still a problem. The lack of a suitable component library is tackled either by designing new components from scratch or by identifying them from the existing software systems. These identified components must be transformed as per component models, such as a Java Bean, in order to increase software reuse and faster software development, and little research has been carried out in this direction. Although many approaches have been proposed to identify components from existing systems and build a component library. But, such approaches lack in transforming the identified components as per specifications of a component model. Further identification of reusable elements also needs to be more accurate and efficient. Accuracy is dependent on the structural and semantic properties of a component. A component can consist of a single or a group of individual elements of the software, and thus identifying components from a set of all elements becomes an exponentially growing problem. Such problems can be more efficiently solved using metaheuristic algorithms. Therefore, this paper targets identifying accurately the components from a singular existing software system and transform those identified components to the Java Bean component model standard. The component identification approach of this paper is based on clustering the underlying software system by utilizing a metaheuristic search-based PSO algorithm. The clusters are identified as a group containing 2/ 3/ 4 software elements. Moreover, the used fitness function is based on the structural (based on usage for member variables) and semantic relations belonging to a software. Since the PSO algorithm is generally applied to continuous problems, whereas our formulated component identification problem is discrete (due to the representation of particles) in nature. Therefore, we have also provided a mechanism through which the PSO algorithm is modified to become applicable to discrete problems. From the obtained clusters (components), the interfaces of the components are identified by identifying independent chains in call-graphs of the underlying components. Finally, these components are transformed as per the Java Bean component model specifications. The proposed approach is validated experimentally on 7 open-source object-oriented Java software systems and results are compared with competitive approaches. The obtained results confirm the correctness of the transformed component and hence their reusability.