Facilitate Software Development Research Articles

ChainAgile: A framework for the improvement of Scrum Agile distributed software development based on blockchain.

Software Development based on Scrum Agile in a distributed development environment plays a pivotal role in the contemporary software industry by facilitating software development across geographic boundaries. However, in the past different frameworks utilized to address the challenges like communication and collaboration in scrum agile distributed software development (SADSD) were notably inadequate in transparency, security, traceability, geographically dispersed location work agreements, geographically dispersed teamwork effectiveness, and trust. These deficiencies frequently resulted in delays in software development and deployment, customer dissatisfaction, canceled agreements, project failures, and disputes over payments between customers and development teams. To address these challenges of SADSD, this paper proposes a new framework called ChainAgile, which leverages blockchain technology. ChainAgile employs a private Ethereum blockchain to facilitate the execution of smart contracts. These smart contracts cover a range of functions, including acceptance testing, secure payments, requirement verification, task prioritization, sprint backlog, user story design and development and payments with the automated distribution of payments via digital wallets to development teams. Moreover, in the ChainAgile framework, smart contracts also play a pivotal role in automatically imposing penalties on customers for making late payments or for no payments and penalties on developers for completing the tasks that exceed their deadlines. Furthermore, ChainAgile effectively addresses the scalability limitations intrinsic in blockchain technology by incorporating the Interplanetary File System (IPFS) is used for storage solutions as an off-chain mechanism. The experimental results conclusively show that this innovative approach substantially improves transparency, traceability, coordination, communication, security, and trust for both customers and developers engaged in scrum agile distributed software development (SADSD).

End-to-End Security for Distributed Event-driven Enclave Applications on Heterogeneous TEEs

This article presents an approach to provide strong assurance of the secure execution of distributed event-driven applications on shared infrastructures, while relying on a small Trusted Computing Base. We build upon and extend security primitives provided by Trusted Execution Environments (TEEs) to guarantee authenticity and integrity properties of applications, and to secure control of input and output devices. More specifically, we guarantee that if an output is produced by the application, it was allowed to be produced by the application’s source code based on an authentic trace of inputs. We present an integrated open-source framework to develop, deploy, and use such applications across heterogeneous TEEs. Beyond authenticity and integrity, our framework optionally provides confidentiality and a notion of availability, and facilitates software development at a high level of abstraction over the platform-specific TEE layer. We support event-driven programming to develop distributed enclave applications in Rust and C for heterogeneous TEE, including Intel SGX, ARM TrustZone, and Sancus. In this article we discuss the workings of our approach, the extensions we made to the Sancus processor, and the integration of our development model with commercial TEEs. Our evaluation of security and performance aspects show that TEEs, together with our programming model, form a basis for powerful security architectures for dependable systems in domains such as Industrial Control Systems and the Internet of Things, illustrating our framework’s unique suitability for a broad range of use cases which combine cloud processing, mobile and edge devices, and lightweight sensing and actuation.

Mzapy: An Open-Source Python Library Enabling Efficient Extraction and Processing of Ion Mobility Spectrometry-Mass Spectrometry Data in the MZA File Format.

Analysis of ion mobility spectrometry (IMS) data has been challenging and limited the full utility of these measurements. Unlike liquid chromatography-mass spectrometry, where a plethora of tools with well-established algorithms exist, the incorporation of the additional IMS dimension requires upgrading existing computational pipelines and developing new algorithms to fully exploit the advantages of the technology. We have recently reported MZA, a new and simple mass spectrometry data structure based on the broadly supported HDF5 format and created to facilitate software development. While this format is inherently supportive of application development, the availability of core libraries in popular programming languages with standard mass spectrometry utilities will facilitate fast software development and broader adoption of the format. To this end, we present a Python package, mzapy, for efficient extraction and processing of mass spectrometry data in the MZA format, especially for complex data containing ion mobility spectrometry dimension. In addition to raw data extraction, mzapy contains supporting utilities enabling tasks including calibration, signal processing, peak finding, and generating plots. Being implemented in pure Python and having minimal and largely standardized dependencies makes mzapy uniquely suited to application development in the multiomics domain. The mzapy package is free and open-source, includes comprehensive documentation, and is structured to support future extension to meet the evolving needs of the MS community. The software source code is freely available at https://github.com/PNNL-m-q/mzapy.

