Software Reuse Research Articles

ROP Defense Using Trie Graph For System Security

Most Intrusion Detection Systems (IDS) / Intrusion Prevention Systems (IPS) cannot defend the attacks from a Return Oriented Program (ROP) which applies code reusing and exploiting techniques without the need for code injection. Malicious attackers chain a short sequence as a gadget and execute this gadget as an arbitrary (Turing-complete) behavior in the target program. Lots of ROP defense tools have been developed with satisfactory performance and low costs overhead, but malicious attackers can evade ROP tools. Therefore, it needs security researchers to continually improve existing ROP defense tools, because the defense ability of target devices, such as smartphones is weak, and such devices are being increasingly targeted. Our contribution in this paper is to propose an ROP defense method that has provided a better performance of defense against ROP attacks than existing ROP defense tools.

Development of Test Automation Framework for Printed Circuit Board Assembly

A Test Automation Framework is a bunch of rules or coding guidelines for test-process handling that is followed during coding. These are simple strategies that produce helpful results such as improved code re-usability, higher portability, diminished script support cost, reduced interdependency, higher interchangeability, and so on. This paper presents the development of a test automation framework for Printed Circuit Board Assembly (PCBA) to test the functionality and fault identification of the electronic circuit in the PCBA. It provides an integrated array of test and measurement Instruments which is automated using SCPI (Standard Command for programming Instrument) based commands to control test and measurement processes, making it simpler to configure and query. These test instruments imitate the environment in which the PCBA is to be deployed, which helps to observe its characteristics to determine whether it meets the expectation for which it was designed. Any possible variations in its characteristics due to fault are observed during testing and those faults are identified automatically using the data-driven fault analysis method.

Reusable Component Retrieval from a Large Repository Using Word2Vec with Continuous Bag of Words

A reusable code component is the one which can be easily used with a little or no adaptation to fit in to the application being developed. The major concern in such process is the maintenance of these reusable components in one place called ‘Repository’, so that those code components can be effectively identified as well as reused. Word embedding allows us to numerically represent our textual information. They have become so pervasive that almost all Natural Language Processing projects make use of them. In this work, we considered to use Word2Vec concept to find vector representation of features of a reusable component. The features of a reusable component in the form of sequence of words are input to Word2Vec network. Our method using Word2Vec with Continuous Bag of Words out performs existing method in the market. The proposed methodology has shown an accuracy of 94.8% in identifying the existing reusable component.

Context-based intelligent recommendation by code reuse for smart decision support and cognitive adaptive systems

PurposeThis paper aims to use the concept of machine learning to enable people and machines to interact more certainly to extend and expand human expertise and cognition.Design/methodology/approachIntelligent code reuse recommendations based on code big data analysis, mining and learning can effectively improve the efficiency and quality of software reuse, including common code units in a specific field and common code units that are not related to the field.FindingsFocusing on the topic of context-based intelligent code reuse recommendation, this paper expounds the research work in two aspects mainly in practical applications of smart decision support and cognitive adaptive systems: code reuse recommendation based on template mining and code reuse recommendation based on deep learning.Originality/valueOn this basis, the future development direction of intelligent code reuse recommendation based on context has prospected.

Unsupervised learning in images and audio to produce neural receptive fields: a primer and accessible notebook

Sensory processing relies on efficient computation driven by a combination of low-level unsupervised, statistical structural learning, and high-level task-dependent learning. In the earliest stages of sensory processing, sparse and independent coding strategies are capable of modeling neural processing using the same coding strategy with only a change in the input (e.g., grayscale images, color images, and audio). We present a consolidated review of Independent Component Analysis (ICA) as an efficient neural coding scheme with the ability to model early visual and auditory neural processing. We created a self-contained, accessible Jupyter notebook using Python to demonstrate the efficient coding principle for different modalities following a consistent five-step strategy. For each modality, derived receptive field models from natural and non-natural inputs are contrasted, demonstrating how neural codes are not produced when the inputs sufficiently deviate from those animals were evolved to process. Additionally, the demonstration shows that ICA produces more neurally-appropriate receptive field models than those based on common compression strategies, such as Principal Component Analysis. The five-step strategy not only produces neural-like models but also promotes reuse of code to emphasize the input-agnostic nature where each modality can be modeled with only a change in inputs. This notebook can be used to readily observe the links between unsupervised machine learning strategies and early sensory neuroscience, improving our understanding of flexible data-driven neural development in nature and future applications.

Construction of Modularized English Teaching Platform for Multimedia Wireless Network Based on NS2 Simulation Software

