Fast and Memory-Efficient Neural Code Completion

Integrated Development Environments (IDEs) are pivotal in enhancing productivity with features like code completion in modern software development. Recent advancements in Natural Language Processing (NLP) have empowered neural language models for code completion. In this study, we present an extensive investigation of the impact of open and closed vocabulary systems on the task of code completion. Specifically, we compare open and closed vocabulary systems with various vocabulary sizes to observe their impact on code completion performance. We experiment with three different open vocabulary systems: byte pair encoding (BPE), WordPiece and Unigram to compare them with closed-vocabulary systems to analyze their modeling performance. We also conduct experiments with different context sizes to study their impact on code completion performance. We have experimented using various prominent language models, including one from recurrent neural networks and five from transformers. Our results indicate that vocabulary size significantly impacts modeling performance and can artificially boost the accuracy of code completion models, especially in the case of a closed-vocabulary system. Moreover, we find that different vocabulary systems have varying impacts on token coverage, whereas open-vocabulary systems exhibit better token coverage. Our findings offer valuable insights for building effective code completion models, aiding researchers and practitioners in this field.

In current software development, code completion is necessary to enhance productivity of our programming tasks. However, how developers use code completion tools on integrated development environments is still not elucidated completely. Aiming to improve such tools, we performed an investigation in terms of code completion use. We investigated developers' operation histories on an integrated development environment and found that code completion operations inserting the same text tend to be repetitively performed in a short time period. We also propose new code completion strategies to reduce such repetitive code completion.

Code completion is an important feature in Integrated Development Environments (IDEs). These years, researchers have been making efforts for intelligent code completion. However, existing work on intelligent code completion either only considered production code, or did not distinguish between production code and test code. It is unclear how effective existing completion models are for test code completion, nor whether we can further improve it. In this work, we focus on the completion of test code. We first find through experiments that completion models for production code are suboptimal for test code completion. Then we analyze the specific characteristics of test code, and observe that test code has inter- and intra-project similarities, and a strong relationship with its focal class and other production classes depending on the focal class (i.e., focal-related code). By incorporating test code from other projects to fine-tune existing models, we leverage the inter-project similarity of test code to improve the completion of tokens specific to test code. By introducing a local component and constructing existing test code as well as the focal-related code in the project as references, we enhance existing code completion models with the intra-project similarity and the focal-related code of test code. Experiments show that each characteristic of test code we exploit can bring substantial improvement to test code completion and our integrated framework outperforms other baseline frameworks. Compared to the base completion model, on token-level completion, our optimal model for test code completion relatively improves all-token and identifier completion accuracy by 7.68% and 19.96%, respectively; on line-level completion, it relatively improves edit-distance similarity and exact-match metrics by 8.89% and 22.82%, respectively. Moreover, we perform error analysis and point out potential directions for future work.

Code completion is one of the most useful features in the Integrated Development Environments (IDEs), which can accelerate software development by suggesting the next probable token based on the contextual code in real-time. Recent studies have shown that statistical language modeling techniques can improve the performance of code completion tools through learning from large-scale software repositories. However, these models suffer from two major drawbacks: a) Existing research uses static embeddings, which map a word to the same vector regardless of its context. The differences in the meaning of a token in varying contexts are lost when each token is associated with a single representation; b) Existing language model based code completion models perform poor on completing identifiers, and the type information of the identifiers is ignored in most of these models. To address these challenges, in this paper, we develop a multi-task learning based pre-trained language model for code understanding and code generation with a Transformer-based neural architecture. We pre-train it with hybrid objective functions that incorporate both code understanding and code generation tasks. Then we fine-tune the pre-trained model on code completion. During the completion, our model does not directly predict the next token. Instead, we adopt multi-task learning to predict the token and its type jointly and utilize the predicted type to assist the token prediction. Experiments results on two real-world datasets demonstrate the effectiveness of our model when compared with state-of-the-art methods.

Distributed software development is becoming a common practice among developers. Factors such as the development environments improvement, their extensibility, and the emergence of social networking software are leading factors. They lead the development process (both co-located and geographically distributed) to a practice that: 1) improves the team’s productivity, and 2) encourages and supports the social interaction among the teams’ members. The above factors along with the distributed development emergence, Integrated Development Environments (IDEs) evolution, and the social media advances got the attention of the software development teams, and made them consider how to better assist the social nature of software developers, and the social aspects of software development, including activity awareness of team members’ progress, their presence, collaboration, communication, and coordination around shared artifacts. IDEs are the most commonly used tools by developers and programmers. Integrating the most needed development tools inside the IDE, makes it a Collaborative Development Environment (CDE), and embedding a variety of social software features within a CDE helps support distributed development teams. It also creates a new genera of tools called Social Development Environments or “SDEs” as it is commonly called. This article discusses the origins and development of “SDEs”. It reflects and presents the research into development environments, explaining their role in supporting the communication and coordination needs of development teams. Also, it presents the effect of embedding social network features in such environments. It presents some emerging SDEs and future work. Finally, it concludes by introducing a new model named 5-star that classifies, and helps to evaluate and compare the collaborative tools. 5-star presents a new way to compare and evaluate the SDE systems based on their supported features. It bases the comparison on five major categories including: Communication, Coordination, Collaboration, Awareness & Presence, and Social networking (SN) tools.