Automated Data Transfer From ADAS to Android-Based IVI Domain Over SOME/IP

Automotive systems are complex and comprise of numerous components, which are developed simultaneously by different companies, rely on different technologies, and have different requirements in terms of safety and user experience. This leads to the multiple implementations of the similar functionalities within different domains of the vehicle, and the redundancy of hardware resources. Having separate domains communicating with each other would certainly lower the cost of the vehicle hardware and facilitate software development. Nevertheless, establishing inter-domain connectivity is not a trivial solution, and requires determining the suitable communication protocol, as well as the consideration of the use-case variety, specialized domain knowledge of automotive developers, platforms and software standards heterogeneity, safety and security issues, etc. This article presents a verified automated solution for data exchange between Advanced Driver Assistance System (ADAS) and In-Vehicle Infotainment (IVI) domains over SOME/IP. The backbone of the generated solution uses the most common interface definition languages for specific domains - ARXML, FIDL and AIDL, and enables the translation between those languages, as well as the generation of the required cross-domain services and clients, while supporting various architectural aspects and different software platforms.

GA-SCS: Graph-Augmented Source Code Summarization

Automatic source code summarization system aims to generate a valuable natural language description for a program, which can facilitate software development and maintenance, code categorization, and retrieval. However, previous sequence-based research did not consider the long-distance dependence and highly structured characteristics of source code simultaneously. In this article, we present a Transformer-based Graph-Augmented Source Code Summarization (GA-SCS), which can effectively incorporate inherent structural and textual features of source code to generate an effective code description. Specifically, we develop a graph-based structure feature extraction scheme leveraging abstract syntax tree and graph attention networks to mine global syntactic information. And then, to take full advantage of the lexical and syntactic information of code snippets, we extend the original attention to a syntax-informed self-attention mechanism in our encoder. In the training process, we also adopt a reinforcement learning strategy to enhance the readability and informativity of generated code summaries. We utilize the Java dataset and Python dataset to evaluate the performance of different models. Experimental results demonstrate that our GA-SCS model outperforms all competitive methods on BLEU, METEOR, ROUGE, and human evaluations.

MZA: A Data Conversion Tool to Facilitate Software Development and Artificial Intelligence Research in Multidimensional Mass Spectrometry.

Modern mass spectrometry-based workflows employing hybrid instrumentation and orthogonal separations collect multidimensional data, potentially allowing deeper understanding in omics studies through adoption of artificial intelligence methods. However, the large volume of these rich spectra challenges existing data storage and access technologies, therefore precluding informatics advancements. We present MZA (pronounced m-za), the mass-to-charge (m/z) generic data storage and access tool designed to facilitate software development and artificial intelligence research in multidimensional mass spectrometry measurements. Composed of a data conversion tool and a simple file structure based on the HDF5 format, MZA provides easy, cross-platform and cross-programming language access to raw MS-data, enabling fast development of new tools in data science programming languages such as Python and R. The software executable, example MS-data and example Python and R scripts are freely available at https://github.com/PNNL-m-q/mza.

What can move non-IS developers towards open and collaborative development initiatives?

