Automatic online partial evaluation

Code clones are widespread in software since programmers always reuse code to reduce programming effort. As programming languages are continuing to evolve and morph, code clones also widely exist across different languages for platform compatibility and adoption. Although code clones can improve development efficiency, they are prone to introducing bugs. Existing code clone detection technologies, however, mainly focused on single programming language or syntactical features of code. The syntax of different programming language are diverse because of syntax sugar, and many cloning pairs are semantic related instead of syntactic similar, such as Type 4 clones. To bridge the gap between syntax and semantic, and detect clone-related bugs more accurately, we explore an IR (Intermediate Representation) based method to represent code semantic representation information of multiple language code. We utilize graph neural network to learn code semantic representation. Through the semantic representation, we can detect more cross-language clone related bugs across multiple language.

Code cloning is a common practice in software development, where developers reuse existing code to accelerate programming speed and enhance work efficiency. Existing clone-detection methods mainly focus on code clones within a single programming language. To address the challenge of code clone instances in cross-platform development, we propose a novel method called TCCCD, which stands for Triplet-Based Cross-Language Code Clone Detection. Our approach is based on machine learning and can accurately detect code clone instances between different programming languages. We used the pre-trained model UniXcoder to map programs written in different languages into the same vector space and learn their code representations. Then, we fine-tuned TCCCD using triplet learning to improve its effectiveness in cross-language clone detection. To assess the effectiveness of our proposed approach, we conducted thorough comparative experiments using the dataset provided by the paper titled CLCDSA (Cross Language Code Clone Detection using Syntactical Features and API Documentation). The experimental results demonstrated a significant improvement of our approach over the state-of-the-art baselines, with precision, recall, and F1-measure scores of 0.96, 0.91, and 0.93, respectively. In summary, we propose a novel cross-language code-clone-detection method called TCCCD. TCCCD leverages the pre-trained model UniXcode for source code representation and fine-tunes the model using triplet learning. In the experimental results, TCCCD outperformed the state-of-the-art baselines in terms of the precision, recall, and F1-measure.

Recursive function theory studies functions that can be evaluated by an algorithm based on some computing model such as a Turing machine or computer program. These functions are called partial recursive (p.r.) and are defined on subsets of N, where N = {0, 1,... }, with values in N. (A good introduction to the theory may be found in [2].) This paper explains the Parameter Theorem, illustrates some unusual computer programs, and explains their connection to recursive function theory. Basing our computing model on a modern high level language, we can construct programs whose existence is known through more formal means. Our functions will operate on strings rather than numbers, however. There is no loss in generality since strings can be viewed as members of N, and vice-versa. From a practical aspect, this approach is somewhat more desirable since conventional programming languages often allow making use of long strings, but place more restrictive limits on the size of integers. We first pose a problem: Does there exist a program (written in some conventional programming language) which halts if and only if its input is identical to the program's text (i.e., source code)? For the remainder of this note X is the set of ASCII characters 'a,' 'b, +,' space, line feed, and so forth, needed to write programs in most programming languages. We denote by X * the set of all strings (finite sequences) over X. Let P1 be the set of all one variable partial recursive functions on X *. A function I belongs to P1 if and only if there is a subset of S of X* and some algorithm which computes 't by associating with each element of S a well-defined element of X *. Similarly, 't belongs to P2 if and only if there is a set S c X * X X *, and an algorithm for 't which associates with each element of S a well-defined element of X *. A partial recursive function I in P1 (or in P2) is recursive if the algorithm is defined on all of X * (or X * X X *). This is equivalent to saying that the algorithm which evaluates I always halts. Our computing model will be based on Adat; its high-level string-handling properties simplify later examples. For readability, however, we will express algorithms in a more familiar Pascal-like style. Readers familiar with either programming language should find forthcoming algorithms sufficiently clear. A formal presentation in Ada is given in the Appendix. A string of ASCII characters, such as in FIGURE 1, represents a function in our language which takes strings to strings. Of course, strings of ASCII characters such as The quick brown fox and %*!! represent nothing at all in our programming language. Let A1 be the set of all strings in X * representing functions in our language of one input STRING which outputs a STRING. Similarly let A2 be the set of all strings in