Using the NS2 network simulation tool to teach the “wireless network” course can enhance students’ understanding of wireless network protocols through visualization and can also improve students’ ability to analyze problems hands on. We built a multimedia wireless network modularized English teaching platform based on NS2 simulation software; made full use of the rich components and network resources provided by NS2 to achieve a high degree of code reuse and reduce the time for developing simulation codes; designed the overall framework of this multimedia wireless network modular English teaching platform based on the B/S structure; and solved the weight coefficient and importance value of the learning input evaluation index, based on the feedback elite teaching optimization algorithm, the improved teaching formula, the increase in the number of exchanges, and the improvement in the learner’s performance. The experimental results show that the LEACH and LEACH-C protocols of the clustered NS2 simulation software have more surviving nodes most of the time, which indicates that the clustering routing protocol has better performance.

Not So Fast: Understanding and Mitigating Negative Impacts of Compiler Optimizations on Code Reuse Gadget Sets

Not So Fast: Understanding and Mitigating Negative Impacts of Compiler Optimizations on Code Reuse Gadget Sets

Not so fast: understanding and mitigating negative impacts of compiler optimizations on code reuse gadget sets

Despite extensive testing and correctness certification of their functional semantics, a number of compiler optimizations have been shown to violate security guarantees implemented in source code. While prior work has shed light on how such optimizations may introduce semantic security weaknesses into programs, there remains a significant knowledge gap concerning the impacts of compiler optimizations on non-semantic properties with security implications. In particular, little is currently known about how code generation and optimization decisions made by the compiler affect the availability and utility of reusable code segments called gadgets required for implementing code reuse attack methods such as return-oriented programming. In this paper, we bridge this gap through a study of the impacts of compiler optimization on code reuse gadget sets. We analyze and compare 1,187 variants of 20 different benchmark programs built with two production compilers (GCC and Clang) to determine how their optimization behaviors affect the code reuse gadget sets present in program variants with respect to both quantitative and qualitative metrics. Our study exposes an important and unexpected problem; compiler optimizations introduce new gadgets at a high rate and produce code containing gadget sets that are generally more useful to an attacker than those in unoptimized code. Using differential binary analysis, we identify several undesirable behaviors at the root of this phenomenon. In turn, we propose and evaluate several strategies to mitigate these behaviors. In particular, we show that post-production binary recompilation can effectively mitigate these behaviors with negligible performance impacts, resulting in optimized code with significantly smaller and less useful gadget sets.

UnDiFi-2D: An unstructured discontinuity fitting code for 2D grids

UnDiFi-2D, an open source (free software) Unstructured-grid, Discontinuity Fitting code, is presented. The aim of UnDiFi-2D is to model gas-dynamic discontinuities in two-dimensional (2D) flows as if they were true discontinuities of null thickness that bound regions of the flow-field where a smooth solution to the governing PDEs exists. UnDiFi-2D therefore needs to be coupled with an unstructured CFD solver that is used to discretize the governing PDEs within the smooth regions of the flow-field. Two different, in-house developed, CFD solvers are also included in the current distribution.The main features of the UnDiFi-2D software can be summarized as follows:Programming languageUnDiFi-2D is written in standard Fortran 77/95; its design is highly modular in order to enhance simplicity of use, maintenance and allow coupling with virtually any existing CFD solver;Usability, maintenance and enhancement In order to improve the usability, maintenance and enhancement of the code also the documentation has been carefully taken into account. The git distributed versioning system has been adopted to facilitate collaborative maintenance and code development;CopyrightsUnDiFi-2D is a free software that anyone can use, copy, distribute, change and improve under the GNU Public License version 3.The present paper is a manifesto of the first public release of the UnDiFi-2D code. It describes the currently implemented features, which are the result of more than a decade of still ongoing CFD developments. This work is focused on the computational techniques adopted and a detailed description of the main characteristics is reported. UnDiFi-2D capabilities are demonstrated by means of examples test cases. The design of the code allows to easily include existing CFD codes and is aimed at ease code reuse and readability. Program summaryProgram title: UnDiFi-2DCPC Library link to program files:https://doi.org/10.17632/5hwssmc2mx.1Licensing provisions: GNU General Public License, version 3Programming language: Fortran; developed and tested with Intel Fortran Compiler v. 18.0.3 and GNU gfortran.External routines: The code depends on several libraries and third-party packages which are detailed in the corpus of the text.Nature of problem: Numerical computation of flows with discontinuities.Solution method: Shock-fitting technique.Additional comments including restrictions and unusual features:•At present, UnDiFi-2D is validated for inviscid steady and unsteady two-dimensional flows without changes in the number of discontinuity lines and interaction points.•UnDiFi-2D implements a shock-fitting algorithm and can be coupled with unstructured cell-vertex solvers, with an Arbitrary Lagrangian-Eulerian (ALE) formulation.•UnDiFi-2D project adopts git [1], a free and open source distributed version control system. A public repository dedicated to UnDiFi-2D project [2] has been created on github [3], a web-based hosting service for software development projects using git versioning system. Finally, a comprehensive documentation is provided in the form of user manual developed in Pandoc [4].