Information systems (IS) have been developed to meet the increasingly complex demands of organisations and society, with a growing understanding of the need for multidisciplinary competencies. It is critical that IS development specialists work with users to conceive and build IS, especially in open and collaborative innovation initiatives. Making these initiatives accessible to non-IS developers can be an opportunity to provide solutions best suited to meet the needs of an application context and more appropriate to the expectations of their target audience. However, non-IS developers are generally unwilling to participate in initiatives for IS development, even open and collaborative ones, due to their lack of technological skills. Our research objective is to identify factors that can influence them to participate, having the Theory of Planned Behaviour as our theoretical basis. We conducted a qualitative interview-based and interpretative study of five open and collaborative development initiatives in Brazilian universities. Results show that the main (beliefs and cognitive) factors influencing non-IS developers to engage are: being able to create useful solutions to the community; professional growth; receiving help from mentors; achieving goals; receiving support from colleagues; availability of tools to facilitate software development; and experiencing new IS development opportunities. These results support organisations to establish guidelines to engage non-IS developers in open and collaborative development initiatives, improving multidisciplinarity and open innovation.

Remote Laboratory Offered as Hardware-as-a-Service Infrastructure

This paper presents a solution for remote classes where hardware is offered as a service. The infrastructure was based on Raspberry Pi mini computers to which a set of different developments boards were connected. The proposed software architecture allows students to connect to remote resources and interact with them. Moreover, the services monitoring status of remote resources were introduced to facilitate software development and the learning process. Furthermore, live video feedback is available to visually monitor operation of the resources. Finally, a debugging server was deployed allowing us to establish a remote debugging session between a user’s PC and the dev board on the server premises. The solution offers a comprehensive remote service including user management. Safety risks of the Internet-exposed infrastructure and safety precautions were discussed. The presented RemoteLab system allows students of WUST to gain knowledge, practise and realize exercises in scope of academic courses such as robot controllers and advanced robot control. Thanks to advances in remote education and utilized tools, the RemoteLab was designed and deployed, allowing stationary classes to be substituted with remote ones, while maintaining a high level of class knowledge transfer. Up to the present, the system has been utilized by over 100 students who could realize exercises and prepare for classes thanks to 24 h system availability.

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.

Code Clone Detection with Hierarchical Attentive Graph Embedding

Code clone serves as a typical programming manner that reuses the existing code to solve similar programming problems, which greatly facilitates software development but recurs program bugs and maintenance costs. Recently, deep learning-based detection approaches gradually present their effectiveness on feature representation and detection performance. Among them, deep learning approaches based on abstract syntax tree (AST) construct models relying on the node embedding technique. In AST, the semantic of nodes is obviously hierarchical, and the importance of nodes is quite different to determine whether the two code fragments are cloned or not. However, some approaches do not fully consider the hierarchical structure information of source code. Some approaches ignore the different importance of nodes when generating the features of source code. Thirdly, when the tree is very large and deep, many approaches are vulnerable to the gradient vanishing problem during training. In order to properly address these challenges, we propose a hierarchical attentive graph neural network embedding model-HAG for the code clone detection. Firstly, the attention mechanism is applied on nodes in AST to distinguish the importance of different nodes during the model training. In addition, the HAG adopts graph convolutional network (GCN) to propagate the code message on AST graph and then exploits a hierarchical differential pooling GCN to sufficiently capture the code semantics at different structure level. To evaluate the effectiveness of HAG, we conducted extensive experiments on public clone dataset and compared it with seven state-of-the-art clone detection models. The experimental results demonstrate that the HAG achieves superior detection performance compared with baseline models. Especially, in the detection of moderately Type-3 or Type-4 clones, the HAG particularly outperforms baselines, indicating the strong detection capability of HAG for semantic clones. Apart from that, the impacts of the hierarchical pooling, attention mechanism and critical model parameters are systematically discussed.

Lost in zero space – An empirical comparison of 0.y.z releases in software package distributions