Exact or nearly similar code fragments in a software system's source code are referred to as code clones. It is often the case that updates (i.e., changes) to a code clone will need to be propagated to its related code clones to preserve their similarity and to maintain source code consistency. When there is a delay in propagating the changes (possibly because the developer is unaware of the related cloned code), the system might behave incorrectly. A delay in propagating a change is referred to as `late propagation,' and a number of studies have investigated this phenomenon. However, these studies did not investigate the intensity of late propagation nor how late propagation differs by clone type. In this research, we investigate late propagation separately for each of the three clone types (Type 1, Type 2, and Type 3). According to our experimental results on thousands of revisions of eight diverse subject systems written in two programming languages, late propagation occurs more frequently in Type 3 clones compared with the other two clone types. More importantly, there is a higher probability that Type 3 clones will experience buggy late propagations compared with the other two clone types. Also, we discovered that block clones are more involved in late propagation than method clones. Refactoring and tracking of Similarity Preserving Change Pattern (SPCP) clones (i.e., the clone fragments that evolve following a SPCP) can help us minimize the occurrences of late propagation in clones.

Developers often practice re-use by copying and pasting code. Copied and pasted code is also known as clones. Clones may be found in all programming languages. Automated clone detection may help to detect clones in order to support software maintenance and language design. Syntax-based clone detectors find similar syntax subtrees and, hence, are guaranteed to yield only syntactic clones. They are also known to have high precision and good recall. Developing a syntax-based clone detector for each language from scratch may be an expensive task. In this paper, we explore the idea to integrate syntax-based clone detection into workbenches for language engineering. Such workbenches allow developers to create their own domain-specific language or to create parsers for existing languages. With the integration of clone detection into these workbenches, a clone detector comes as a free byproduct of the grammar specification. The effort is spent only once for the workbench and not multiple times for every language built with the workbench. We report our lessons learned in applying this idea for three language workbenches: the popular parser generator ANTLR and two language workbenches for domain-specific languages, namely, MPS, developed by JetBrains, and Xtext, which is based on the Eclipse Modeling Framework.

Developers frequently employ Copy and Paste. However, little is known about the copy and paste behavior during development. To better understand the copy and paste behavior, automated approaches are proposed to identify cloned code. However, such automated approaches can only identify the location of the code that has been copied and pasted, but little is known about the context of the copy and paste. On the other hand, prior research studying actual copy and paste behavior is based on a small number of users in an experimental setup. In this paper, we study the behavior of developers copying and pasting code while using the Eclipse IDE. We mine the usage data of over 20,000 Eclipse users. We aim to explore the different patterns of Copy and Paste (C&P) that are used by Eclipse users during development. We compare such usage patterns to the regular users' usage of copy and paste during non-development tasks reported in earlier studies. Our findings instruct builders of future IDEs. We find that developers' C&P behavior is considerably different from the behavior of regular users. For example, developers tend to perform more frequent C&P in the same file contrary to regular users, who tend to perform C&P across different windows. Moreover, we find that C&P across different programming languages is a common behavior as we extracted more than 75,000 C&P incidents across different programming languages. Such a finding highlights the need for code cloning tools that can detect code clones across different programming languages.

Reusing code through copy and paste is a well-known process in software development. The replicated code is known as code clone and the process is known as code cloning. Software clones can cause bug propagation and severe issues related to maintenance. Code clone detection process consist of many steps, which is complex to some extent for user to perform. Therefore, we are trying to propose a generic approach for code clone detection approaches at model level. This study particularly presents Unified Modeling Language profile for Code Clone Detection (UMLCCD) to model the process of token-based code clone detection approaches as token-based approaches has good execution time while maintaining high precision and recall. It automate the clone detection process of token-based approaches which is helpful for user because user simply gives input and whole process is done automatically. It can be used for source code of various programming languages. The proposed UML profile provides the bases to transform the UMLCCD source model into required text. The applicability of UMLCCD is validated by taking 484 lines of source code of Library Management System case study.