Responding to the fact that software systems become more and more complex and mutable, not only the software-standards-related technologies should be adopted, but the environments for software development and evolution should also be flexible and integratable. These facts make software development and maintenance difficult and costly. In this chapter, we first illustrate the activities and studies for software standards, processes, CASE toolsets, and environments. Then, we propose a process and an environment for evolution-oriented software development, called the PRocess and Agent-based Integrated Software development Environment (PRAISE). PRAISE advocates software development with popular software methodologies, and it uses an XML-based mechanism to unify the various paradigms with different standards. It integrates processes, roles, toolsets, and work products to make software development more efficient. With PRAISE, users are encouraged to adopt familiar mechanisms and formal approaches as they wish. PRAISE maintains the consistency of the paradigms so that users do not need to worry about conflicts with other paradigms that are built in or added later. PRAISE meets the need for evolving software development and maintenance.

Responding to the fact that software systems become more and more complex and mutable, not only the software-standards-related technologies should be adopted, but the environments for software development and evolution should also be flexible and integratable. These facts make software development and maintenance difficult and costly. In this chapter, we first illustrate the activities and studies for software standards, processes, CASE toolsets, and environments. Then, we propose a process and an environment for evolution-oriented software development, called the PRocess and Agent-based Integrated Software development Environment (PRAISE). PRAISE advocates software development with popular software methodologies, and it uses an XML-based mechanism to unify the various paradigms with different standards. It integrates processes, roles, toolsets, and work products to make software development more efficient. With PRAISE, users are encouraged to adopt familiar mechanisms and formal approaches as they wish. PRAISE maintains the consistency of the paradigms so that users do not need to worry about conflicts with other paradigms that are built in or added later. PRAISE meets the need for evolving software development and maintenance.

Code completion, one of the most useful features in the Integrated Development Environments (IDEs), can accelerate software development by suggesting the libraries, APIs, and method names in real-time. Recent studies have shown that statistical language models can improve the performance of code completion tools through learning from large-scale software repositories. However, these models suffer from three major drawbacks: a) The hierarchical structural information of the programs is not fully utilized in the program's representation; b) In programs, the semantic relationships can be very long. Existing recurrent neural networks based language models are not sufficient to model the long-term dependency. c) Existing approaches perform a specific task in one model, which leads to the underuse of the information from related tasks. To address these challenges, in this paper, we propose a self-attentional neural architecture for code completion with multi-task learning. To utilize the hierarchical structural information of the programs, we present a novel method that considers the path from the predicting node to the root node. To capture the long-term dependency in the input programs, we adopt a self-attentional architecture based network as the base language model. To enable the knowledge sharing between related tasks, we creatively propose a Multi-Task Learning (MTL) framework to learn two related tasks in code completion jointly. Experiments on three real-world datasets demonstrate the effectiveness of our model when compared with state-of-the-art methods.

Processing, besides being a language of sorts, is an integrated development environment (IDE)—an IDE created by artists for artists. The Processing development environment is simple to learn and use, and doesn’t add to the complexity of learning to program, as with many other IDEs. In fact, the Processing IDE really does substantially simplify the process of coding, even for absolute beginners. Even Flash, which is another very popular IDE of sorts, also geared toward artists, has a steep learning curve, and its complexity can get in the way on pure coding projects. In contrast, the Processing IDE has a well-designed interface and core functionality that allows you to work efficiently; it’s a huge improvement over working in your old text editorKeywordsVirtual MachineProcessing EnvironmentText EditorJava Virtual MachineJava ApplicationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Software is rapidly moving from the desktop to the Web. The Web provides a generic user interface that allows ubiquitous access, instant collaboration, integration with other online services, and avoids installation and configuration on desktop computers. For software development, the Web presents a shift away from developer workstations as a silo, and has the promise of closer collaboration and improved feedback through innovations in Web-based interactive development environments (IDEs). Moving IDEs to the Web is not just a matter of porting desktop IDEs; a fundamental reconsideration of the IDE architecture is necessary in order to realize the full potential that the combination of modern IDEs and the Web can offer. This paper discusses research challenges and opportunities in this area, guided by a pilot study of a web IDE implementation.