Distributions of open source software packages dedicated to specific programming languages facilitate software development by allowing software projects to depend on the functionality provided by such reusable packages. The health of a software project can be affected by the maturity of the packages on which it depends. The version numbers of the used package releases provide an indication of their maturity. Packages with a 0.y.z version number are commonly assumed to be under initial development, suggesting that they are likely to be less stable, and depending on them may be considered as less healthy. In this paper, we empirically study, for four open source package distributions (Cargo, npm, Packagist and RubyGems) to which extent 0.y.z package releases and >=1.0.0 package releases behave differently. We quantify the prevalence of 0.y.z releases, we explore how long packages remain in the initial development stage, we compare the update frequency of 0.y.z and >=1.0.0 package releases, we study how often 0.y.z releases are required by other packages, we assess whether semantic versioning is respected for dependencies towards them, and we compare some characteristics of 0.y.z and >=1.0.0 package repositories hosted on GitHub. Among others, we observe that package distributions are more permissive than what semantic versioning dictates for 0.y.z releases, and that many of the 0.y.z releases can actually be regarded as mature packages. As a consequence, the version number does not provide a good indication of the maturity of a package release.

CaPBug-A Framework for Automatic Bug Categorization and Prioritization Using NLP and Machine Learning Algorithms

Bug reports facilitate software development teams in improving the quality of software. These reports include significant information related to problems encountered within a software, possible enhancement suggestions, and other potential issues. Bug reports are typically complex and are too detailed; hence a lot of resources are required to analyze and process them manually. Moreover, it leads to delays in the resolution of high priority bugs. Accurate and timely processing of bug reports based on their category and priority plays a significant role in improving the quality of software maintenance. Therefore, an automated process of categorization and prioritization of bug reports is needed to address the aforementioned issues. Automated categorization and prioritization of bug reports have been explored recently by many researchers; however, limited progress has been made in this regard. In this research, we present a novel framework, titled CaPBug, for automated categorization and prioritization of bug reports. The framework is implemented using Natural Language Processing (NLP) and supervised machine learning algorithms. A baseline corpus is built with six categories and five prioritization levels by analyzing more than 2000 bug reports of Mozilla and Eclipse repository. Four classification algorithms i.e., Naive Bayes, Random Forest, Decision Tree, and Logistic Regression have been used to categorize and prioritize bug reports. We demonstrate that the CaPBug framework achieved an accuracy of 88.78% by using a Random Forest classifier with a textual feature for predicting the category. Similarly, using the CaPBug framework, an accuracy of 90.43% was achieved in predicting the priority of bug reports. Synthetic Minority Over-Sampling Technique (SMOTE) has been applied to address the class imbalance issue in priority classes.

Объектно-ориентированный подход к разработке моделей данных

The modern understanding of the object-oriented approach focuses on one of the main problems of programming – its automation. Many important and practically useful results have been achieved in this direction. Methods for creating object libraries and programming technologies have been developed, which greatly facilitate software development. This is especially evident in the development of WEB-applications. MVC technology has improved the efficiency of developing programs that link remote databases to client applications. However, this and similar technologies have one significant drawback, which is manifested in the fact that the time of obtaining data from their database often does not meet the requirements of both the developer and the user. For a long time, there have been ongoing discussions on this topic on the Internet. Various methods are proposed to speed up database calls, which, as a rule, complicate programming and are artificial methods that go beyond the basic technology, which are applicable to solving particular problems and require significant processing in each specific case. The article assumes that the reason for these problems lies in the fact that in the programming community there is a solidified opinion, the essence of which is that the relational data model, which serves as the basis for most modern DBMS, has nothing to do with the object-oriented paradigm. Therefore, developers of programming technologies use an intermediate technology called object-relational mapping (ORM), which, in their opinion, should connect the non-object database and the object program that provides the client application with the database. In fact, any way you organize your database systems is in the object-oriented paradigm. Based on these premises, the article discusses the object method of developing data models. For this purpose, the properties of data models are formulated, which are necessary for them to be object and to ensure high performance of programs that implement data processing on their basis. The concept of an abstract algebraic machine is introduced, which is a two-base algebraic system. Examples are given that illustrate the use of an abstract algebraic machine for solving various problems. The possibility is considered and a method is proposed for constructing algebraic systems for complex data structures, namely, tuples, which can be considered as elements of such data aggregates as multidimensional matrices, relations, files. In conclusion, it is concluded that the proposed approach allows one to prove the correspondence of various data models, which, in turn, makes it possible to effectively implement parallel processing of various databases on software and hardware complexes, the architecture of which is based on a multidimensional matrix computation model.

