Narrow Results

Banking legacy systems intensively exchange messages in electronic format. Such systems are, for their nature, difficult to update and maintain. As a consequence, the introduction of new types of messages is a hard task. Adding new functionalities requires custom coding and software reuse is seen as a key to obtain a better time-to-market factor, risk and cost reduction. In this paper we describe the architecture and part of the implementation of the SI.RE. Visual System, an Interbanking Network Information System that lets us generate gateways for the exchange of electronic messages among banking legacy systems and supports software reuse. In particular, the SI.RE visual system contains a Visual Programming Environment that allows us to obtain a rapid development of the message handling functions. This environment implements a Visual Programming Language UVG that allows a programmer to reuse COBOL routines.

Software reuse is an important topic due to its potential benefits in increasing product quality and decreasing cost. Although more and more people are aware that not only technical issues, but also nontechnical issues are important to the success of software reuse, people are still not certain which factors will have direct effect on the success of reuse. In this paper, we applied a causal discovery algorithm to the software reuse survey data [2]. Ensemble strategy is incorporated to locate a probable causal model structure for software reuse, and find all those factors which have direct effect on the success of reuse. Our discovery results reinforced some conclusions of Morisio et al. and found some new conclusions which might significantly improve the odds of a reuse project succeeding.

This study aimed to design a software reuse system by case-based reasoning (CBR) in order to reuse object models in system analysis. We developed a system including the methods and procedures for reusing object models, and also proposed how to express the cases of object models by CBR. Moreover, this expressed the rules for retrieving, reusing and modifying object models in accordance with the new problems. Furthermore, this study confirmed its adequacy through applying the system for reusing object models to the real-world business cases; and verified the assumed hypotheses that are related to this system.

To have an effective and efficient mechanism to store, manage and utilize software sources is essential to the automation of software engineering. The paper presents an innovative approach in managing software resources using software warehouse where software assets are systematically accumulated, deposited, retrieved, packaged, managed and utilized, driven by data-mining and OLAP technologies. The results lead to streamlined high efficient software development process and enhance the productivity in response to modern challenges of the design and development of software applications.

XML Schema matching problem can be formulated as follows: given two XML Schemas, find the best mapping between the elements and attributes of the schemas, and the overall similarity between them. XML Schema matching is an important problem in data integration, schema evolution, and software reuse. This paper describes a matching system that can find accurate matches and scales to large XML Schemas with hundreds of nodes. In our system, XML Schemas are modeled as labeled and unordered trees, and the schema matching problem is turned into a tree matching problem. We proposed Approximate Common Structures in trees, and developed a tree matching algorithm based on this concept. Compared with the traditional tree edit-distance algorithm and other schema matching systems, our algorithm is faster and more suitable for large XML Schema matching.

During the past decade a number of methods and techniques for software product line scoping have been developed. Although their basic goal is the same, when it comes to details it is often hard to see what they have in common, where they differ and what their strengths and weaknesses are. This makes it difficult for the user to decide when and how to use them because these methods and techniques sometimes describe the same concepts and activities with different terminologies and, more often than not, by that the activities and tasks defined in them do not exactly match with each other and their inputs/outcomes are not clearly defined. In this paper, we compare and analyze the mainstream approaches to software product line scoping, deduce their essential components and develop them into a unified approach that can be easily referred to and utilized by the user companies planning to launch product lines.

Open Source Software (OSS) has become an important environment where developers can create, exchange, and improve reusable software assets by collaborating with other developers. Although developers may find useful software assets to reuse from OSS for their projects, they usually experience difficulties in solving problems that occur while integrating the assets to their own software. We investigated data from major open source environments such as Sourceforge.net and GitHub, and learned that there is a common pattern of solving reuse-related problems in OSS. To analyze the pattern in detail, we have developed an ontological model to formally represent the symptoms and causes of the reuse-related problems, and the correlations between them. Based on this model, we collected data from Sourceforge.net, and built a knowledge base for the most common problem type. We extracted the core types of symptoms and causes for the problem type and calculated the number of correlations between the types of symptoms and causes. We found that there exist correlations between the symptoms and causes that are extracted from the discussion threads for the problem type, and about 60% of them are statistically significant. We also conducted a study to understand the effective timing of recommending solutions to the developers by analyzing the recall rates of finding the causes of the problems in a timeline. We figured that most of the important causes of a problem are discussed at the beginning of the forum discussion. This leads us to the conclusion that recommending the causes of a problem early by using our knowledge framework may help developers spend less amount of time to solve the problem (around 50% less time than solving the problem without using our framework).

