Software Reuse Research Articles

Facilitating Software Reuse Through Design Characteristics in Object-Oriented Paradigm

Software are used to increases quality as well as productivity that could be associated with lower costs. Implementing software with capability for reuse is difficult without sufficient support. This paper includes tutorial represents four important design characteristics in object-oriented paradigm for facilitating the production of more reusable software. It reviews the concepts of modularity, cohesion, coupling and information hiding and provides a discussion about their effect on software reuse. Object-oriented approach is having wide attention both in research environments and in industry. This tutorial is prepared for newbie developers of reusable software assets and for everyone else interested in the subject.

From simple digital twin to complex digital twin Part I: A novel modeling method for multi-scale and multi-scenario digital twin

In recent years, the digital twin has attracted widespread attention as an important means of digitalization and intelligence. However, the digital twin is becoming more and more complex due to the expansion of need on the simulation of multi-scale and multi-scenario in reality. The instance of digital twin in references mostly concentrates a particular application, while it is still a lack of a method for constructing the complex digital twin in the total elements, the variable scale of working environments, changeable process, not even the coupling effects. In this paper, a novel modeling method for such a complex digital twin is proposed based on the standardized processing on the model division and assembly. Firstly, the complex model of digital twin is divided into several simple models according to the composition, context, component, and code in 4C architecture. Composition and context make the digital twin focus on the effective elements in a specific scale and scenario. Component and code develop the digital twin in standard-based modularization. Secondly, assemble the simple models of digital twins into the complex model through information fusion, multi-scale association and multi-scenarios iterations. Ontology establishes the complete information library of the entities on different digital twins. Knowledge graph bridges the structure relationship between the different scales of digital twins. The scenario iterations realize the behavior interaction and the accuracy calculation results. It provides an implementable method to construct a complex model of digital twin, and the reuse of components and code also enables rapid development of digital twins.

A modeling environment for reinforcement learning in games

Developing Non-Player Characters, i.e., game characters that interact with the game’s environment autonomously with flexibility to experiment different behavior configurations is not a trivial task. Traditionally, this has been done with techniques that limit the complexity of the behavior of Non-Player Characters (NPCs), as in the case of using Navigation Mesh (NavMesh) for navigation behaviors. For this problem, it has been shown that reinforcement learning can be more efficient and flexible than traditional techniques. However, integrating reinforcement learning into current game development tools is laborious, given that a great deal of experimentation and coding is required. For that, we have developed a modeling environment that integrates with a game development tool and allows the direct specification of reward functions and NPC agent components with maximum code reuse and automatic code generation.

On the Use of NDVI to Estimate LAI in Field Crops: Implementing a Conversion Equation Library

The leaf area index (LAI) is a direct indicator of vegetation activity, and its relationship with the normalized difference vegetation index (NDVI) has been investigated in many research studies. Remote sensing makes available NDVI data over large areas, and researchers developed specific equations to derive the LAI from the NDVI, using empirical relationships grounded in field data collection. We conducted a literature search using “NDVI” AND “LAI” AND “crop” as the search string, focusing on the period 2017–2021. We reviewed the available equations to convert the NDVI into the LAI, aiming at (i) exploring the fields of application of an NDVI-based LAI, (ii) characterizing the mathematical relationships between the NDVI and LAI in the available equations, (iii) creating a software library with the retrieved methods, and (iv) releasing a publicly available software as a service, implementing these equations to foster their reuse by third parties. The literature search yielded 92 articles since 2017, where 139 equations were proposed. We analyzed the mathematical form of both the single equations and ensembles of the NDVI to LAI conversion methods, specific for crop, sensor, and biome. The characterization of the functions highlighted two main constraints when developing an NDVI-LAI conversion function: environmental conditions (i.e., water and light resource, land cover, and climate) and the availability of recurring data during the growing season. We found that the trend of an NDVI-LAI function is usually driven by the ecosystem water availability for the crop rather than by the crop type itself, as well as by the data availability; the data should be adequate in terms of the sample size and temporal resolution for reliably representing the phenomenon under investigation. Our study demonstrated that the choice of the NDVI-LAI equation (or ensemble of equations) should be driven by the trade-off between the scale of the investigation and data availability. The implementation of an extensible and reusable software library publicly queryable via API represents a valid mean to assist researchers in choosing the most suitable equations to perform an NDVI-LAI conversion.

