Repetitive Code Research Articles

CodeEditor : Learning to Edit Source Code with Pre-trained Models

Developers often perform repetitive code editing activities (up to 70%) for various reasons (e.g., code refactoring) during software development. Many deep learning (DL) models have been proposed to automate code editing by learning from the code editing history. Among DL-based models, pre-trained code editing models have achieved the state-of-the-art (SOTA) results. Pre-trained models are first pre-trained with pre-training tasks and fine-tuned with the code editing task. Existing pre-training tasks mainly are code infilling tasks (e.g., masked language modeling), which are derived from the natural language processing field and are not designed for automatic code editing. In this article, we propose a novel pre-training task specialized in code editing and present an effective pre-trained code editing model named CodeEditor . Compared to previous code infilling tasks, our pre-training task further improves the performance and generalization ability of code editing models. Specifically, we collect lots of real-world code snippets as the ground truth and use a powerful generator to rewrite them into mutated versions. Then, we pre-train our CodeEditor to edit mutated versions into the corresponding ground truth, to learn edit patterns. We conduct experiments on four code editing datasets and evaluate the pre-trained CodeEditor in three settings (i.e., fine-tuning, few-shot, and zero-shot). (1) In the fine-tuning setting, we train the pre-trained CodeEditor with four datasets and evaluate it on the test data. CodeEditor outperforms the SOTA baselines by 15%, 25.5%, 9.4%, and 26.6% on four datasets. (2) In the few-shot setting, we train the pre-trained CodeEditor with limited data and evaluate it on the test data. CodeEditor substantially performs better than all baselines, even outperforming baselines that are fine-tuned with all data. (3) In the zero-shot setting, we evaluate the pre-trained CodeEditor on the test data without training. CodeEditor correctly edits 1,113 programs, while the SOTA baselines cannot work. The results show that the superiority of our pre-training task and the pre-trained CodeEditor is more effective in automatic code editing.

Web Based Portal for Complete Data Engineering

Abstract: Machine Learning has become the need of today’s world. Any intelligent system is incomplete without Machine Learning. People use ML models in various applications. Every ML-based project has to go through some of the steps during the development process. This process consists of certain common steps which every ML project needs to follow. The process of building ML models is tedious and time consuming. There are some common problems which people face while developing MLbased projects. That includes lack of resources and infrastructure, lack of uniformity in codebase and writing repetitive code for every project. These problems are very serious as building ML models needs a lot of effort and time. This paper aims to describe some of the problems that people face during the development of ML-based projects. It also provides a solution to reduce many problems and save efforts in the development process. The system proposed in this paper can save a lot of time and effort in building ML models. It will help to build projects faster and increase efficiency.

A verifiable multi-party quantum key distribution protocol based on repetitive codes

A multi-party quantum key distribution protocol based on repetitive code is designed in this paper for the first time. First we encode the classical key sequence in accordance with this repetitive code. Then unitary transformation of the quantum state sequence corresponding to this encoded sequence is carried out by using the parameters from this (t, n) threshold protocol. Furthermore, we derive two thresholds for whether or not reserving the measured values of the received sequence, and extract the classical subkey sequence from the measured values conforming to these two threshold conditions. This protocol can authenticate the identity of the participant, resist the attack from the internal and external participants, and do not need the decoy state particles when testing the eavesdropper, which is more efficient than the similar protocols, and also saves the quantum resources.

Deliberate Practice in Simulation: Evaluation of Repetitive Code Training on Nursing Students’ BLS Team Skills

BackgroundBasic life support (BLS) skills decline rapidly without frequent practice. Deliberate practice (DP) and simulation scenarios have been shown to increase BLS skill retention for nursing students. In addition, BLS implementation in the hospital setting requires effective team skills, which are infrequently addressed in resuscitation courses or in nursing students’ practice. An exploratory study to determine the impact of recurrent simulations with DP on BLS team skills was designed for senior nursing students. MethodSeven teams of students were followed over the course of one semester examining the impact of DP in recurrent simulation codes on BLS team skills. ResultsStudents attained effective BLS team performance after three hours of DP and sustained these skills over the semester with recurrent code practice. ConclusionRecurring code team DP sustains BLS skills and is recommended for nursing students.

CODIT: Code Editing With Tree-Based Neural Models