Large Language Models (LLMs) have achieved remarkable success in code completion, as evidenced by their essential roles in developing code assistant services such as Copilot. Being trained on in-file contexts, current LLMs are quite effective in completing code for single source files. However, it is challenging for them to conduct repository-level code completion for large software projects that require cross-file information. Existing research on LLM-based repository-level code completion identifies and integrates cross-file contexts, but it suffers from low accuracy and limited context length of LLMs. In this paper, we argue that Integrated Development Environments (IDEs) can provide direct, accurate and real-time cross-file information for repository-level code completion. We propose IDECoder, a practical framework that leverages IDE native static contexts for cross-context construction and diagnosis results for self-refinement. IDECoder utilizes the rich cross-context information available in IDEs to enhance the capabilities of LLMs of repository-level code completion. We conducted preliminary experiments to validate the performance of IDECoder and observed that this synergy represents a promising trend for future exploration.

The ULowell Data Flow Project combines dataflow hardware, dataflow software, and a data flow development environment. The hardware component, a data flow coprocessor card, utilizes seven NEC 7281 Image Pipelined Processors. Each chip models a static dataflow computation and is programmable. The coprocessor was designed and implemented by ULowell personnel and uses an AMIGA 2000 as a host. The software component currently consists of a library of data flow image processing algorithms and an evolving software development environment. Currently the image processing library includes typical imaging operations such as: edge enhancement, filtering, histogramming, and affine transformation. The software development environment (SDE) is depicted in Figure 1. The SDE contains a Data Flow Graph Editor which programmers use to design their data flow code. The data flow algorithm can then be converted directly into NEC data flow assembly code which is then assembled using the ULowell Data Flow Assembler. The assembler differs from NEC's assembler in that it can produce relocatable code. The object code output of the assembler is given to the Data Flow Resource Manager. The resource manager monitors the available resources within the chips. Thus, if a single process does not totally utilize a chip's table space or memory, then a second process may be concurrently loaded onto the same chip. The ability to have multiple data flow processes coexisting within a single chip is unique to the ULowell environment. The data flow resource manager can download and monitor code to either the hardware or to a software simulator/debugger. The simulator/debugger can monitor and trace data flow tokens as they proceed through the chip. Output of the simulator/debugger can be fed back into the data flow graph editior to visually trace token flow through the original program design. The last component of our SDE is a High Level Language translator which can compile programs written in SISAL, a high level language for parallel computation, down to NEC 7281 assembly language. We have already implemented the relocatable assembler, and the data flow resource manager. Prototype versions of the high level translator, simulator/debugger and graph/editor are currently being implemented.

Many Integrated Development Environment (IDE) can be used to create Android Apps. Android Studio with Java programming language is an IDE and native programming language that is officially supported by Google. As a supported IDE, AS becomes the best IDE that can be used to build apps. Nevertheless, many novice programmers find it difficult to get started especially by starting a new programming concept for mobile devices. Android Studio is also known as an IDE that requires a high specs computer requirement and also has sophisticated features. This research purposed to develop applications with IDEs that are more user-friendly and more emphasize the big concept of programming without much difficulty regarding compiling the program code and also the complexity of IDE as well as Android Studio. The IDE used in this study is App Inventor 2 (AI2), a cloud-based IDE managed by the Massachusetts Institute of Technology (MIT). The next goal is to test the capabilities of the application by conducting Blackbox Testing and User Testing. In this research has been developed an app called Receptionist that is used to test the ability of the codes generated by AI2. The results show that AI2 can be used to build complex applications such as Text Message Service (SMS) broadcasting, performing local database queries and retrieving data on the server. However, some features such as database processing should run in the background still run on the UI thread, thereby reducing the user experience when Application Not Responding (ANR) occurs. Keywords: App Inventor 2, Android Application, Cloud Programming, visual programming

Evaluation of integrated software development environments: Challenges and results from three empirical studies

In this paper, we propose the components and an effective integrated development environment (IDE) of an Open software Platform for Robotic Services (OPRoS) that covers from the control of H/W devices to the execution of complicated application programs. Standardized components with data, service, and event ports are offered for developing robot S/W applications easily and efficiently by just combining several components in proper ways. Some design patterns are also provided for general reusable solutions to commonly occurring problems in developing the robot S/W applications. For an all-level development environment, the IDE of the OPRoS supports the development from low-level device controls to high-level contents composition. It turns out that, as a comprehensive platform for robot S/W applications, the proposed OPRoS provides convenient environments for all development steps from editing to execution.