An analysis of open source software licensing questions in Stack Exchange sites

Free and open source software is widely used in the creation of software systems, whereas many organizations choose to provide their systems as open source. Open source software carries licenses that determine the conditions under which the original software can be used. Appropriate use of licenses requires relevant expertise by the practitioners, and has an important legal angle. Educators and employers need to ensure that developers have the necessary training to understand licensing risks and how they can be addressed. At the same time, it is important to understand which issues practitioners face when they are using a specific open source license, when they are developing new open source software products or when they are reusing open source software. In this work, we examine questions posed about open source software licensing using data from the following Stack Exchange sites: Stack Overflow, Software Engineering, Open Source and Law. We analyze the indication of specific licenses and topics in the questions, investigate the attention the posts receive and trends over time, whether appropriate answers are provided and which type of questions are asked. Our results indicate that practitioners need, among other, clarifications about licensing specific software when other licenses are used, and for understanding license content. The results of the study can be useful for educators and employers, organizations that are authoring open source software licenses and developers for understanding the issues faced when using licenses, whereas they are relevant to other software engineering research areas, such as software reusability.

A Review of Software Components Identification Methods and Quality Assessment Criteria

Identification of suitable reusable software components from repositories and other sources is a key process in software reuse.  Many methods for components identifying exist.  However, considering the increased adoption of reuse in software projects and the need to identify appropriate components from the numerous sources based on multiple quality criteria, it becomes imperative to undertake a review of existing methods to determine their strengths and weaknesses as well as gaps in components identification.  In view of the above, this research was designed to undertake a systematic review of components identification methods in software reuse.  Research findings indicate that existing methods and automated tools were inadequate in handling components identification from multiple sources especially where multiple quality criteria are considered.  Also, findings indicate that multi-objective optimization algorithms like non-dominated sorting genetic algorithm III (NSGA-III) are capable of addressing such multidimensional problems; therefore, greater efforts in designing and developing automated tools that are based on this technique are highly recommended.  The need for adequate methods for cataloguing and categorizing components that are stored in repositories and other sources is also identified as capable of enhancing the process of components identification in software reuse.

Graph representations in genetic programming

Graph representations promise several desirable properties for genetic programming (GP); multiple-output programs, natural representations of code reuse and, in many cases, an innate mechanism for neutral drift. Each graph GP technique provides a program representation, genetic operators and overarching evolutionary algorithm. This makes it difficult to identify the individual causes of empirical differences, both between these methods and in comparison to traditional GP. In this work, we empirically study the behaviour of Cartesian genetic programming (CGP), linear genetic programming (LGP), evolving graphs by graph programming and traditional GP. By fixing some aspects of the configurations, we study the performance of each graph GP method and GP in combination with three different EAs: generational, steady-state and (1+lambda ). In general, we find that the best choice of representation, genetic operator and evolutionary algorithm depends on the problem domain. Further, we find that graph GP methods can increase search performance on complex real-world regression problems and, particularly in combination with the (1 + lambda) EA, are significantly better on digital circuit synthesis tasks. We further show that the reuse of intermediate results by tuning LGP’s number of registers and CGP’s levels back parameter is of utmost importance and contributes significantly to better convergence of an optimization algorithm when solving complex problems that benefit from code reuse.

Development of a Genomic Prediction Pipeline for Maintaining Comparable Sample Sizes in Training and Testing Sets across Prediction Schemes Accounting for the Genotype-by-Environment Interaction