Code reuse has become very popular among software developers in recent times since it saves time and resources. One of the significant difficulties to software reuse is the time pertaining to assess the fitness of the reusable code components. Over the recent years, code search engines have made momentous advancement in establishing the semantic suitability of software components for new usage scenarios. But the issue of evaluating software components based on their nonfunctional suitability has been overlooked to a large extent. The maintenance and reusability of software systems are highly influenced by the structural properties of system classes like complexity, size, coupling, cohesion, etc. The quality of object-oriented code or design artifacts is commonly measured by analyzing the structure of these artifacts in terms of the interdependencies of classes and components as well as their internal elements. In this paper, we perform an empirical analysis on Python packages for the two measures namely coupling and cohesion. The coupling score of a module is computed as module imports and the cohesion score of a module is evaluated as call dependency between classes and global functions of the module. Finally, the proposed work evaluates a package in terms of reusability score which is a cumulative score of the coupling scores and cohesion scores of all the modules within the package. The study has evaluated 15 different packages and five different releases of one single package for reusability. We have empirically tested that the Halstead’s effort metric is inversely proportional to the reusability score. The reusability score was validated using four code detuners. The proposed work was compared with the existing metrics namely cyclomatic complexity and maintainability Index showing satisfactory results.

This paper introduces a mechanism to recover traceability links between the requirements and logical models in the context of critical systems development. Currently, lifecycle processes are covered by a good number of tools that are used to generate different types of artifacts. One of the cornerstone capabilities in the development of critical systems lies in the possibility of automatically recovery traceability links between system artifacts generated in different lifecycle stages. To do so, it is necessary to establish to what extent two or more of these work products are similar, dependent or should be explicitly linked together. However, the different types of artifacts and their internal representation depict a major challenge to unify how system artifacts are represented and, then, linked together. That is why, in this work, a concept-based representation is introduced to provide a semantic and unified description of any system artifact. Furthermore, a traceability function is defined and implemented to exploit this new semantic representation and to support the recovery of traceability links between different types of system artifacts. In order to evaluate the traceability function, a case study in the railway domain is conducted to compare the precision and recall of recovery traceability links between text-based requirements and logical model elements. As the main outcome of this work, the use of a concept-based paradigm to represent that system artifacts are demonstrated as a building block to automatically recover traceability links within the development lifecycle of critical systems.

Drones can perform air operations that are hard to be executed using manned aircrafts. The usage of drones in different domains brings significant environmental benefits and economic savings while decreasing risks to human life. Recently, a number of approaches have been introduced to support the development of drone software systems. However, developing customized drone software based on end-user needs is still a time consuming process. Such delay in software production does not match end-users expectations. Therefore, in the COMP4DRONES project (C4D, for short), we propose an agile-development process that is based on reuse to shorten the drone software development. In this process, based on the user requirements, a number of reusable components are selected from a repository that matches the user requirements. These components are then integrated to have a fully functioning drone system. This repository will be filled with reusable components that are being developed during the C4D project (i.e. the key enabling technologies for drones).

Often most software development doesn’t start from scratch but applies previously developed artifacts. These reusable artifacts are involved in various phases of the software life cycle, ranging from requirements to maintenance. Software design as the high level of software development process has an important impact on the following stages, so its reuse is gaining more and more attention. Unified modeling language (UML) class diagram as a modeling tool has become a de facto standard of software design, and thus its reuse also becomes a concern accordingly. So far, the related research on the reuse of UML class diagrams has focused on matching and retrieval. As a large number of class diagrams enter the repository for reuse, classification has become an essential task. The classification is divided into unsupervised classification (also known as clustering) and supervised classification. In our previous work, we discussed the clustering of UML class diagrams. In this paper, we focus on only the supervised classification of UML class diagrams and propose a supervised classification method. A novel ensemble classifier F-KNB combining both dependent and independent construction ideas is built. The similarity of class diagrams is described, in which the semantic, structural and hybrid matching is defined, respectively. The extracted feature elements are used in base classifiers F-KNN and F-NBs that are constructed based on improved K-nearest neighbors (KNNs) and Naive Bayes (NB), respectively. A series of experimental results show that the proposed ensemble classifier F-KNB shows a good classification quality and efficiency under the condition of variable size and distribution of training samples.

We present a model of the data structure domain that is expressed in terms of the GenVoca domain modeling concepts [7]. We show how familiar data structures can be encapsulated as realms of plug-compatible, symmetric, and reusable components, and we show how complex data structures can be formed from their composition. The target application of our research is a precompiler for specifying and generating customized data structures.