Fault-Based Test Case Prioritization of Regression Testing Using Genetic Algorithm

Prioritization of test case technique schedules the test suite in an order which will increase the efficiency and effectiveness of the system. The test case executed in an order which enhances the probability of finding the fault and also it finds the severe fault at the early stage. The prioritization of test case is proved to be useful for the regression testing. While much research is going on code coverage based prioritization technique and requirement based test case prioritization technique is not used by many. In this paper, test case prioritization technique based on fault of regression technique is proposed from the requirement specification, to improve the software quality and to increase the fault detection rate. In this paper, test case prioritization is done based the six main factors (i) requirement based on customer priority (ii) based on changes made in requirement specification (iii) complexity in Implementation of code (iv) re-usability (v) flow of application (vi) impact of the fault.

Summary of the 12th Brazilian Conference on Software and the 1st Latin American School on Software Engineering

The main goal of the Brazilian Conference on Software: Practice and Theory (CBSoft) is to bring together researchers, practitioners, and students aiming at fostering the exchange of experience about the most recent research, tendencies, and theoretical and practical innovations in software. The conference is the top conference in the field of Latin America. In 2021, the conference was organized virtually by Dr. Karine Roggia, Dr. Cristiano Vasconcellos (UDESC), and Dr. Paulo Boulsfield (Univille). This year, we had more than 450 participants registered to attend CBSoft. CBSoft 2021 held four traditional Brazilian symposia: (i) 35th Brazilian Symposium on Software Engineering (SBES); (ii) 25th Brazilian Symposium on Programming Languages (SBLP); (iii) 15th Brazilian Symposium on Software Components, Architectures, and Reuse (SBCARS); (iv) 6th Brazilian Symposium on Systematic Automated Software Testing (SAST).

Malicious Code Classification Method Based on Deep Residual Network and Hybrid Attention Mechanism for Edge Security

Edge computing is a feasible solution for effectively collecting and processing data in industrial Internet of Things (IIoT) systems, and edge security is an important guarantee for edge computing. Fast and accurate classification of malicious code in the whole lift cycle of edge computing is of great significance, which can effectively prevent malicious code from attacking wireless sensor networks and ensure the stable and secure transmission of data in smart devices. Considering that there is a large amount of code reuse in the same malicious code family, making their visual feature similar, many studies use visualization technology to assist malicious code classification. However, traditional malicious code visual classification schemes have the problems such as single image source, weak ability of deep-level feature extraction, and lack of attention to key image details. Therefore, an innovative malicious code visual classification method based on a deep residual network and hybrid attention mechanism for edge security is proposed in this study. Firstly, the malicious code visualization scheme integrates the bytecode file and assembly file of the malware and converts them into a four-channel RGBA image to fully represent malicious code feature information without increasing the computational complexity. Secondly, a hybrid attention mechanism is introduced into the deep residual network to construct an effective classification model, which extracts image texture features of malicious code from two dimensions of the channel and spatial to improve the classification performance. Finally, the experimental results on the BIG2015 and Malimg datasets show that the proposed scheme is feasible and effective and can be widely applied used in various malicious code classification issues, and the classification accuracy rate is relatively higher than the existing better-performing malicious code classification methods.

An examination of middle school student learner characteristics as related to the reuse and remixing of code in two different computer science learning contexts

The goal of this study was to examine how two groups of middle school students’ self-efficacy, interest, goal orientation, and prior experience related to evidence of their building upon existing ideas and code in digital artifacts they created using MIT’s App Inventor, a computational practice that Brennan and Resnick (2012) identified as “reusing and remixing.” Participants included 110 students in a formal computer science education course and 87 students in an after-school computing club. Data sources included a learner profile survey and participants’ digital artifacts. Correlational analysis, followed by logistic regression analysis, uncovered significant relationships between self-efficacy, goal orientation, and evidence of participants’ code-oriented reusing and remixing their digital artifacts.

Building a Culture of Reuse: An Analysis of Reusable Software and Policies for Institutional Libraries

Building a Culture of Reuse: An Analysis of Reusable Software and Policies for Institutional Libraries

Method of designing the system of classes of the subject area model on the basis of the architecture of integrated objects