Purpose. The authors aim to determine the differences between functional programming languages, to identify the capabilities of the most popular languages by comparing and analyzing them. To identify the main features, it is necessary to consider their data structures, as well as the application scope. The authors also aim to analyze and compare examples from various fields of language application using metrics of the program texts complexity. Methodology. The five most popular specialized functional languages are selected: Erlang, Lisp, F #, Scala and Haskel. An overview of the official documentation was conducted to obtain information on the capabilities of each language; their data structures and the application scope were studied. The experimental research base is formed from texts of the existing open source software systems and matched by similar applications and equal volume of text. Comparative analysis of sample programs is performed using Halsted metrics, which are calculated using specially designed software. The analysis of the received quality assessments is done graphically. Findings. Software has been developed to obtain Halsted metrics for program input texts in functional programming languages such as Erlang, Lisp, F # and Scala. The complexity of the Haskel programming language syntax did not allow the use of metrics to evaluate the text, so only a documentation review was performed. Benchmarking shows the differences between languages and outlines their use. The examples of different volumes from such areas of application as system programming tasks, graphing, mathematical calculations, AI systems, web programming, etc. were compared. Originality. The authors first conducted a comparative analysis of specialized languages using text complexity metrics, which made it possible to establish that Lisp has the smallest vocabulary and code length, Scala text has the most structured form, and F # and Erlang are marked with extra verbosity. Practical value. The findings and measurements will help in selecting the most effective functional programming language for solving specific problems, taking into account differences in applications. The developed software allows making measurements for various program texts when developing and maintaining complex software systems.

Effort for development and maintenance of complex large software is believed to have dependency on the amount of duplicated code fragments (code clones) present in code-bases. For example, clones need to be carefully and consistently maintained and/or refactored for preventing accidental error propagation. Thus it is important to understand the proportion and evolution of clones in evolving software systems for cost estimation or the like. This paper presents a study on the evolution of near-miss clones at release level in medium to large open source software systems of different types (operating systems, database systems, editors, etc.) written in three different programming languages namely C, C#, and Java. Using a hybrid clone detector, NiCad, we detected both exact and near-miss clones at different levels of similarity. Applying statistical methods we investigated, from different dimensions, the evolution of both exact and near-miss clones, and also forecasted the amount of clones in future releases of the software systems. Our study offers significant insights into the existence and evolution of code clones and their relationships with programming language or paradigm and program size.

The paper describes a new programming language for structured programming of computer operating systems. It extends the sequential programming language Pascal with concurrent programming tools called processes and monitors. Section I explains these concepts informally by means of pictures illustrating a hierarchical design of a simple spooling system. Section II uses the same example to introduce the language notation. The main contribution of Concurrent Pascal is to extend the monitor concept with an explicit hierarchy Of access' rights to shared data structures that can be stated in the program text and checked by a compiler.

Existing commercial and open source speech recognition engines do not come with prebuilt models that lend themselves to natural input of programming languages. Prior approaches to this problem have largely concentrated on developing spoken syntax for existing programming languages. In this paper, we instead describe a new programming language and environment that is being developed to use "closer to English" syntax. In addition to providing a more intuitive spoken syntax for users, this allows existing speech recognizers to achieve improved accuracy using their prebuilt English models. Our basic recognizer is built from a standard context-free grammar together with the CMU Sphinx pre-trained English models. To improve its accuracy, we modify the language model during runtime by factoring in additional context derived from the program text, such as variable scoping and type inference. While still a work in progress, we anticipate that this will yield measurable improvements in speed and accuracy of spoken program dictation.

Code clones mostly have been proven harmful for the development and maintenance of software systems, leading to code deterioration and an increase in bugs as the system evolves. Modern software systems are composed of several components, incorporating multiple technologies in their development. In such systems, it is common to replicate (parts of) functionality across the different components, potentially in a different programming language. Effect of these duplicates is more acute, as their identification becomes more challenging. This paper presents LICCA, a tool for the identification of duplicate code fragments across multiple languages. LICCA is integrated with the SSQSA platform and relies on its high-level representation of code in which it is possible to extract syntactic and semantic characteristics of code fragments positing full cross-language clone detection. LICCA is on a technology development level. We demonstrate its potential by adopting a set of cloning scenarios, extended and rewritten in five characteristic languages: Java, C, JavaScript, Modula-2 and Scheme.

