Reuse-Conducive Development Environments

Despite its well-recognized benefits, software reuse has not met its expected success due to technical, cognitive, and social difficulties. We have systematically analyzed the reuse problem (especially the cognitive and social difficulties faced by software developers who reuse) from a multidimensional perspective, drawing on our long-term research on information retrieval, human-computer interaction, and knowledge-based systems. Based on this analysis, we propose the concept of reuse-conducive development environments, which encourage and enable software developers to reuse through the smooth integration of reuse repository systems and development environments. We have designed, implemented, and evaluated CodeBroker—a reuse-conducive development environment—that autonomously locates and delivers task-relevant and personalized components into the current software development environment. Empirical evaluations of CodeBroker have shown that the system is effective in promoting reuse by enabling software developers to reuse components unknown to them, reducing the difficulties in locating components, and augmenting the programming capability of software developers.     

Application of fuzzy expert systems in assessing operational risk of software

Risk is the potential for realization of undesirable consequences of an event. Operational risk of software is the likelihood of untoward events occurring during operations due to software failures. NASA IV&V Facility is an independent institution which conducts Independent Assessments for various NASA projects. Its responsibilities, among others, include the assessments of operational risks of software. In this study, we investigate Independent Assessments that are conducted very early in the software development life cycle.Existing risk assessment methods are largely based on checklists and analysis of a risk matrix, in which risk factors are scored according to their influence on the potential operational risk. These scores are then arithmetically aggregated into an overall risk score. However, only incomplete project information is available during the very early phases of the software life cycle, and thus, a quantitative method, such as a risk matrix, must make arbitrary assumptions to assess operational risk.We have developed a fuzzy expert system, called the Research Prototype Early Assessment System, to support Independent Assessments of projects during the very early phases of the software life cycle. Fuzzy logic provides a convenient way to represent linguistic variables, subjective probability, and ordinal categories. To represent risk, subjective probability is a better way than quantitative objective probability of failure. Furthermore, fuzzy severity categories are more credible than numeric scores. We illustrated how fuzzy expert systems can infer useful results by using the limited facts about a current project, and rules about software development. This approach can be extended to add planned IV&V level, history of past NASA projects, and rules from NASA experts.     

Three empirical studies of a software reuse reference model

The contribution of this paper is a reference model for the practice of software reuse. Our research thesis is that software development based upon a software reuse reference model improves quality of products, productivity of processes and product time‐to‐market for many software development enterprises. The definition and investigation of such a model has been carried out using three steps. First, the reference model is developed based on existing software reuse concepts. Second, this reference model is empirically studied using both legacy studies and lessons learned studies. Third, the impact of the reference model on software development productivity, quality, and time‐to‐market is empirically derived. Copyright © 2000 John Wiley & Sons, Ltd.     

Three empirical evaluations of a software reuse reference model

The contribution of this paper is three empirical evaluations of a reference model for the practice of software reuse. Our research thesis is that software development based upon a software reuse reference model improves quality of products, productivity of processes and product time‐to‐market for many software development enterprises. The definition and investigation of such a model has been carried out using three steps. First, the reference model is developed based on existing software reuse concepts. Second, this reference model is empirically evaluated using three studies: one using a survey method, one using a case studies method, and one using a legacy studies method. Third, the impact of the reference model on software development productivity, quality, and time‐to‐market is empirically derived. This revised version was published online in June 2006 with corrections to the Cover Date.     

An empirical study of a software reuse reference model

In software engineering there is a need for technologies that will significantly decrease effort in developing software products, increase quality of software products and decrease time-to-markets. The software development industry can be improved by utilizing and managing software reuse with an “empirically validated reference model” that can be customized for different kinds of software development enterprises. Our research thesis is that software development based on a software reuse reference model improves the competitive edge and time-to-market of many software development enterprises. The definition and study of such a model has been carried out using four steps. First, the reference model developed here is based on the existing software reuse concepts. Second, this reference model is an empirical study which uses both legacy studies and lessons learned studies. Third, the impact of the reference model on software development effort, quality, and time-to-market is empirically derived. Fourth, an initial set of successful cases, which are based on the software reuse reference model utilization, are identified. The main contribution of this paper is a reference model for the practice of software reuse. A secondary contribution is an initial set of cases from software development enterprises which are successful in the practice of reuse in terms of decreased effort, increased quality and a high correlation in their application of our software reuse reference model activities.     

Trends in software reuse research: A tertiary study

ContextThe reuse of software has been a research topic for more than 50 years. Throughout that time, many approaches, tools and proposed techniques have reached maturity. However, it is not yet a widespread practice and some issues need to be further investigated. The latest study on software reuse trends dates back to 2005 and we think that it should be updated.ObjectiveTo identify the current trends in software reuse research.MethodA tertiary study based on systematic secondary studies published up to July 2018.ResultsWe identified 4,423 works related to software reuse, from which 3,102 were filtered by selection criteria and quality assessment to produce a final set of 56 relevant studies. We identified 30 current research topics and 127 proposals for future work, grouped into three broad categories: Software Product Lines, Other reuse approaches and General reuse topics.ConclusionsFrequently reported topics include: Requirements and Testing in the category of Lifecycle phases for Software Product Lines, and Systematic reuse for decision making in the category of General Reuse. The most mentioned future work proposals were Requirements, and Evolution and Variability management for Software Product Lines, and Systematic reuse for decision making. The identified trends, based on future work proposals, demonstrate that software reuse is still an interesting area for research. Researchers can use these trends as a guide to lead their future projects.     