The article presents a method of designing the system of software classes, which includes the stages of conceptual, logical and physical design of classes with the implementation of a software system in the architecture of integrated objects. The input data for design is the model of the subject area, which is obtained as the result of object-oriented analysis, which is represented by conceptual, mathematical and semantic models. The conceptual model defines the entities and attributes of entities and is considered as the basis for designing the properties of classes. Mathematical model, as a dynamic model of entity behavior, is formally or informally defined by mathematical formulas, algorithms, diagrams or descriptions of the implementation, which is the basis for designing class methods. The semantic model defines the concepts of subject area in relation to the elements of its model and includes identifiers, meaningful names and descriptions used for the design, programming and implementation of system functionality in terms of subject area. The proposed design method is based on the following principles: normalization of classes (reduction of data to atomic values, reduction of class methods arguments and removal of redundant class methods), replacement of inheritance by logical composition and physical integration, decapsulation (separation of physical functional model from logical data model), virtualization of classes (logical model of classes are considered as a set of relational data model and physical functional model of class methods), interrelation of models (end-to-end mapping of conceptual model on logical and physical model, and class implementation). The essence of the method is to perform successive stages of design: normalization of conceptual model, logical design of classes (transformation of mathematical model into normalized functional model, design and analysis of class characteristics), physical design of classes in architecture of integrated objects (creation of classes, mapping of logical classes on physical classes, implementation of classes in programming language). Actually, the developed design method leads to the creation of a model focused on solving problems, when instances of entities are not created entirely and only the properties and methods that are needed to calculate the desired results for given input values are used. An example of application of the method for a certain subject area with demonstration of design results is considered, and also the approach on the basis of query language of formulation of problems in terms of subject area with generation of source code in programming language is shown. The application of the method allows to increase the efficiency of creating software systems due to the non-redundancy of the system of classes and parameters of class methods, reuse of code and selection of the minimum required set of properties and class methods when solving specific problems.

Software Reusability Estimation based on Dynamic Metrics using Soft Computing Techniques

Dynamic metrics capture the run time features of object-oriented languages, i.e., runtime polymorphism, dynamic binding, etc., that are not covered by static metrics. Therefore, in this paper, we derived a new approach to measuring the software reusability of a design pattern based on dynamic metrics. To achieve this, the authors proposed a model based on five parameters, i.e., polymorphism, inheritance, number of children, coupling, and complexity, to measure the reusability factor by using various soft computing techniques, i.e., Fuzzy, Neural Network, and Neuro-Fuzzy. Further, we also compared the proposed model with four existing machine learning algorithms. Lastly, we found that the proposed model using the neuro-fuzzy technique is trained well and predicts well with MAE (Mean absolute error) 0.003 and RMSE (Root mean square error) 0.009 based on dynamic metrics. Hence, it is concluded that dynamic metrics are a better predictor of the reusability factor than static metrics.

Asynchronous object-oriented approach to the automation of the 0.8-meter George Mason University campus telescope in Python

We present a unique implementation of Python coding in an asynchronous object-oriented programming (OOP) framework to fully automate the process of collecting data with the George Mason University (GMU) Observatory's 0.8-meter telescope. The goal of this project is to perform automated follow-up observations for the Transiting Exoplanet Survey Satellite (TESS) mission, while still allowing for human control, monitoring, and adjustments. Prior to our implementation, the facility was computer-controlled by a human observer through a combination of webcams, TheSkyX, ASCOM Dome, MaxIm DL, and a weather station. We have automated slews and dome movements, CCD exposures, saving FITS images and metadata, initial focusing, guiding on the target, using the ambient temperature to adjust the focus as the telescope cools through the rest of the night, taking calibration images (darks and flats), and monitoring local weather data. The automated weather monitor periodically checks various weather data from multiple sources to automate the decision to close the observatory during adverse conditions. We have organized the OOP code structure in such a way that each hardware device or important higher-level process is categorized as its own object class or "module" with associated attributes and methods, with inherited common methods across modules for code reusability. To allow actions to be performed simultaneously across different modules, we implemented a multithreaded approach where each module is given its own CPU thread on which to operate concurrently with all other threads. After the initial few modules (camera, telescope, dome, data I/O) were developed, further development of the code was carried out in tandem with testing on sky on clear nights. The code, in its current state, has been tested and used for observations on 171 nights, with more planned usage and feature additions.

Product Model Derivation from Feature Model and Formal Specification

