Automated classification and retrieval of reusable software components

Starting from the principle of software reusability through formal specifications, the authors suggest a model for the retrieval of reusable components utilizing the search techniques in database management systems. The formal specification language of software components is ASL. Component specifications will be translated into a specification written in the knowledge representation Telos for storage and other manipulation. The retrieval of software components is based on signature matching between the signatures of goal specifications and those of reusable components. In this way, the authors overcome some of the main problems with respect to retrieval such as representation of reusable components, representation of goal specification, and name differences in the software. The retrieval mechanism is supported by the database management system ConceptBase. >

This paper is concerned with the organization and retrieval of reusable software components with the aid of unsupervised learning. The methods considered of unsupervised learning include FUZZY ISODATA and Kohonen self-organizing maps. The key issues addressed in the study include information retrieval in the presence of incomplete information, and domain specific enhancements of unsupervised learning, including those of partial supervision. The primary intention is to reveal how the learning mechanism can accommodate individual preferences (profile) of the users viewed as a significant component of organization and retrieval algorithms. Numerical examples use a set of MS-DOS system commands and a collection of reusable C++ classes. © 1997 by John Wiley & Sons, Ltd.

Automated assistance for software component reuse involves supporting retrieval, adaptation and verification of software components. The informality of feature-based software classification schemes is an impediment to formally verifying the reusability of a software component. The use of formal specifications to model and retrieve reusable components alleviates the informality, but the formal reasoning required for retrieval introduces questions of scalability. To provide scalability, current retrieval systems resort to syntactic classification at some level of abstraction, abandoning the semantic information provided by the specification. We propose a methodology that shifts the overhead of formal reasoning from the retrieval to the classification phase of reuse. Software components are classified using semantic features that are derived from their formal specification. Retrieval of functionally similar components can then be accomplished based on the stored feature sets. Formal verification can be applied to precisely determine the reusability of the set of similar components.

Storage and representation of reusable software components in software repositories to facilitate convenient identification and retrieval has been always a concern for software reuse researchers. This paper discusses and demonstrated an ant colony algorithm based technique that generates rules to store and then identify the component from software repository for possible reuse. Proposed technique helps user in organization and storage of components in repository and later can help in identifying most appropriate component for given context. In first stage while searching it makes use of keywords, their synonyms and their inter-relationships. Then it makes use of ant colony optimization; initial pheromone of one is assigned to all domain representative terms of components. By updating pheromone for participating terms and non-participating terms iteratively and by calculating the quality of each rule generated, it leads to quality rules to represent and retrieve the reusable components

Scientific missions in the Earth sciences frequently require cost-effective, highly reliable, and easy-to-use software, which can be a challenge for software developers to provide. The NASA Earth Science Enterprise (ESE) spends a significant amount of resources developing software components and other software development artifacts that may also be of value if reused in other projects requiring similar functionality. In general, software reuse is often defined as utilizing existing software artifacts. Software reuse can improve productivity and quality while decreasing the cost of software development, as documented by case studies in the literature. Since large software systems are often the results of the integration of many smaller and sometimes reusable components, ensuring reusability of such software components becomes a necessity. Indeed, designing software components with reusability as a requirement can increase the software reuse potential within a community such as the NASA ESE community. The NASA Earth Science Data Systems (ESDS) Software Reuse Working Group is chartered to oversee the development of a process that will maximize the reuse potential of existing software components while recommending strategies for maximizing the reusability potential of yet-to-be-designed components. As part of this work, two surveys of the Earth science community were conducted. The first was performed in 2004 and distributed among government employees and contractors. A follow-up survey was performed in 2005 and distributed among a wider community, to include members of industry and academia. The surveys were designed to collect information on subjects such as the current software reuse practices of Earth science software developers, why they choose to reuse software, and what perceived barriers prevent them from reusing software. In this paper, we compare the results of these surveys, summarize the observed trends, and discuss the findings. The results are very similar, with the second, larger survey confirming the basic results of the first, smaller survey. The results suggest that reuse of ESE software can drive down the cost and time of system development, increase flexibility and responsiveness of these systems to new technologies and requirements, and increase effective and accountable community participation.

Using formal specifications to represent software components facilitates the determination of reusability because they more precisely characterize the functionality of the software, and the well-defined syntax makes processing amenable to automation. This paper presents an approach, based on formal methods, to the search, retrieval, and modification of reusable software components. From a two-tiered hierarchy of reusable software components, the existing components that are analogous to the query specification are retrieved from the hierarchy. The specification for an analogous retrieved component is compared to the query specification to determine what changes need to be applied to the corresponding program component in order to make it satisfy the query specification.

Introduces the concept of reusable software component retrieval using normalized formal specifications. Reusable Ada software components are stored in a software base that supports a rapid prototyping system called CAPS (Computer Aided Prototyping System). Each component in the software base has a corresponding formal specification. A query in the form of a formal specification is used to search for candidate components that satisfy the requirements of the query. The specification languages used are the Prototype System Description Language (PSDL) and OBJ3. Each specification is normalized to facilitate component retrieval. This paper describes the software base model, syntactic and semantic normalization, and the component retrieval mechanisms. >