Development of CORBA-based engineering applications from legacy Fortran programs

A majority of scientific and engineering applications in aerodynamics and solid mechanics are written in Fortran. To reduce the high cost of software development, NASA researchers reuse most of the legacy Fortran codes instead of developing them from scratch in the numerical propulsion system simulation project. In this paper, we present an efficient methodology for integrating legacy applications written in Fortran into a distributed object framework. Issues and strategies regarding the conversion and wrapping of Fortran codes into common object request broker architecture objects are discussed. Fortran codes are modified as little as possible when they are decomposed into modules and wrapped as objects. We implement a wrapper generator which takes the Fortran application as input and generates the C++ wrapper files and interface definition language file. Tedious programming tasks for wrapping the codes can therefore be reduced.     

How to evaluate legacy system maintenance

Drawing on extensive data from the NASA Space Shuttle's guidance software, the author proposes a method for evaluating the effectiveness of legacy software maintenance efforts. He provides several formulas for tracking maintenance stability, defined as increasing functionality with decreasing failures over time, and offers data that supports their validity. He also provides tips for applying his formulas to different projects     

Quality,productivity and economic benefits of software reuse: a review of industrial studies

Systematic software reuse is proposed to increase productivity and software quality and lead to economic benefits. Reports of successful software reuse programs in industry have been published. However, there has been little effort to organize the evidence systematically and appraise it. This review aims to assess the effects of software reuse in industrial contexts. Journals and major conferences between 1994 and 2005 were searched to find observational studies and experiments conducted in industry, returning eleven papers of observational type. Systematic software reuse is significantly related to lower problem (defect, fault or error) density in five studies and to decreased effort spent on correcting problems in three studies. The review found evidence for significant gains in apparent productivity in three studies. Other significant benefits of software reuse were reported in single studies or the results were inconsistent. Evidence from industry is sparse and combining results was done by vote-counting. Researchers should pay more attention to using comparable metrics, performing longitudinal studies, and explaining the results and impact on industry. For industry, evaluating reuse of COTS or OSS components, integrating reuse activities in software processes, better data collection and evaluating return on investment are major challenges.

A second look at Faster,Better, Cheaper

“Faster, Better, Cheaper” (FBC) was a systems development methodology used by NASA in the 1990s. While usually a deprecated practice, we find that, with certain caveats, it is a viable approach. To determine this we utilized a stochastic AI tool to determine the behavior of FBC for several case studies. In these case studies we compare results of using FBC with that of other optimization policies. In our tests, FBC is as advantageous a policy to use with projects as other policies, while avoiding their apparent downfalls.     

Multi-agent simulation of complex heterogeneous models in scientific computing

Electronic protoyping is becoming a part of every scientific inquiry and product design, and is the focus of research in the new scientific field of Computational Science and Engineering. The new grand challenge here is the rapid prototyping of manufactured artifacts and the rapid solution to problems with numerous interrelated elements. This, in turn, requires the fast, accurate simulation of physical processes and design optimization using knowledge and computational models from multiple disciplines in science and engineering. In this paper, we formulate a mathematical and software framework for complex rapid prototyping. Its design utilizes the current computer network infrastructures and high performance computation technologies. Its functionality includes adaptability and intelligence with respect to end-users and hardware platforms. We present the architecture of this framework, named SciAgents, using a multi-agent software model encapsulating a collaborating mathematical method. We also briefly discuss some issues related to legacy software reuse that we faced in the implementation. The design of SciAgents allows wholesale reuse of scientific software and provides a natural approach to parallel and distributed problem solving.     

Design verification in model-based?��-controller development using an abstract component

Component-based software development is a promising approach for controlling the complexity and quality of software systems. Nevertheless, recent advances in quality control techniques do not seem to keep up with the growing complexity of embedded software; embedded systems often consist of dozens to hundreds of software/hardware components that exhibit complex interaction behavior. Unanticipated quality defects in a component can be a major source of system failure. To address this issue, this paper suggests a design verification approach integrated into the model-driven, component-based development methodology Marmot. The notion of abstract components—the basic building blocks of Marmot—helps to lift the level of abstraction, facilitates high-level reuse, and reduces verification complexity by localizing verification problems between abstract components before refinement and after refinement. This enables the identification of unanticipated design errors in the early stages of development. This work introduces the Marmot methodology, presents a design verification approach in Marmot, and demonstrates its application on the development of a μ-controller-based abstraction of a car mirror control system. An application on TinyOS shows that the approach helps to reuse models as well as their verification results in the development process.     

Combining service-orientation and software product line engineering: A systematic mapping study