Code summarization and generation empower conversion between programming language(PL) and natural language (NL), while code translation avails the migration of legacy code from one PL to another. This paper introduces PLBART, a sequence-to-sequence model capable of performing a broad spectrum of program and language understanding and generation tasks. PLBART is pre-trained on an extensive collection of Java and Python functions and associated NL text via denoising autoencoding. Experiments on code summarization in the English language, code generation, and code translation in seven programming languages show that PLBART outperforms or rivals state-of-the-art models. Moreover, experiments on discriminative tasks,e.g., program repair, clone detection, and vulnerable code detection, demonstrate PLBART’s effectiveness in program understanding. Furthermore, analysis reveals that PLBART learns program syn-tax, style (e.g., identifier naming convention), logical flow (e.g., if block inside an else block is equivalent to else if block) that are crucial to program semantics and thus excels even with limited annotations.

The concept of software birthmark is developed for the detection of theft and piracy in software applications. The originality of software can be evaluated by comparing software programs on the basis of their birthmarks. A number of birthmark designs have been proposed which are used to specify birthmark for source code and executable code related to particular programming languages. This study presents a systematic literature review on available software birthmark designs and related techniques for comparing birthmarks in order to identify pirated software. This research is focused on identifying different applications of software birthmark, especially the estimation of software birthmark to identify the extent of piracy performed in a software. The objective is to gain insight into complex details of software birthmark by accumulating and analyzing the knowledge provided in the literature in order to facilitate further research in software birthmark and its applications. The study is conducted by following the systematic literature review protocol. The data are collected from primary studies published from 1992 to April 2018 in specified journals and conference/workshop proceedings. A total of 143 primary studies are selected, based on predefined exclusion, inclusion, and quality criteria. The research identifies 22 software birthmark techniques frequently used and discussed by researchers and industry. The study also identifies a number of important applications of software birthmarks. These applications define the use of software birthmark in software theft and plagiarism detection, intellectual software asset management, detecting binary theft, malware detection, detecting the theft of natural language, and semantics-based repackaging detection for mobile apps. The results show that despite the large-scale research and development of different birthmark techniques, there is a lack of organized knowledge which is needed to facilitate the usage of software birthmark for critical applications like clone detection and malware detection. Furthermore, it is seen that the area of software birthmark estimation is not well researched which needs to be explored further. The study recommends that the area of software birthmark needs to be explored for developing a reliable and authentic mechanism which can accurately and easily detect software theft and ultimately prevent the piracy of software.

The problem of similarity (similarity) of program code can be one solution to the plagiarism detection approach. Plagiarism raises a form of action and consequences of plagiarism itself if the source used is not open source. Plagiarism is an act of deception of the work of others without the knowledge of the original author, which violates a Copyright and Moral Rights. With the increasing amount of data and data complexity, deep learning provides solutions for predictive analytics, with increased processing capabilities and optimal processor utilization. Deep learning shows success and improves the classification model in this field. On the other hand, clone detection code with massive, varied and high-speed data volumes requires feature extraction. With the potential of deep learning to extract better features, deep learning techniques are suitable for code clone detection. For this reason, it is necessary to develop a clone detection code that can process data from a programming language by utilizing deep learning. Based on the results of experiments conducted on 100 PHP program code data files, experimented with several types of activation function and optimizer methods. The average value of the resulting accuracy is good. With a variety of activation functions that we use such as Relu, Linear, Sigmoid, Softmax, Tanh, Elu, Selu, Softplus, Softsign, hard, and sigmoid, as well as variations of the optimizer used are Adagrad, RMSProp, SGD, Adadelta, Adam, Adamax and Nadam , the best attribute selection is in the Selu function and the RMSProp optimizer. The number of epochs used is 1000, the number of neurons per layer is 500 and the best number of hidden layers is 10, the average accuracy is 0.900