The global growing population is experiencing challenges to satisfy the food chain supply in a world that faces rapid changes in environmental conditions complicating the development of stable cultivars. Emergent methodologies aided by molecular marker information such as marker assisted selection (MAS) and genomic selection (GS) have been widely adopted to assist the development of improved genotypes. In general, the implementation of GS is not straightforward, and it usually requires cross-validation studies to find the optimum set of factors (training set sizes, number of markers, quality control, etc.) to use in real breeding applications. In most cases, these different scenarios (combination of several factors) vary just in the levels of a single factor keeping fixed the levels of the other factors allowing the use of previously developed routines (code reuse). In this study, we present a set of structured modules that are easily to assemble for constructing complex genomic prediction pipelines from scratch. Also, we proposed a novel method for selecting training-testing sets of sizes across different cross-validation schemes (CV2, predicting tested genotypes in observed environments; CV1, predicting untested genotypes in observed environments; CV0, predicting tested genotypes in novel environments; and CV00, predicting untested genotypes in novel environments). To show how our implementation works, we considered two real data sets. These correspond to selected samples of the USDA soybean collection (D1: 324 genotypes observed in 6 environments scored for 9 traits) and of the Soybean Nested Association Mapping (SoyNAM) experiment (D2: 324 genotypes observed in 6 environments scored for 6 traits). In addition, three prediction models which consider the effect of environments and lines (M1: E + L), environments, lines and main effect of markers (M2: E + L + G), and also the inclusion of the interaction between makers and environments (M3: E + L + G + G×E) were considered. The results confirm that under CV2 and CV1 schemes, moderate improvements in predictive ability can be obtained with the inclusion of the interaction component, while for CV0 mixed results were observed, and for CV00 no improvements were shown. However, for this last scenario, the inclusion of weather and soil data potentially could enhance the results of the interaction model.

Code-free cloud computing service to facilitate rapid biomedical digital signal processing and algorithm development

Background and Objective: Cloud computing has the ability to offload processing tasks to a remote computing resources. Presently, the majority of biomedical digital signal processing involves a ground-up approach by writing code in a variety of languages. This may reduce the time a researcher or health professional has to process data, while increasing the barrier to entry to those with little or no software development experience. In this study, we aim to provide a service capable of handling and processing biomedical data via a code-free interface. Furthermore, our solution should support multiple file formats and processing languages while saving user inputs for repeated use.Methods: A web interface via the Python-based Django framework was developed with the potential to shorten the time taken to create an algorithm, encourage code reuse, and democratise digital signal processing tasks for non-technical users using a code-free user interface. A user can upload data, create an algorithm and download the result. Using discrete functions and multi-lingual scripts (e.g. MATLAB or Python), the user can manipulate data rapidly in a repeatable manner. Multiple data file formats are supported by a decision-based file handler and user authentication-based storage allocation method.Results: The proposed system has been demonstrated as effective in handling multiple input data types in various programming languages, including Python and MATLAB. This, in turn, has the potential to reduce currently experienced bottlenecks in cross-platform development of bio-signal processing algorithms. The source code for this system has been made available to encourage reuse. A cloud service for digital signal processing has the ability to reduce the apparent complexity and abstract the need to understand the intricacies of signal processing.Conclusion: We have introduced a web-based system capable of reducing the barrier to entry for inexperienced programmers. Furthermore, our system is reproducable and scalable for use in a variety of clinical or research fields.

A Flexible Input Mapping System for Next-Generation Virtual Reality Controllers

This paper proposes an input mapping system that can transform various input signals from next-generation virtual reality devices to suit existing virtual reality content. Existing interactions of virtual reality content are developed based on input values for standardized commercial haptic controllers. This prevents the challenge of new ideas in content. However, controllers that are not compatible with existing virtual reality content have to take significant risks until commercialization. The proposed system allows content developers to map streams of new input devices to standard input events for use in existing content. This allows the reuse of code from existing content, even with new devices, effectively reducing development tasks. Further, it is possible to define a new input method from the perspective of content instead of the sensing results of the input device, allowing for content-specific standardization in content-oriented industries such as games and virtual reality.

FACER: An API usage-based code-example recommender for opportunistic reuse

To save time, developers often search for code examples that implement their desired software features. Existing code search techniques typically focus on finding code snippets for a single given query, which means that developers need to perform a separate search for each desired functionality. In this paper, we propose FACER (F eature-driven A PI usage-based C ode E xamples R ecommender), a technique that avoids repeated searches through opportunistic reuse. Specifically, given the selected code snippet that matches the initial search query, FACER finds and suggests related code snippets that represent features that the developer may want to implement next. FACER first constructs a code fact repository by parsing the source code of open-source Java projects to obtain methods’ textual information, call graphs, and Application Programming Interface (API) usages. It then detects unique features by clustering methods based on similar API usages, where each cluster represents a feature or functionality. Finally, it detects frequently co-occurring features across projects using frequent pattern mining and recommends related methods from the mined patterns. To evaluate FACER, we run it on 120 Java Android apps from GitHub. We first manually validate that the detected method clusters represent methods with similar functionality. We then perform an automated evaluation to determine the best parameters (e.g., similarity threshold) for FACER. We recruit 10 professional developers along with 39 experienced students to judge FACER’s recommendation of related methods. Our results show that, on average, FACER’s recommendations are 80% precise. We also survey a total of 20 professional Android and Java developers to understand their code search and reuse experiences, and also to obtain their feedback on the usability and usefulness of FACER. The survey results show that 95% of our surveyed professional developers find the idea of related method recommendations useful during code reuse.