Product derivation is the process of building a specific product from a software product line. Effective product derivation can improve software reuse productivity. Existing methods can only obtain abstract feature models, lacking detailed specifications of individual features. They are more about deriving code assets or class diagram templates without precise model descriptions for specific products. This article proposes a product derivation approach to obtain a formal specification of a specific product based on the feature model and formal specification. We use the integration ordering and behavior preserving integration techniques to integrate the formal specification for each feature pair. The method is divided into two steps. First, it determines the feature formal specification integration ordering based on the feature model. Then, the behavior-preserving integration will be conducted for pairs, including declaration integration, functional scenario path generation, and function integration based on path matching. Behavior preserving integration guarantees consistent behavior to ensure the quality of the formal specification after integration. Finally, we developed a support tool to conduct a case study. The tool first guides the user to perform feature functional scenario path matching, then performs functional integration based on the matching results and repeats the above steps to generate a product model. The result indicates that our method facilitates the derivation process and improves the quality of the generated models.

ERA5 and ERA-Interim Data Processing for the GlobWat Global Hydrological Model

The reproducibility of computational hydrology is gaining attention among hydrologists. Reproducibility requires open and reusable code and data, allowing users to verify results and process new datasets. The creation of input files for global hydrological models (GHMs) requires complex high-resolution gridded dataset processing, limiting the model’s reproducibility to groups with advanced programming skills. GlobWat is one of these GHMs, which was developed by the Food and Agriculture Organization (FAO) to assess irrigation water use. Although the GlobWat code and sample input data are available, the methods for pre-processing model inputs are not available. Here, we present a set of open-source Python and YAML scripts within the Earth System Model Evaluation Tool (ESMValTool) that provide a formalized technique for developing and processing GlobWat model weather inputs. We demonstrate the use of these scripts with the ERA5 and ERA-Interim datasets from the European Centre for Medium-Range Weather Forecasts (ECMWF). To demonstrate the advantage of using these scripts, we ran the GlobWat model for 30 years for the entire world. The focus of the evaluation was on the Urmia Lake Basin in Iran. The validation of the model against the observed discharge in this basin showed that the combination of ERA5 and the De Bruin reference evaporation method yields the best GlobWat performance. Moreover, the scripts allowed us to examine the causes behind the differences in model outcomes.

Research on the Effects of Software Reuse in Project Development

Software reuse is the process of reusing software resources. In a new application, all stages of the software development process. Given the high cost and difficulty of building high-quality software, the idea of leveraging earlier software investments is intriguing; yet, software reuse has not shown to be as effective as anticipated and is not widely or systematically adopted in business.

SSSL: Secure Search Space Locking of Behavioral IPs

Raising the level of VLSI design abstraction from the Register Transfer Level (RTL) to the behavioral level has multiple advantages: (i) It reduces the turn-around-time, (ii) allows faster verification and (iii) extends the re-usability of the design as High-Level Synthesis (HLS) automatically re-optimizes the synthesized circuit when new process technologies are available by simply selecting a different technology library. Moreover, HLS makes extensive use of synthesis directives that control how to synthesize mainly loops (unroll or pipeline), arrays (register or RAM) and functions (inline or not). This further increases the re-usability of the behavioral code as it enables the generation of micro-architectures with different area vs. performance trade-offs. These advantages open the door to third party IP (3PIP) vendors providing Behavioral IPs (BIPs). Unfortunately, the market of third party BIPs is still very small and mostly limited to the HLS vendors themselves. Being so flexible is also their main weakness as it makes them only economically viable if the BIP provider can charge a large premium as it is highly unlikely that the BIP consumer will require their service again. Traditional IP vendors discriminate the price of the IP based on the amount of flexibility of the IP, e.g., RTL description vs. providing a synthesized gate netlist. We envision a similar price discrimination strategy for BIPs by limiting the re-usability of the BIP by partially encrypting the BIP source code. The main idea is to limit the search space, and hence, the re-usability of the BIP such that it only allows the BIP consumer to generate micro-architectures within a pre-defined search space range. This is accomplished by selectively fixing some of the synthesis directives in the form of pragmas at the source code while leaving others explorable. By encrypting the portion of the BIP that contains the fix pragmas we can guarantee that no designs outside of the pre-defined search space are generated. We believe that this work could serve as catalyst to grow the BIP market.

Family-Based and Product-Based Development of Correct-by-Construction Software Product Lines