SMMARTS: An Open Architecture Development Platform for Modular, Mixed, and Augmented Reality Procedural and Interventional Simulators.

Different simulators often share elements, resulting in different laboratories doing redundant work. This can lead to higher development and acquisition costs, proprietary, incompatible technology, lack of interoperability, and large inventories that reduce accessibility to the benefits of simulation. Simulation technology can become more affordable and scalable with open architecture and modular design. We describe the System of Modular Mixed and Augmented Reality Tracking Simulators (SMMARTS) open architecture, rapid development platform for designing and building modular procedural and guided-intervention simulators. A modular stand provides mechanical indexing (registration) of a modular anatomical block representing the anatomy relevant to the simulated intervention. A software development kit (SDK) integrated with the hardware (stand and hand-held tracked tools such as a needle and ultrasound probe) facilitates software development. The SMMARTS SDK at https://github.com/UF-CSSALT/SMMARTS-SDK developed in Unity Technologies' Unity game engine includes Arduino microcontroller and NDI's 6 degrees of freedom tracking connectivity along with software tools such as a replayer, user interface templates, 3D visualization of the virtual counterparts of physical elements, scoring monitors, cognitive aids, common error messages, and Experience Application Programming Interface compatibility. We used SMMARTS to develop 9 different simulators internally (instructor-less central venous access currently deployed to Iraq, prostate biopsy, epidural loss-of-resistance, ventriculostomy, pterygopalatine fossa block, lumbar/chronic pain blocks, chest tube insertion) and externally (intravenous access). As a living tool, SMMARTS now has sufficient functionality and benefits that we can share it to help clinicians and engineers focus more on content specific to learning objectives rather than back-end tasks.

A Process Model for Component-Based Model-Driven Software Development

Developing high quality, reliable and on time software systems is challenging due to the increasing size and complexity of these systems. Traditional software development approaches are not suitable for dealing with such challenges, so several approaches have been introduced to increase the productivity and reusability during the software development process. Two of these approaches are Component-Based Software Engineering (CBSE) and Model-Driven Software Development (MDD) which focus on reusing pre-developed code and using models throughout the development process respectively. There are many research studies that show the benefits of using software components and model-driven approaches. However, in many cases the development process is either ad-hoc or not well-defined. This paper proposes a new software development process model that merges CBSE and MDD principles to facilitate software development. The model is successfully tested by applying it to the development of an e-learning system as an exemplar case study.

Siamese: scalable and incremental code clone search via multiple code representations

This paper presents a novel code clone search technique that is accurate, incremental, and scalable to hundreds of million lines of code. Our technique incorporates multiple code representations (i.e., a technique to transform code into various representations to capture different types of clones), query reduction (i.e., a technique to select clone search keywords based on their uniqueness), and a customised ranking function (i.e., a technique to allow a specific clone type to be ranked on top of the search results) to improve clone search performance. We implemented the technique in a clone search tool, called Siamese, and evaluated its search accuracy and scalability on three established clone data sets. Siamese offers the highest mean average precision of 95% and 99% on two clone benchmarks compared to seven state-of-the-art clone detection tools, and reported the largest number of Type-3 clones compared to three other code search engines. Siamese is scalable and can return cloned code snippets within 8 seconds for a code corpus of 365 million lines of code. Using an index of 130,719 GitHub projects, we demonstrate that Siamese’s incremental indexing capability dramatically decreases the index preparation time for large-scale data sets with multiple releases of software projects. The paper discusses the applications of Siamese to facilitate software development and research with two use cases including online code clone detection and clone search with automated license analysis.

