Traditional Source Code Research Articles

A Transformer-based approach to highly granular source code authorship attribution

Traditional source code authorship identification methods often rely on features such as textual similarity, programming style or metadata, however, these methods often struggle to extract the precise source code authoring style when dealing with large-scale code bases or complex programming patterns, resulting in poor performance. Therefore, this paper proposes a Transformer-based high fine-grained source code author attribution method.Aiming at the problem of roughness of existing literature on word segmentation, this paper proposes a high fine-grained source code segmentation method to extract higher fine-grained features. Aiming at the problem of feature dimension redundancy, this paper adopts the Transformer network to locate sensitive features that can characterise the author's style.To verify the effectiveness of the model, it was tested on GCJ-C++ and GCJ-Java datasets. The experimental results show that the proposed method model achieves higher recognition accuracy in the source code authorship attribution problem compared to the traditional methods.

A Transformer-based approach to highly granular source code authorship attribution

Traditional source code authorship identification methods often rely on features such as textual similarity, programming style or metadata, however, these methods often struggle to extract the precise source code authoring style when dealing with large-scale code bases or complex programming patterns, resulting in poor performance. Therefore, this paper proposes a Transformer-based high fine-grained source code author attribution method.Aiming at the problem of roughness of existing literature on word segmentation, this paper proposes a high fine-grained source code segmentation method to extract higher fine-grained features. Aiming at the problem of feature dimension redundancy, this paper adopts the Transformer network to locate sensitive features that can characterise the author's style.To verify the effectiveness of the model, it was tested on GCJ-C++ and GCJ-Java datasets. The experimental results show that the proposed method model achieves higher recognition accuracy in the source code authorship attribution problem compared to the traditional methods.

A Novel Source Code Representation Approach Based on Multi-Head Attention

Code classification and code clone detection are crucial for understanding and maintaining large software systems. Although deep learning surpasses traditional techniques in capturing the features of source code, existing models suffer from low processing power and high complexity. We propose a novel source code representation method based on the multi-head attention mechanism (SCRMHA). SCRMHA captures the vector representation of entire code segments, enabling it to focus on different positions of the input sequence, capture richer semantic information, and simultaneously process different aspects and relationships of the sequence. Moreover, it can calculate multiple attention heads in parallel, speeding up the computational process. We evaluate SCRMHA on both the standard dataset and an actual industrial dataset, and analyze the differences between these two datasets. Experiment results in code classification and clone detection tasks show that SCRMHA consumes less time and reduces complexity by about one-third compared with traditional source code feature representation methods. The results demonstrate that SCRMHA reduces the computational complexity and time consumption of the model while maintaining accuracy.

Graph-Based Keyphrase Extraction for Software Traceability in Source Code and Documentation Mapping

Natural Language Processing (NLP) forms the basis of several computational tasks. However, when applied to the software system’s, NLP provides several irrelevant features and the noise gets mixed up while extracting features. As the scale of software system’s increases, different metrics are needed to assess these systems. Diagrammatic and visual representation of the SE projects code forms an essential component of Source Code Analysis (SCA). These SE projects cannot be analyzed by traditional source code analysis methods nor can they be analyzed by traditional diagrammatic representation. Hence, there is a need to modify the traditional approaches in lieu of changing environments to reduce learning gap for the developers and traceability engineers. The traditional approaches fall short in addressing specific metrics in terms of document similarity and graph dependency approaches. In terms of source code analysis, the graph dependency graph can be used for finding the relevant key-terms and keyphrases as they occur not just intra-document but also inter-document. In this work, a similarity measure based on context is proposed which can be employed to find a traceability link between the source code metrics and API documents present in a package. Probabilistic graph-based keyphrase extraction approach is used for searching across the different project files.

Pragmatic evidence of cross-language link detection: A systematic literature review