Automated refactoring of legacy JavaScript code to ES6 modules

The JavaScript language did not specify, until ECMAScript 6 (ES6), native features for streamlining encapsulation and modularity. Developer community filled the gap with a proliferation of design patterns and module formats, with impact on code reusability, portability and complexity of build configurations. This work studies the automated refactoring of legacy ES5 code to ES6 modules with fine-grained reuse of module contents through the named import/export language constructs. The focus is on reducing the coupling of refactored modules through destructuring exported module objects to fine-grained module features and enhancing module dependencies by leveraging the ES6 syntax. We employ static analysis to construct a model of a JavaScript project, the Module Dependence Graph (MDG), that represents modules and their dependencies. On the basis of MDG we specify the refactoring procedure for module migration to ES6. A prototype implementation has been empirically evaluated on 19 open source projects. Results highlight the relevance of the refactoring with a developer intent for fine-grained reuse. The analysis of refactored code shows an increase in the number of reusable elements per project and reduction in the coupling of refactored modules. The soundness of the refactoring is empirically validated through code inspection and execution of projects’ test suites.

Documentation‐based functional constraint generation for library methods

SummaryAlthough software libraries promote code reuse and facilitate software development, they increase the complexity of programme analysis tasks. To effectively analyse programmes built on top of software libraries, it is essential to have specifications for the library methods that can be easily processed by analysis tools. However, the availability of such specifications is seriously limited at the moment. Manually writing the specifications can be prohibitively expensive and error‐prone, while existing automated approaches to inferring the specifications seldom produce results that are strong enough to be used in programme analysis. In this work, we propose the Doc2smt approach to generating strong functional constraints in SMT for library methods based on their documentations. Doc2smt first applies natural language processing (NLP) techniques and a set of rules to translate a method's natural language documentation into a large number of candidate constraint clauses in OCL. Then, it utilizes a manually enhanced domain model to identify OCL candidate constraint clauses that comply with the problem domain in static validation, translates well‐formed OCL constraints into the SMT‐LIB format, and checks whether each SMB‐LIB constraint rightly abstracts the functionalities of the method under consideration via testing in dynamic validation. In the end, it reports the first functional constraint that survives both validations to the user as the result. We have implemented the approach into a supporting tool with the same name. In experiments conducted on 451 methods from the Java Collections Framework and the Java IO library, Doc2smt generated correct constraints for 309 methods, with the average generation time for each correct constraint being merely 2.7 min. We have also applied the generated constraints to facilitate symbolic‐execution‐based test generation with the Symbolic Java PathFinder (SPF) tool. For 24 utility methods manipulating Java container and IO objects, SPF with access to the generated constraints produced 51.2 times more test cases than SPF without the access.

Empirical Evaluation of the Automatic Generation of a Component-Based Software Architecture for Games

Component-based architecture is the software design of choice for most modern games and game engines, allowing for extensible and reusable software that easily adapts to changes in requirements. Nevertheless, designing a component-based architecture is not an easy achievement and some techniques have been previously proposed for the automatic generation of a component distribution to implement a given declarative model of the entities in the game. The goal of the work presented here is to empirically compare the quality of the component distributions designed by programmers, with those others automatically obtained with such techniques.

A ROS-Gazebo Interface for the Katana Robotic Arm Manipulation

Nowadays, simulators are being used more and more during the development of robotic systems due to the efficiency of the development and testing processes of such applications. Undoubtedly, these simulators save time, resources and costs, as well as enable ease of demonstrations of the system. Specifically, tools like the open source Robotic Operating System (ROS) and Gazebo have gained popularity in building models of robotic systems. ROS is extensively used in robotics due to the pros of hardware abstraction and code reuse. The Gazebo platform is used for visualisation because of its high compatibility with ROS. In this paper, ROS and Gazebo have been integrated to build an interface for the visualisation of the Katana Arm manipulator.