Fast Code Clone Detection Based on Weighted Recursive Autoencoders

Code cloning considerably facilitates software development but also leads to recurring bugs and other software quality problems. In this paper, we propose a fast code clone detection method based on weighted recursive autoencoders (RAE) to measure code similarity at the function level. Different from manually defining features for code clone detection, our deep learning-based method can automatically learn program features. First, we analyze program abstract syntax trees using weighted RAE, extract the program features and encode the functions to vectors. During the modeling process, we consider node weight information in abstract syntax trees to increase the proportion of information contributed by important nodes in the final vector representation of one program. Second, we report functions with similar vectors as code clone pairs. The second phase is time consuming when analyzing large software systems because it needs quadratic pairwise comparisons. To solve this problem, we transform the clone detection problem into an approximate nearest neighbors search (ANNS) in a high-dimensional vector set and use the navigating spreading-out graph to reduce the computational time complexity. Experimental results on BigCloneBench show that our method outperforms the compared algorithm based on unweighted RAE in terms of precision, recall, and AUC value and can return clone pairs in approximately 33 min, while the compared algorithm requires approximately 14 days when performing pairwise comparisons among 785,438 functions’ vectors. Our method also outperforms many prominent tools, including Oreo, in detecting Moderately Type-3 or Type-4 clones, and our false positive rate (FPR) equals 0.055, which means few false positives. More importantly, our method has no need for labeled data, and all of the source code is released to guarantee experimental reproducibility.

A Comparative study of PHP frameworks performance

Abstract The increased demand for Web development has led to a high demand for efficiency, reliability, maintainability and scalability, which is why a PHP framework is an essential part of the web development toolbox. PHP frameworks are meant to facilitate software development and are becoming more and more popular in web-based projects, as they speed up the development process and reduce time, thus helping to meet coding standards. Bullet-proof and maintainable code. The final web applications created by the PHP framework will be more stable and secure. Today, there are hundreds of PHP frameworks. Each of these frameworks has its own advantages over others, however, selecting the best PHP framework for the developer can be tricky, which requires a good understanding of the different PHP frameworks. For this reason, this research has conducted a method of evaluation and performance testing to compare three PHP frameworks most used in web development to help the developer to better choose the most effective PHP framework for future web development.

Towards an Actor-based Approach to Design Verified ROS-based Robotic Programs using Rebeca

Robotic technology helps humans in different areas such as manufacturing, health care and education. Due to the ubiquitous revolution, today’s focus is on mobile robots and their applications in a variety of cyber-physical systems. ROS is a wll-known and powerful middleware that facilitates software development for mobile robots. However, this middleware does not support assuring properties such as timeliness and safety of ROS-based software. In this paper we present an integration of Timed Rebeca modeling language with ROS to synthesize verified robotic software. First, a conceptual model of robotic programs is developed using Timed Rebeca. After verifying a set of user-defined correctness properties on this model, it is translated to a ROS program automatically. Experiments on some small-scale case studies illustrates the applicability of the proposed integration method.

Introduction to the Special Issue on “International Conference on Software Reuse 2015”

Conducting requirements reviews before the start of software design is one of the central goals in requirements management. Fast and accurate reviews promise to facilitate software development process and mitigate technical risks of late design modifications. In large software development companies, however, it is difficult to conduct reviews as fast as needed, because the number of regularly incoming requirements is typically several thousand. Manually reviewing thousands of requirements is a time-consuming task and disrupts the process of continuous software development. As a consequence, software engineers review requirements in parallel with designing the software, thus partially accepting the technical risks. In this paper we present a measurement-based method for automating requirements reviews in large software development companies. The method, Rendex, is developed in an action research project in a large software development organization and evaluated in four large companies. The evaluation shows that the assessment results of Rendex have 73%-80% agreement with the manual assessment results of software engineers. Succeeding the evaluation, Rendex was integrated with the requirements management environment in two of the collaborating companies and is regularly used for proactive reviews of requirements.