There is a rising trend for heterogeneous software applications involving multilingual source code. The key focus of reverse engineers is to unravel the cross-language links (XLLs) and their dependencies. This study aims to perform a systematic literature review (SLR) to compile different approaches, tools, techniques, and shortcomings of such techniques and understand the XLLs and their dependencies while performing reverse engineering on state-of-the-art software applications. This SLR selects 76 primary studies and uses them to create a ’go-to’ literature database, where professionals from software engineering could find all the content pertinent to the analysis and XLL detection for major multilingual applications like Java enterprise applications, Android applications, etc. It has been observed that traditional source code analysis mechanisms to reverse engineer contemporary software applications face scores of problems and limitations that need to be addressed. To assist the community in the above-mentioned goal, a general schema with definitions of XLLs and associated concepts is furnished. This study provides an SLR on XLLs, comprehensive taxonomy called cross-language analysis, which incorporates all the methods for XLL detection in multilingual source code. By pursuing future directions suggested in the end, researchers and practitioners can advance the field of multilingual applications; such as Enterprise resource planning (ERP) solutions, and cross-language software corpora, leading to improved software development practices and better understanding of language interactions in multilingual environments. The research data provided in the survey presents a comprehensive analysis of the complexities involved in working with diverse programming languages and frameworks, offering valuable insights for language technology researchers, software developers, academics, and decision-makers. This integration will enable them to identify and manage dependencies across diverse languages, leading to more efficient and reliable multilingual software systems.

CDNM: Clustering-Based Data Normalization Method For Automated Vulnerability Detection

Abstract The key to deep learning vulnerability detection framework is pre-processing source code and learning vulnerability features. Traditional source code representation techniques take a complete normalization to user-defined symbols but ignore the semantic information associated with vulnerabilities. The current mainstream vulnerability feature learning model is Recurrent Neural Network (RNN), whose time-series structure determines its insufficient remote information acquisition capability. This paper proposes a new vulnerability detection framework to solve the above problems. We propose a new data normalization method in the source code pre-processing phase. The user-defined symbols are clustered using the unsupervised clustering algorithm K-means. The normalized classification is performed according to the clustering results, which preserves the primary semantic information in the source code and ensures the smoothness of the sample data. In the feature extraction stage, we input the source code after performing text representation into Bidirectional Encoder Representations for Transformers (BERT) for feature automation learning, which enhances semantic information extraction and remote information acquisition. Experimental results show that the vulnerability detection precision of this method is 18.3% higher than that of the current mainstream vulnerability detection framework in the real-world data collected by ourselves. Further, our method improves the precision of the state-of-the-art method by 4.2%.

Wireless Image Transmission With Semantic and Security Awareness

Semantic communication is an increasingly popular framework for wireless image transmission due to its high communication efficiency. With the aid of the joint-source-and-channel (JSC) encoder implemented by neural network, semantic communication directly maps original images into symbol sequences containing semantic information. Compared with the traditional separate source and channel coding design used in bit-level communication systems, semantic communication systems are known to be more efficient and accurate especially in the low signal-to-the-noise ratio (SNR) regime. This thus prompts a critical while yet to be tackled issue of security in semantic communication: it makes the eavesdropper much easier to crack the semantic information as it can be retrieved even in a highly noisy channel. In this letter, we develop a semantic communication framework that accounts for both semantic meaning decoding efficiency and its risk of privacy leakage. To this end, targeting wireless image transmission, we propose an JSC autoencoder featuring residual structure for efficient semantic meaning extraction and transmission, and the training of which is guided by a well-designed loss function that can flexibly regulate the efficiency-privacy trade-off. Extensive experimental results are provided to show the effectiveness and robustness of the proposed scheme.

“Through the looking‐glass …” An empirical study on blob infrastructure blueprints in the Topology and Orchestration Specification for Cloud Applications

AbstractInfrastructure‐as‐code (IaC) helps keep up with the demand for fast, reliable, high‐quality services by provisioning and managing infrastructures through configuration files. Those files ensure efficient and repeatable routines for system provisioning, but they might be affected by code smells that negatively affect quality and code maintenance. Research has broadly studied code smells for traditional source code development; however, none explored them in the “Topology and Orchestration Specification for Cloud Applications” (TOSCA), the technology‐agnostic OASIS standard for IaC. In this paper, we investigate a prominent traditional implementation code smell potentially applicable to TOSCA: Large Class, or “Blob Blueprint” in IaC terms. We compare metrics‐based and unsupervised learning‐based detectors on a large dataset of manually validated observations related to Blob Blueprints. We provide insights on code metrics that corroborate previous findings and empirically show that metrics‐based detectors perform highly in detecting Blob Blueprints. We deem our results put forward a new research path toward dealing with this problem, for example, in the scope of fully automated service pipelines.