Software product lines provide systematic software reuse to implement whole product families efficiently. Therefore, they are increasingly used to handle the growing demand of custom-tailored software variants including safety-critical systems as a domain of application. The requirements for safety-critical systems are generally higher and often demand for behavioral correctness to reduce the risk of dangerous situations in-field. However, the high variability of software product lines is still a big challenge for formal methods in general. We argue that the stepwise development approach correctness-by-construction is beneficial compared to post-hoc verification approaches in dealing with the growing variability. Correctness-by-construction uses a set of refinement rules to incrementally create a correct program from a formal specification. In previous work, we already introduced variational correctness-by-construction to develop correct-by-construction software product lines in a product-based way. In this article, we extend our approach in three directions. First, we propose a feature-based specification technique matching the fine-grained specifications of correctness-by-construction. Second, we propose a family-based development approach to show the correctness of the product line as an alternative to the previous product-based approach. Third, we present our usability-improved tool VarCorC implementing our approach. In the evaluation, we compare the product-based development approach to the family-based approach using two case studies implemented with VarCorC.

A Review of Incremental Reuse Method in Software Reuse Process

Abstract: In the late 1960s, the concept of software reuse was proposed. The legacy of software engineering process shows that the scope and field of software reuse was not particularly new. However, it is considered that software reuse is in its primary stages and has yet to reach its full capacity. The utilization of software components from entire stages of the software engineering process in new applications is called as software reuse. Given the economically costly and difficulty of building qualitative software, repurposing prior software investments is enticing. We propose that software reuse should be considered as part of a fully systematic approach that considers a wide range of technological, economical, managerial, organisational, and legal considerations, and we wrap up with a synopsis of the important research issues in all these verticals. This paper summarises our progress in software reuse research. Keywords: Software Reuse, Incremental Reuse Method (IRM), Reuse Process, Artifact, Software Component

On the impact of security vulnerabilities in the npm and RubyGems dependency networks

The increasing interest in open source software has led to the emergence of large language-specific package distributions of reusable software libraries, such as npm and RubyGems. These software packages can be subject to vulnerabilities that may expose dependent packages through explicitly declared dependencies. Using Snyk’s vulnerability database, this article empirically studies vulnerabilities affecting npm and RubyGems packages. We analyse how and when these vulnerabilities are disclosed and fixed, and how their prevalence changes over time. We also analyse how vulnerable packages expose their direct and indirect dependents to vulnerabilities. We distinguish between two types of dependents: packages distributed via the package manager, and external GitHub projects depending on npm packages. We observe that the number of vulnerabilities in npm is increasing and being disclosed faster than vulnerabilities in RubyGems. For both package distributions, the time required to disclose vulnerabilities is increasing over time. Vulnerabilities in npm packages affect a median of 30 package releases, while this is 59 releases in RubyGems packages. A large proportion of external GitHub projects is exposed to vulnerabilities coming from direct or indirect dependencies. 33% and 40% of dependency vulnerabilities to which projects and packages are exposed, respectively, have their fixes in more recent releases within the same major release range of the used dependency. Our findings reveal that more effort is needed to better secure open source package distributions.

Präzi: from package-based to call-based dependency networks

Modern programming languages such as Java, JavaScript, and Rust encourage software reuse by hosting diverse and fast-growing repositories of highly interdependent packages (i.e., reusable libraries) for their users. The standard way to study the interdependence between software packages is to infer a package dependency network by parsing manifest data. Such networks help answer questions such as “How many packages have dependencies to packages with known security issues?” or “What are the most used packages?”. However, an overlooked aspect in existing studies is that manifest-inferred relationships do not necessarily examine the actual usage of these dependencies in source code. To better model dependencies between packages, we developed Präzi, an approach combining manifests and call graphs of packages. Präzi constructs a dependency network at the more fine-grained function-level, instead of at the manifest level. This paper discusses a prototypical Präzi implementation for the popular system programming language Rust. We use Präzi to characterize Rust’s package repository, Crates.io, at the function level and perform a comparative study with metadata-based networks. Our results show that metadata-based networks generalize how packages use their dependencies. Using Präzi, we find packages call only 40% of their resolved dependencies, and that manual analysis of 34 cases reveals that not all packages use a dependency the same way. We argue that researchers and practitioners interested in understanding how developers or programs use dependencies should account for its context—not the sum of all resolved dependencies.