The way developers edit day-to-day code tends to be repetitive, often using existing code elements. Many researchers have tried to automate repetitive code changes by learning from specific change templates which are applied to limited scope. The advancement of deep neural networks and the availability of vast open-source evolutionary data opens up the possibility of automatically learning those templates from the wild. However, deep neural network based modeling for code changes and code in general introduces some specific problems that needs specific attention from research community. For instance, compared to natural language, source code vocabulary can be significantly larger. Further, good changes in code do not break its syntactic structure. Thus, deploying state-of-the-art neural network models without adapting the methods to the source code domain yields sub-optimal results. To this end, we propose a novel tree-based neural network system to model source code changes and learn code change patterns from the wild. Specifically, we propose a tree-based neural machine translation model to learn the probability distribution of changes in code. We realize our model with a change suggestion engine, <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Codit</small> , and train the model with more than 24k real-world changes and evaluate it on 5k patches. Our evaluation shows the effectiveness of <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Codit</small> in learning and suggesting patches. <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Codit</small> can also learn specific bug fix pattern from bug fixing patches and can fix 25 bugs out of 80 bugs in Defects4J.

Free Code Sharing Web Platform with Intelligent Developer Suggestion Tool

Due to increase in demands for websites, faster deployment requirements and complex functionality requirements, developers face the need for a centralized code repository system to store repetitive codes and a suggestion tool to help them in solving the errors and warnings they face during development. The proposed system provides a centralized database for storing repetitive code segments, errors, warnings and solutions and also a code suggestion mechanism to provide suggestions to the developer during development. The system includes a code collection system to help the user to add the codes, errors and solutions to the centralized database and an analyzer system to fetch the web-page data, errors and warnings to analyze and provide appropriate suggestions to the developer. The proposed system focuses to reduce work and development time of developers by providing code suggestions during development and also facilitate effective code reusability.

Similarity Code File Detection Model Based on Frequent Itemsets

In order to improve the efficiency and accuracy of program source code similarity detection, an improvement on the method of code detection is made according to some deficiencies of the current research. A similar code detection model based on frequent item sets is proposed. The model constructs frequent items set data to discover repetitive code collections and automatically divide file similarity attribution. The algorithm model does not need to consider the type of the code in the detection process, and has wide applicability, not only can detect the code files of different programming languages and grammars, but also can mark out similar codes and statistic the results. Simultaneously, through experimental comparison, it is proved that the model has high accuracy and processing efficiency.

Identification of Potential Reusable Subroutines in Recorded Automated Test Scripts

In the automated testing based on actions in user interface of the tested application, one of the key challenges is maintenance of these tests. The maintenance overhead can be decreased by suitably structuring the test scripts, typically by employing reusable objects. To aid in the development, maintenance and refactoring of these test scripts, potentially reusable objects can be identified by a semi-automated process. In this paper, we propose a solution that identifies the potentially reusable objects in a set of automated test scripts and then provides developers with suggestions about these objects. During this process, we analyze the semantics of specific test steps using a system of abstract signatures. The solution can be used to identify the potentially reusable objects in both recorded automated test sets and tests programmed in an unstructured style. Moreover, compared to approaches that are based solely on searching for repetitive source code fragments, the proposed system identifies potentially reusable objects that are more relevant for test automation.

Staged generic programming

Generic programming libraries such as Scrap Your Boilerplate eliminate the need to write repetitive code, but typically introduce significant performance overheads. This leaves programmers with the regrettable choice between writing succinct but slow programs and writing tedious but efficient programs. Applying structured multi-stage programming techniques transforms Scrap Your Boilerplate from an inefficient library into a typed optimising code generator, bringing its performance in line with hand-written code, and so combining high-level programming with uncompromised performance.

Lydgate's Kneeling Retraction:

Abstract This article maintains that John Lydgate's Testament is not a rejection of his secular career but a literary palinode that attempts to impress a sense of coherence onto a diverse body of work. As the language of conversion, the repetitive litaneutical code at the end of the poem is vindicated by the earlier performance of poetic bravado. Lydgate's textual piety, which I show to be indebted to the devotion to the Holy Name of Jesus, is paradoxically sustained by the displacement of prior secular forms. In a central gesture, the kneeling monk-poet presents his life's work to God, who acts as his patron. Finally, I demonstrate that manuscript illuminations depicting a kneeling Lydgate confirm the reception of such a pose as simultaneously pious yet secular.

Improving code completion based on repetitive code completion operations

Improving code completion based on repetitive code completion operations

Improving code completion based on repetitive code completion operations

Improving code completion based on repetitive code completion operations

An automated simulator-independent workflow for reproducible simulation and analysis using Lancet and IPython Notebook