Software Defect Prediction using Deep Learning by Correlation Clustering of Testing Metrics

The software industry has made significant efforts in recent years to enhance software quality in businesses. The use of proactively defect prediction in the software will assist programmers and white box testing in detecting issues early, saving time and money. Conventional software defect prediction methods focus on traditional source code metrics such as code complexities, lines of code, and so on. These capabilities, unfortunately, are unable to retrieve the semantics of source code. In this paper, we have presented a novel Correlation Clustering fine-tuned CNN (CCFT-CNN) model based on testing Metrics. CCFT-CNN can predict the regions of source code that contain faults, errors, and bugs. Abstract Syntax Tree (AST) tokens are extracted as testing Metrics vectors from the source code. The correlation among AST testing Metrics is performed and clustered as a more relevant feature vector and fed into Convolutional Neural Network (CNN). Then, to enhance the accuracy of defect prediction, fine-tuning of the CNN model is performed by applying hyperparameters. The result analysis is performed on the PROMISE dataset that contains samples of open-source Java applications such as Camel Dataset, Jedit dataset, Poi dataset, Synapse dataset, Xerces dataset, and Xalan dataset. The result findings show that the CCFT- CNN model increases the average F-measure by 2% when compared to the baseline model.

User Interface Matters: Analysing the Complexity of Mobile Applications from a Visual Perspective

Product-centric techniques to analyze mobile applications leverage traditional source code analysis, size, market success, complexity, and others. Many of these techniques converge in the strategy of evaluating metrics taken from the source code that delivers the functionality of the software product. However, when following the Model-View-Controller (MVC) architecture, mobile applications are typically constructed by a compound of at least two programming languages, one to deliver the functionality and the other to describe the visual aspects. The latter is commonly left out from source code analysis, even though critical parts of the application are present in the graphic User Interface (UI). In this paper, we identify an opportunity to strengthen the product-centric mobile app analysis by incorporating UI metrics. This approach aims to enhance the expressiveness of source code metrics and deliver a more comprehensive analysis of the complexity, maintainability, and effort estimation of a mobile app. To introduce the concept, we present a case study realized using a block-based programming language to create mobile apps, in which we describe and calculate functional and UI metrics, discover commonalities and differences, discuss traits, and open tracks for further research.

Deep Learning for Source Code Modeling and Generation

Deep Learning (DL) techniques for Natural Language Processing have been evolving remarkably fast. Recently, the DL advances in language modeling, machine translation, and paragraph understanding are so prominent that the potential of DL in Software Engineering cannot be overlooked, especially in the field of program learning. To facilitate further research and applications of DL in this field, we provide a comprehensive review to categorize and investigate existing DL methods for source code modeling and generation. To address the limitations of the traditional source code models, we formulate common program learning tasks under an encoder-decoder framework. After that, we introduce recent DL mechanisms suitable to solve such problems. Then, we present the state-of-the-art practices and discuss their challenges with some recommendations for practitioners and researchers as well.

Project repositories for machine learning with TensorFlow

Abstract In machine learning, models capture intelligence from data using algorithms implemented on frameworks like TensorFlow. Models learn during the training phase; an iterative process in which parameters are tuned to improve the prediction accuracy. Software repositories are used to save the artifacts of model development so that they can be modified in subsequent releases and shared between development teams. Issues in saving the state of machine learning projects is different from standard software practices. Machine learning models are equivalent to binary executable programs and ideally one should be able to recreate the model from the information preserved in project repositories. Recreation of the model becomes necessary when there is a change in the development team as part of the product transition. Retraining of models also becomes necessary when the inaccuracy in the predictions made on new data increases beyond the acceptable limit. When traditional source code management systems are used for maintaining repositories of machine learning projects, we face challenges in keeping complete information required for model development starting from saved states. This paper presents the results of the studies conducted to identify the challenges in maintaining TensorFlow machine learning projects in repositories. Some of the existing tools are compared and recommendations are made to improve the ease of recreation of machine learning models by saving complete information in project repositories maintained in normal source code control systems.

A Conceptual Dependency Graph Based Keyword Extraction Model for Source Code to API Documentation Mapping