ContextService-Orientation (SO) is a rapidly emerging paradigm for the design and development of adaptive and dynamic software systems. Software Product Line Engineering (SPLE) has also gained attention as a promising and successful software reuse development paradigm over the last decade and proven to provide effective solutions to deal with managing the growing complexity of software systems.ObjectiveThis study aims at characterizing and identifying the existing research on employing and leveraging SO and SPLE.MethodWe conducted a systematic mapping study to identify and analyze related literature. We identified 81 primary studies, dated from 2000–2011 and classified them with respect to research focus, types of research and contribution.ResultThe mapping synthesizes the available evidence about combining the synergy points and integration of SO and SPLE. The analysis shows that the majority of studies focus on service variability modeling and adaptive systems by employing SPLE principles and approaches.In particular, SPLE approaches, especially feature-oriented approaches for variability modeling, have been applied to the design and development of service-oriented systems. While SO is employed in software product line contexts for the realization of product lines to reconcile the flexibility, scalability and dynamism in product derivations thereby creating dynamic software product lines.ConclusionOur study summarizes and characterizes the SO and SPLE topics researchers have investigated over the past decade and identifies promising research directions as due to the synergy generated by integrating methods and techniques from these two areas.     

MoDisco: A model driven reverse engineering framework

ContextMost companies, independently of their size and activity type, are facing the problem of managing, maintaining and/or replacing (part of) their existing software systems. These legacy systems are often large applications playing a critical role in the company’s information system and with a non-negligible impact on its daily operations. Improving their comprehension (e.g., architecture, features, enforced rules, handled data) is a key point when dealing with their evolution/modernization.ObjectiveThe process of obtaining useful higher-level representations of (legacy) systems is called reverse engineering (RE), and remains a complex goal to achieve. So-called Model Driven Reverse Engineering (MDRE) has been proposed to enhance more traditional RE processes. However, generic and extensible MDRE solutions potentially addressing several kinds of scenarios relying on different legacy technologies are still missing or incomplete. This paper proposes to make a step in this direction.MethodMDRE is the application of Model Driven Engineering (MDE) principles and techniques to RE in order to generate relevant model-based views on legacy systems, thus facilitating their understanding and manipulation. In this context, MDRE is practically used in order to (1) discover initial models from the legacy artifacts composing a given system and (2) understand (process) these models to generate relevant views (i.e., derived models) on this system.ResultsCapitalizing on the different MDRE practices and our previous experience (e.g., in real modernization projects), this paper introduces and details the MoDisco open source MDRE framework. It also presents the underlying MDRE global methodology and architecture accompanying this proposed tooling.ConclusionMoDisco is intended to make easier the design and building of model-based solutions dedicated to legacy systems RE. As an empirical evidence of its relevance and usability, we report on its successful application in real industrial projects and on the concrete experience we gained from that.     

A Longitudinal Study of the Impact of Open Source Software Project Characteristics on Positive Outcomes

This article formulates and tests a set of hypotheses about the success of open source software projects with respect to market penetration and human resource attraction. The authors collected data from 1025 open source software projects in a longitudinal study. The cross-sectional results show that the extent of a project’s operating systems, the range of translated languages, programming languages, and project age positively impact OSS projects’ positive outcomes with respect to market penetration and human resource attraction.     

Assessing the cost-effectiveness of software reuse: A model for planned reuse

Information systems development is typically acknowledged as an expensive and lengthy process, often producing code that is of uneven quality and difficult to maintain. Software reuse has been advocated as a means of revolutionizing this process. The claimed benefits from software reuse are reduction in development cost and time, improvement in software quality, increase in programmer productivity, and improvement in maintainability. Software reuse entails undeniable costs of creating, populating, and maintaining a library of reusable components. There is anecdotal evidence to suggest that some organizations benefit from reuse. However, many software developers practicing reuse claim these benefits without formal demonstration thereof. There is little research to suggest when the benefits are expected and to what extent they will be realized. For example, does a larger library of reusable components lead to increased savings? What is the impact of component size on the effectiveness of reuse? This research seeks to address some of these questions. It represents the first step in a series wherein the effects of software reuse on overall development effort and costs are modeled with a view to understanding when it is most effective.     

A JAVA application framework for scientific software development

This paper presents AIBench (SING group, Ourense, Spain), a JAVA desktop application framework mainly focused on scientific software development, with the goal of improving the productivity of research groups. Following the MVC design pattern, the programmer is able to develop applications using only three types of concepts: operations, data‐typesand views. The framework provides the rest of the functionality present in typical scientific applications, including user parameter requests, logging facilities, multithreading execution, experiment repeatability and graphic user interface generation, among others. The proposed framework is implemented following a plugin‐based architecture, which also allows assembling new applications by the reuse of modules from past development projects. Copyright © 2011 John Wiley & Sons, Ltd.     

Software reuse through re-engineering the legacy systems

Software reuse is widely considered to be a way to increase the productivity and improve the quality and reliability of new software systems. Identifying, extracting and re-engineering software components that implement abstractions within existing systems is a promising cost-effective way to create reusable assets and re-engineer legacy systems. This paper summarizes our experiences with using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. In this effort, we have developed an object-oriented architecture for the Janus Combat Simulation Subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the reuse of the software components of the legacy systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.