Lancet [1] is a new, simulator-independent utility for succinctly specifying, launching, and collating results from large batches of interrelated simulations. Neural simulations require significant time and computational resources, particularly when exploring the large parameter spaces involved. Simulators rarely provide specific, comprehensive support for launching and collecting results across batch runs, and so the process of going from idea to publishable results typically involves an ad-hoc set of manual practices and/or one-off shell scripts. This informal process can be difficult to replicate later, because information about each of the processing steps is lost over time. Here we demonstrate how Lancet can be used together with IPython Notebook [2] to provide a fully automated and fully reproducible workflow for neural simulations and similar batch-computing tasks. This workflow covers specifying what simulations are to be launched, storing metadata about each simulation run, collating the resulting output files, analyzing the results, and generating publication-quality figures that can be traced directly back to the original simulation and analysis code. This approach scales to hundreds of parallel jobs launched and simulation results spread across thousands of files, allowing users to focus on the scientific component of their work instead of writing repetitive boilerplate code. Lancet is most useful with batch schedulers such as Oracle Grid Engine or other computing clusters, but also works well with single workstations. Users are given a small set of composable primitives that can succinctly specify large parameter spaces, from which individual jobs are generated. The declared simulation can then be reviewed in detail, avoiding mistakes before valuable time and computational resources are expended. All Lancet components are designed as self-contained, declarative objects that constitute the elements of a small DSL (domain specific language). Once all the simulations are complete and the necessary files have been generated, Lancet collates the results for further analysis. To complete the workflow, the results can then be imported into an IPython Notebook, where they can be visualized interactively, with immediate feedback and a record of the analysis steps for reproducibility. This workflow allows you to assess your results for each simulation or compare results between different simulations. The generated data can be viewed in manageable chunks, without needing to directly manipulate files on either the local or remote filesystem. As parameters associated with each simulation are automatically recorded and tracked, all the relevant parameters are available for each file viewed. You can then process your data, saving it back out to separate files or to a database backend (HDF5 format using PyTables is currently supported [3]) while maintaining all the relevant metadata. The core of Lancet is written in pure Python (Python 2 and 3 are supported), offering a general framework that is easily integrated with external tools and simulators that keeps track of all parameters used, ensuring a reproducible workflow. The fundamental design is entirely independent of the tools that are invoked, making Lancet a flexible and general tool for anyone who needs to run and analyze the data generated by hundreds of time-consuming simulations.

Genome-wide comparative analysis of simple sequence coding repeats among 25 insect species

We present a detailed genome-scale comparative analysis of simple sequence repeats within protein coding regions among 25 insect genomes. The repetitive sequences in the coding regions primarily represented single codon repeats and codon pair repeats. The CAG triplet is highly repetitive in the coding regions of insect genomes. It is frequently paired with the synonymous codon CAA to code for polyglutamine repeats. The codon pairs that are least repetitive code for polyalanine repeats. The frequency of hexanucleotide and dinucleotide motifs of codon pair repeats is significantly (p<0.001) different in the Drosophila species compared to the non-Drosophila species. However, the frequency of synonymous and non-synonymous codon pair repeats varies in a correlated manner (r2=0.79) among all the species. Results further show that perfect and imperfect repeats have significant association with the trinucleotide and hexanucleotide coding repeats in most of these insects. However, only select species show significant association between the numbers of perfect/imperfect hexamers and repeat coding for single amino acid/amino acid pair runs. Our data further suggests that genes containing simple sequence coding repeats may be under negative selection as they tend to be poorly conserved across species. The sequences of coding repeats of orthologous genes vary according to the known phylogeny among the species. In conclusion, the study shows that simple sequence coding repeats are important features of genome diversity among insects.

Flexible object layouts

Programming idioms, design patterns and application libraries often introduce cumbersome and repetitive boilerplate code to a software system. Language extensions and external DSLs (domain specific languages) are sometimes introduced to reduce the need for boilerplate code, but they also complicate the system by introducing the need for language dialects and inter-language mediation. To address this, we propose to extend the structural reflective model of the language with object layouts, layout scopes and slots. Based on the new reflective language model we can 1) provide behavioral hooks to object layouts that are triggered when the fields of an object are accessed and 2) simplify the implementation of state-related language extensions such as stateful traits. By doing this we show how many idiomatic use cases that normally require boilerplate code can be more effectively supported. We present an implementation in Smalltalk, and illustrate its usage through a series of extended examples.

Scrap your nameplate