Natural language processing on software systems usually contain high dimensional noisy and irrelevant features which lead to inaccurate and poor contextual similarity between the project source code and its API documentation. Most of the traditional source code analysis models are independent of finding and extracting the relevant features for contextual similarity. As the size of the project source code and its related API documentation increases, these models incorporate the contextual similarity between the source code and API documentation for code analysis. One of the best solutions for this problem is finding the essential features using the source code dependency graph. In this paper, the dependency graph is used to compute the contextual similarity computation between the source code metrics and its API documents. A novel contextual similarity measure is used to find the relationship between the project source code metrics to the API documents. Proposed model is evaluated on different project source codes and API documents in terms of pre-processing, context similarity and runtime. Experimental results show that the proposed model has high computational efficiency compared to the existing models on the large size datasets.

A comparison of tree- and line-oriented observational slicing

Observation-based slicing and its generalization observational slicing are recently-introduced, language-independent dynamic slicing techniques. They both construct slices based on the dependencies observed during program execution, rather than static or dynamic dependence analysis. The original implementation of the observation-based slicing algorithm used lines of source code as its program representation. A recent variation, developed to slice modelling languages (such as Simulink), used an XML representation of an executable model. We ported the XML slicer to source code by constructing a tree representation of traditional source code through the use of srcML. This work compares the tree- and line-based slicers using four experiments involving twenty different programs, ranging from classic benchmarks to million-line production systems. The resulting slices are essentially the same size for the majority of the programs and are often identical. However, structural constraints imposed by the tree representation sometimes force the slicer to retain enclosing control structures. It can also “bog down” trying to delete single-token subtrees. This occasionally makes the tree-based slices larger and the tree-based slicer slower than a parallelised version of the line-based slicer. In addition, a Java versus C comparison finds that the two languages lead to similar slices, but Java code takes noticeably longer to slice. The initial experiments suggest two improvements to the tree-based slicer: the addition of a size threshold, for ignoring small subtrees, and subtree replacement. The former enables the slicer to run 3.4 times faster while producing slices that are only about 9% larger. At the same time the subtree replacement reduces size by about 8–12% and allows the tree-based slicer to produce more natural slices.

The need for software specific natural language techniques

For over two decades, software engineering (SE) researchers have been importing tools and techniques from information retrieval (IR). Initial results have been quite positive. For example, when applied to problems such as feature location or re-establishing traceability links, IR techniques work well on their own, and often even better in combination with more traditional source code analysis techniques such as static and dynamic analysis. However, recently there has been growing awareness among SE researchers that IR tools and techniques are designed to work under different assumptions than those that hold for a software system. Thus it may be beneficial to consider IR-inspired tools and techniques that are specifically designed to work with software. One aim of this work is to provide quantitative empirical evidence in support of this observation. To do so a new technique is introduced that captures the level of difficulty found in an information need, the true, often latent, information that a searcher desires to know. The new technique is used to compare two domains: Natural Language (NL) and SE. Analysis of the data leads to three significant findings. First, the variation in the distribution of difficulty of the SE information needs differs from that of the NL information needs; second, collection age plays a role in the differences between the NL collections; and finally, the retrieval model used has little impact on the results.

Software trustworthiness 2.0—A semantic web enabled global source code analysis approach

There has been an ongoing trend toward collaborative software development using open and shared source code published in large software repositories on the Internet. While traditional source code analysis techniques perform well in single project contexts, new types of source code analysis techniques are ermerging, which focus on global source code analysis challenges. In this article, we discuss how the Semantic Web, can become an enabling technology to provide a standardized, formal, and semantic rich representations for modeling and analyzing large global source code corpora. Furthermore, inference services and other services provided by Semantic Web technologies can be used to support a variety of core source code analysis techniques, such as semantic code search, call graph construction, and clone detection. In this paper, we introduce SeCold, the first publicly available online linked data source code dataset for software engineering researchers and practitioners. Along with its dataset, SeCold also provides some Semantic Web enabled core services to support the analysis of Internet-scale source code repositories. We illustrated through several examples how this linked data combined with Semantic Web technologies can be harvested for different source code analysis tasks to support software trustworthiness. For the case studies, we combine both our linked-data set and Semantic Web enabled source code analysis services with knowledge extracted from StackOverflow, a crowdsourcing website. These case studies, we demonstrate that our approach is not only capable of crawling, processing, and scaling to traditional types of structured data (e.g., source code), but also supports emerging non-structured data sources, such as crowdsourced information (e.g., StackOverflow.com) to support a global source code analysis context.