This paper describes an approach to software reuse that involves generating and retrieving abstractions from existing software systems using concept formation methods. The potential of the approach is illustrated through two important activities of the reuse process. First, the concept hierarchy generated by the concept formation methods is used for organizing and retrieving the artifacts inside a repository. Second, the generated concepts are used in identifying new abstractions that may be converted into new, more generic artifacts with better reuse potential. These experiments are part of a major software engineering research project involving many business and academic partners.

Automatic programming is discussed in the context of software engineering. An approach to automatic programming is presented, which utilizes software engineering principles in the synthesis and maintenance of programs. As a simple demonstration, program-equivalent Turing machines are synthesized, encapsulated, reused, and maintained by genetic programming.

Turing machines are synthesized from input-output pairs for a variety of simple problems. When a problem is solved, the solution is encapsulated and becomes part of a software library. The genetic program uses the library to solve new problems by combining library components with program primitives to synthesize new programs. When a new problem is solved or a known problem is solved more efficiently, the genetic program maintains the library so as to keep it valid and efficient.

In this paper, we present a framework for maintainable software design, based on a multilevel understanding of software function. This framework is the novel functional representation ZD, in which domain concepts (e.g., employee records) as well as computational concepts (e.g., stacks and queues) are represented in a reusable manner. We use ZD to support the construction of a library of reusable components for novel configurations. In order to achieve this, we provide mechanisms for supporting flexible configurations, address problems of determining the correctness of a combination of library components, and consider the computational complexity of finding combinations. These problems all stem from problems of interactions between components. Therefore, the structure of ZD is focused on representing and handling these interactions. We show how the approach based on ZD resolves certain well-known problems faced by other library-based component reuse architectures.

Integrating application domain knowledge into reverse engineering is an important step to overcome the shortcomings of conventional reverse engineering approaches that are based exclusively on information derivable from source code. In this paper, we show the basic concepts of a program transformation process from a conventional to an object-oriented architecture which incorporates extraneous higher-level knowledge in its process. To which degree this knowledge might stem from some general domain knowledge, and to which extent it needs to be introduced as application dependent knowledge by a human expert is discussed. The paper discusses these issues in the context of the architectural transformation of legacy systems to an object-oriented architecture.

We describe a knowledge-based framework for software reuse based on parameterizing and instantiating a generic architecture. The reuse process consists of two phases: (1) an acquisition phase, which creates knowledge components representing problem classes, generic architectures, and the design process, followed by: (2) a synthesis phase, which reuses the knowledge components in instantiating a generic architecture for new applications. We illustrate the process using two case studies in two different domains. The distinguishing features of our approach include the use of both formal and informal representations and the use of knowledge to assist software designers in designing new systems. We present empirical evidence, based on the case studies to argue that the approach improves productivity and reliability.

Software reuse may only be put into practice if we make available matching mechanisms between user needs and reusable components. The matching mechanisms should also be powerful enough to allow transformations of the user components that, while maintaining correctness, increase the possibilities of use of repository components by the user. In this paper we propose to use the mathematical framework of category theory to develop matching mechanisms for single-sort algebraic specifications that would allow the automatic retrieval and data adaptation of correct programs. We identify two types of specification matching, isomorphic and composite.

The Summary-based Object-Oriented Reuse Library System (SOORLS) was developed to support both librarians who manage databases of object-oriented reusable components, and software developers who intend to use these components to develop software on the Web. This paper presents the library management functions implemented by SOORLS, with focus on a software reuse approach based on the summary contents of the library. The cluster-based classification scheme proposed in this paper alleviates the labor-intensity domain analysis problem often attributed to traditional facet-based classification schemes. We then concentrate on the facilities offered by SOORLS' tools, as well as its Web-based architecture, which allows distributed access to reusable components on servers from a variety of platforms.

Biggerstaff and Richter suggest that there are four fundamental subtasks associated with operationalizing the reuse process [1]. They are finding reusable components, understanding these components, modifying these components, and composing components. Each of these sub-problems can be re-expressed as a knowledge acquisition sub-problem relative to producing a new representation for the components that make them more suitable for future reuse.

In this paper, we express the first two subtasks for the software reuse activity, as described by Biggerstaff and Richter, as a problem in Machine Learning. From this perspective, the goal of software reuse is to learn to recognize reusable software in terms of code structure, run-time behavior, and functional specification. The Partial Metrics (PM) System supports the acquisition of reusable software at three different levels of granularity: the system level, the procedural level, and the code segment level. Here, we describe how the system extracts procedural knowledge from an example Pascal software system that satisfies a set of structural, behavioral, and functional constraints. These constraints are extracted from a set of positive and negative examples using inductive learning techniques. The constraints are expressed quantitatively in terms of various quality models and metrics. The general characteristics of learned constraints that were extracted from a variety of applications libraries are discussed.