This paper presents and validates a methodology for integrating reusable software components in diverse game engines. While conforming to the RAGE component-based architecture described elsewhere, the paper explains how the interactions and data exchange processes between a reusable software component and a game engine should be implemented for procuring seamless integration. To this end, a RAGE-compliant C# software component providing a difficulty adaptation routine was integrated with an exemplary strategic tile-based game TileZero. Implementations in MonoGame, Unity and Xamarin, respectively, have demonstrated successful portability of the adaptation component. Also, portability across various delivery platforms Windows desktop, iOS, Android, Windows Phone was established. Thereby this study has established the validity of the RAGE architecture and its underlying interaction processes for the cross-platform and cross-game engine reuse of software components. The RAGE architecture thereby accommodates the large scale development and application of reusable software components for serious gaming.

Each phase of software development life cycle has the potential for reuse. However, according to the viewpoint of cost and reusability, the design phase is the most suitable phase for packaging the reusable software components. In this paper, we describe the design component knowledge extraction and representation method for component retrieval. The design knowledge is based on the principle of structured design and object-oriented design. According to the valuable and clearly design component knowledge, we generate a rule-based system which contains the component matching rules and retrieval supporting rules. Using these rules not only can assist the potential reusers retrieve the more suitable design component but also can improve component retrieval performance.

KAPSEL is a new object-oriented programming language to encourage the building of reusable software components. The components, i.e. classes, establish clear boundaries between their implementation detail and their outside-visible specification. The underlying software concept employed is that of encapsulation: the close integration and protection of information and its functionality. The paper explores the basic idea of encapsulation in object-oriented methodology: as it applies to objects, classes and class hierarchies, and introduces the programming language-KAPSEL-which facilitates the specification of reusable object-oriented software components.

Software reuse is one of the major research area in component based software engineering (CBSE). It is an area which integrates all the other technical areas like data mining, soft computing, artificial intelligence etc. The major areas which are to be focused in software reuse are classification, clustering, searching, indexing and retrieval of software components. There are many techniques described in literature each with their advantages and limitations. In this paper, we propose a dynamic approach where the components are retrieved by using genetic algorithm. The proposed algorithm mainly focuses on the termination condition or stopping criteria of Genetic Algorithm, which changes dynamically based on the user query. Genetic Algorithm (GA) stops the evolution i.e., reaches convergence when the average fitness value of the population becomes equal to the fitness value of the user query.

Many regard widespread development and reuse of software components as one of the next biggest phenomena for software. However, widespread reuse of a software component with poor quality may lead to disasters. Improper reuse of software components of good quality may also be disastrous. Testing and quality assurance is therefore critical for both software components and component-based software systems. This tutorial provides an in-depth look at the technical issues, challenges, managerial aspects, and needs in testing of components and systems. Moreover, this tutorial reports on the recent advances and research efforts in developing new solutions to solve those problems and meet those needs, from the perspectives of component-based software engineering. The tutorial will discuss the state-of-the-art practice, issues, and challenges, new solutions and research efforts in third-party component testing, component-based program validation, and test automation. The targeted audience includes technical managers, software testing engineers, quality assurance people, and development engineers who are working on component-based software projects. The tutorial will be useful for professionals, researchers, and students interested in understanding the general concepts and methods in component testing and component-based software validation. This tutorial assumes that participants have a general understanding of software engineering and software testing methods, and have some working experience in software development and validation.

This paper presents an approach to incorporating collaboration among process actors as a major construct for business process modeling. Furthermore collaboration is realized as a reusable software component. This provides today's workflow management systems with an opportunity to integrate collaboration with their existing process execution to realize full co-operation support for business process management. A collaboration-centric application framework based on a reusable collaboration component and a multi-agent platform is proposed. A description of how it was refined through use in a succession of applications used to trial team-working with various groups of mobile workers is included to show the usefulness and maturity of the approach. Finally some information is given in regards to the productisation of the enterprise mobilization platform of which the collaboration-centric application framework is a component.

Software reusability is believed to be the key to improving software development productivity, while specification plays an important part in software reuse. From a modern object oriented view, the reusable software components can be grouped into three categories. Procedural components, abstract data types and concrete data objects. Both procedural components and abstract data types can be parameterized in many Object-Oriented languages. Specifications for reuse of these components are discussed in detail in this paper. The reusable software components and their specifications will form a reusable software library, and the information extracted from the specifications forms a knowledge base. Based on the knowledge base and the reusable software library, a new software development paradigm with software reusability can be realized.

A prevalent problem in code reuse is the difficult if in locating the code to be reused. Rapid prototyping depends heavily on being able to locate software components to assemble into new applications. The paper presents DYHARD, a specification language that allows a programmer to specify how hypertext links are to be maintained between reusable software components in a library. The language is object-oriented and exploits the class structure to help the user model his data. The hypertext links are used to form multiple logical threads interconnecting the software components to let the programmer to locate and reuse code more easily. >