An Efficient P2P Content Distribution System Based on Altruistic Demand and Recoding Dissemination

Peer-to-peer (P2P) content distribution systems based on random linear combination coding schemes outperform traditional block forwarding and source coding systems but have large storage requirements and high computation and communication overheads. To resolve this problem, this paper presents an efficient and scalable P2P content dissemination system based on novel altruistic demand and recoding dissemination mechanisms. In the proposed approach, the shared-content file is segmented and encoded using Reed-Solomon code at a seed. Downstream peers wishing to obtain the file utilize an altruistic demand mechanism to issue demand requests for coded blocks which are useful not only to themselves but also to their neighbors. Upon receiving these requests, the upstream peers utilize a recoding dissemination mechanism to provide the downstream peers with either an existing useful coded block or a new coded block produced using a Lagrange polynomial interpolation method. The two mechanisms rapidly increase the diversity of the coded blocks within the network and therefore provide an effective solution to the missing last block problem. In addition, it is shown that the proposed content distribution system demonstrates a substantial improvement over P2P systems based on random linear combination coding in terms of a lower storage requirement, reduced computation and communication costs, and an improved download efficiency.

Domain-specific aspect languages for modularising crosscutting concerns in grammars

The emergence of crosscutting concerns can be observed in various representations of software artifacts (e.g., source code, models, requirements, and language grammars). Although much of the focus of AOP has been on aspect languages that augment the descriptive power of general purpose programming languages, there is also a need for domain-specific aspect languages that address particular crosscutting concerns found in software representations other than traditional source code. This paper discusses the issues involved in the design and implementation of domain-specific aspect languages that are focused within the domain of language specification. Specifically, the paper outlines the challenges and issues that we faced while designing two separate aspect languages that assist in modularizing crosscutting concerns in grammars.

A testbed for configuration management policy programming

Even though the number and variety of available configuration management systems has grown rapidly in the past few years, the need for new configuration management systems still remains. Driving this need are the emergence of situations requiring highly specialized solutions, the demand for management of artifacts other than traditional source code and the exploration of entirely new research questions in configuration management. Complicating the picture is the trend toward organizational structures that involve personnel working at physically separate sites. We have developed a testbed to support the rapid development of configuration management systems. The testbed separates configuration management repositories (i.e., the stores for versions of artifacts) from configuration management policies (i.e., the procedures, according to which the versions are manipulated) by providing a generic model of a distributed repository and an associated programmatic interface. Specific configuration management policies are programmed as unique extensions to the generic interface, while the underlying distributed repository is reused across different policies. The authors describe the repository model and its interface and present their experience in using a prototype of the testbed, called NUCM, to implement a variety of configuration management systems.

The Control Structure Diagram: An Overview and InitialEvaluation

A new graphical representation, the Control Structure Diagram (CSD), has been created to visualize software at both the source code and program design language (PDL) level. The primary impetus for creation of the CSD was to improve the comprehension efficiency of software and, as a result, improve reliability and reduce costs. The CSD has the potential to replace traditional prettyprinted source code. As part of the GRASP (Graphical Representations of Algorithms, Structures, and Processes) research project at Auburn University, the GRASP software engineering tool has been successfully developed. GRASP automatically generates CSDs from source code written in Ada, C, C++, Java, and VHDL. The emphasis to this point has been on the automatic generation of the CSD to support development, maintenance, reverse engineering and reengineering through the use of GRASP. GRASP has been applied successfully to numerous programs ranging in size from several hundred to several thousand lines of source code and is efficient and sufficiently flexible for use in a production setting. To demonstrate the potential benefits of the CSD and its automatic generation using GRASP, a series of empirical studies has been planned and initiated. First, as reported in this article, the perceived usefulness of the CSD was evaluated using a preference instrument based on eleven performance characteristics in which a comparison was made with other well-known graphical representations for algorithms. Statistical analysis indicated numerous significant differences with a clear preference for the CSD in seven of the eleven performance characteristics. Further empirical studies, currently being implemented, will examine the effect of the CSD and GRASP on objective measures such as comprehension efficiency and effectiveness.