Recent research has shown how boilerplate code, or repetitive code for traversing datatypes, can be eliminated using generic programming techniques already available within some implementations of Haskell. One particularly intractable kind of boilerplate is nameplate , or code having to do with names, name-binding, and fresh name generation. One reason for the difficulty is that operations on data structures involving names, as usually implemented, are not regular instances of standard map , fold , or zip operations. However, in nominal abstract syntax , an alternative treatment of names and binding based on swapping, operations such as α-equivalence, capture-avoiding substitution, and free variable set functions are much better-behaved.In this paper, we show how nominal abstract syntax techniques similar to those of FreshML can be provided as a Haskell library called FreshLib . In addition, we show how existing genericmprogramming techniques can be used to reduce the amount of nameplate code that needs to be written for new datatypes involving names and binding to almost nothing—in short, how to scrap your nameplate .

Optimum Time Diversity and BCH Codes for DS SS-CDMA CellularMobile Channels

This paper presents the results of optimum diversity and coding of a cellular radio system using spread-spectrum code division multiple-access (SS-CDMA) and binary phase-shift-keying modulation (BPSK). The base-to-mobile link is considered with the mobile at the boundary between cells. Hence, the received signal is subject to Rayleigh or log-normal fading, as well as to interference from neighbouring cells. First, the probability of error for the fading-interference channel is approximated as a simple, closed-form expression, with one-parameter which signifies the degree of channel fading and interference. It is shown that the approximation is quite satisfactory for a wide range of channel fading and interference. Beside avoiding numerical integration, the use of such simplification offers more insight into the nature of the channel. The use of error-correcting codes to enable increasing the system capacity is then investigated. Since employment of either SS or forward-error correction (FEC) techniques results in bandwidth expansion for a communication system using a fixed alphabet size, there exists a trade-off between how much processing gain and how much coding gain the system should employ such that the bit-error rate is minimum. Two types of coding are analysed, viz. repetitive coding and binary BCH codes. For the repetitive code, Chernoff upper-bound is used to approximate the bit-error rate (BER) and the optimum diversity is then found by a simple minimisation. To find the optimum trade-off between code rate k/n and correction capability t of BCH (n,k,t) codes, the first term of the series representing the BER is used as an estimate of the probability of error. Such approximation is shown to yield a nearly exact estimate of the optimum coding parameters, which minimise the BER. Although exact analysis can be used, the present approach yields a general solution, and optimum design parameters can be related to channel conditions. The essence of the results is as follows: (i) fading and interference channel is approximated as a one parameter family; (ii) optimum diversity increases and processing gain decreases, almost linearly, with the increase of interference and fading severity; (iii) optimum BCH code rate is 0.3 over a wide range of fading and interference conditions, and (iv) optimising coding gain and processing gain can provide substantial increase in system capacity.

Remote Insulator Contamination Monitoring System

erful features for the formulation of appropriate abstractions for the desired application. But programming is always easier if a specialized language is already available for the creation of similar applications. Specialized applications should use dedicated computational engines where the developer can build and compose with high level constructs. In addition to defining a new library of functions and overloading existing operators, such an engine must provide a minimal number of portable graphical data visualization and manipulation functions. It is obvious that programming a computational engine from scratch is a major effort. This paper proposes to use a widely used general purpose program available on most popular computer platforms as a computational engine: MATLAB. MATLAB has a large number of built-in functions and constructs covering a wide range of EMTP development needs and is expandable by means of optional toolboxes. The recent implementation of sparse matrix manipulation capabilities eliminates a major feasibility barrier. This paper presents the creation of MatEMTP: a transient analysis program in MATLAB M-files. It is based on a new formulation of the main system of network equations, designed to eliminate several topological data restrictions and capable of handling arbitrary switch interconnections. By programming through matrix and vector operations the MatEMTP code 1s naturally vectorized. To eliminate useless testing, initialization procedures and repetitive dead code executions, the readyto-run structure of Figure 1 is proposed. This data adaptable structure relies on the input processor to interconnect the M-files. The input processor is a separate program that decodes standard EMTP data files and creates the case.m file. This file is a processed file of network data created from the external case data format. The model selector is a set of M-files created by the inputprocessor for connecting required case.m models to the main program. All models are programmed in separate M-files that obey to a set of predefined core code requests. A typical request for a component model is “provide admittance matrix” or “update history”. The creation of any new model is as simple as programming a new M-file which is automatically recognized and inserted into the appropriate code location by the model selector. The organizer is another M-file created by the input processor that calls solution M-files according to selected options and overall solution needs. Thus, MatEMTP is based on a data dependent interconnection of individual code modules.