Multiple Programmers Research Articles

Real-Time Collaborative Programming in Undergraduate Education: A Comprehensive Empirical Analysis of Its Impact on Knowledge, Behaviors, and Attitudes

Real-time collaborative programming (RCP), which allows multiple programmers to work concurrently on the same codebase with changes instantly visible to all participants, has garnered considerable popularity in higher education. Despite this trend, little work has rigorously examined how undergraduates engage in collaborative programming when using RCP. This study utilized a quasi-experimental design to investigate the impact of RCP on undergraduates’ programming knowledge and skills, behaviors, and attitudes toward collaboration. Eighty-two participants were randomly assigned to either the RCP group or the Traditional Collaborative Programming (TCP) group. The data analysis yielded noteworthy findings. First, RCP significantly improved learners’ problem-solving skills and led to higher knowledge test scores compared to TCP. Second, there were no significant differences in attitudes toward collaboration between the two groups. Third, analysis of programming behaviors indicated that the RCP group exhibited more efficient coding practices, including producing a greater volume of code and executing it more successfully. Additionally, the RCP group’s code-testing activities were predominantly concentrated at the first half of the class sessions. Based on the empirical research results, three major pedagogical implications were proposed. These findings highlight the benefits of integrating RCP into programming education and suggest avenues for future research into collaborative learning dynamics.

DeepMerge: Learning to Merge Programs

In collaborative software development, program merging is <i>the</i> mechanism to integrate changes from multiple programmers. Merge algorithms in modern version control systems report a conflict when changes interfere textually. Merge conflicts require manual intervention and frequently stall modern continuous integration pipelines. Prior work found that, although costly, a large majority of resolutions involve re-arranging text without writing any new code. Inspired by this observation we propose the <i>first data-driven approach</i> to resolve merge conflicts with a machine learning model. We realize our approach in a tool DEEPMERGE that uses a novel combination of (i) an edit-aware embedding of merge inputs and (ii) a variation of pointer networks, to construct resolutions from input segments. We also propose an algorithm to localize manual resolutions in a resolved file and employ it to curate a ground-truth dataset comprising 8,719 non-trivial resolutions in JavaScript programs. Our evaluation shows that, on a held out test set, DEEPMERGE can predict correct resolutions for 37&#x0025; of non-trivial merges, compared to only 4&#x0025; by a state-of-the-art semistructured merge technique. Furthermore, on the subset of merges with upto 3 lines (comprising 24&#x0025; of the total dataset), DEEPMERGE can predict correct resolutions with 78&#x0025; accuracy.

Integrating Real-Time and Non-Real-Time Collaborative Programming

Real-time collaborative programming enables a group of programmers to edit shared source code at the same time, which significantly complements the traditional non-real-time collaborative programming supported by version control systems. However, one critical issue with this emerging technique is the lack of integration with non-real-time collaboration. Specifically, contributions from multiple programmers in a real-time collaboration session cannot be distinguished and accurately recorded in the version control system. In this study, we propose a scheme that integrates real-time and non-real-time collaborative programming with a novel workflow, and contribute enabling techniques to realize such integration. As a proof-of-concept, we have successfully implemented two prototype systems named CoEclipse and CoIDEA, which allow programmers to closely collaborate in a real-time fashion while preserving the work's compatibility with traditional non-real-time collaboration. User evaluation and performance experiments have confirmed the feasibility of the approach and techniques, demonstrated the good system performance, and presented the satisfactory usability of the prototypes.

PERSONA: A personalized model for code recommendation.

Code recommendation is an important feature of modern software development tools to improve the productivity of programmers. The current advanced techniques in code recommendation mostly focus on the crowd-based approach. The basic idea is to collect a large pool of available source code, extract the common code patterns, and utilize the patterns for recommendations. However, programmers are different in multiple aspects including coding preferences, styles, levels of experience, and knowledge about libraries and frameworks. These differences lead to various usages of code elements. When the code of multiple programmers is combined and mined, such differences are disappeared, which could limit the accuracy of the code recommendation tool for a specific programmer. In the paper, we develop a code recommendation technique that focuses on the personal coding patterns of programmers. We propose Persona, a personalized code recommendation model. It learns personalized code patterns for each programmer based on their coding history, while also combines with project-specific and common code patterns. Persona supports recommending code elements including variable names, class names, methods, and parameters. The empirical evaluation suggests that our recommendation tool based on Persona is highly effective. It recommends the next identifier with top-1 accuracy of 60-65% and outperforms the baseline approaches.

Envisioning an Intelligent Collaborative Integrated Development Environment

Abstract Programming editors have evolved over the years. However, we still lack an environment that can allow on-the-fly collaboration between multiple programmers. We envision Incide, an integrated development environment that allows a synergistic collaboration environment by using program synthesis technology to combine partial solutions from multiple programmers attempting to solve the (same) problem into one concrete solution. This solution is then communicated to the editor of each programmer as patches along with personalization on syntactic elements like choice of programming language constructs and variable names. We believe that such editors will improve productivity on complex solutions by bringing a discipline into combining the intuition and intellect of multiple programmers.

Modular programming for tuberculosis control, the \u201cAuTuMN\u201d platform

BackgroundTuberculosis (TB) is now the world’s leading infectious killer and major programmatic advances will be needed if we are to meet the ambitious new End TB Targets. Although mathematical models are powerful tools for TB control, such models must be flexible enough to capture the complexity and heterogeneity of the global TB epidemic. This includes simulating a disease that affects age groups and other risk groups differently, has varying levels of infectiousness depending upon the organ involved and varying outcomes from treatment depending on the drug resistance pattern of the infecting strain.ResultsWe adopted sound basic principles of software engineering to develop a modular software platform for simulation of TB control interventions (“AuTuMN”). These included object-oriented programming, logical linkage between modules and consistency of code syntax and variable naming. The underlying transmission dynamic model incorporates optional stratification by age, risk group, strain and organ involvement, while our approach to simulating time-variant programmatic parameters better captures the historical progression of the epidemic. An economic model is overlaid upon this epidemiological model which facilitates comparison between new and existing technologies. A “Model runner” module allows for predictions of future disease burden trajectories under alternative scenario situations, as well as uncertainty, automatic calibration, cost-effectiveness and optimisation. The model has now been used to guide TB control strategies across a range of settings and countries, with our modular approach enabling repeated application of the tool without the need for extensive modification for each application.ConclusionsThe modular construction of the platform minimises errors, enhances readability and collaboration between multiple programmers and enables rapid adaptation to answer questions in a broad range of contexts without the need for extensive re-programming. Such features are particularly important in simulating an epidemic as complex and diverse as TB.

Supporting semantic conflict prevention in real-time collaborative programming environments

Real-time collaborative programming environments support multiple programmers to concurrently edit shared source code documents at the same time over communication networks. One of the key challenges in supporting real-time collaborative programming is semantic conflicts, which may occur when multiple programmers are performing concurrent and incompatible programming work in the same source code region or in different source code regions with dependency relationships. Semantic conflicts may result in programming errors that are difficult to detect and costly to resolve. This paper presents in-depth analyses of representative collaborative programming scenarios for understanding the nature and general conditions of semantic conflicts, and proposes a novelDependency-based Automatic Locking(DAL) approach for supporting semantic conflict prevention in real-time collaborative programming environments. The novelty of the DAL approach lies in its capabilities of supporting automatic and fine-grained locking on selected source code regions with dependency relationships to balance conflict prevention, concurrent work, and programmer convenience in real-time collaborative programming. The DAL approach and technical solutions have been implemented in theCoEclipseprototype system as a proof-of-concept for this emerging technique, which is being continuously extended for further exploration and evaluation.

Protecting the process [source code management

The author mentions that building software using a team of multiple programmers working from different time zones brings production efficiencies, but managing the source code effectively is essential. Mention source code management (SCM) to most developers, and there is the strong possibility that they will think about version control of individual source-code files. At its most basic, version control is a method of maintaining separate versions of files, rather than simply overwriting the old ones.The most up-to-date SCM systems offer developers and project managers a way of implementing an efficient and productive workflow: they go beyond simple version control they can streamline project management.

Electromagnetic interaction between an axial left ventricular assist device and an implantable cardioverter defibrillator

Electromagnetic interaction between an axial left ventricular assist device and an implantable cardioverter defibrillator

Development of decision support tools for aquaculture: the POND experience

Decision support systems (DSS) are potentially valuable tools for assessing the economic and ecological impacts of alternative decisions on aquaculture production. In this paper, we discuss the philosophy of design, functional modules and application areas of POND, a decision tool that has been developed to allow analysis of pond aquaculture facilities by the use of a combination of simulation models and enterprise budgeting. We focus less on the details of POND’s internal models, and more on the experiences we have gained from going through the process of the designing, developing and using the POND software. POND was designed and implemented using object-oriented programming principles. The software makes use of a simulation framework to provide much of the generic simulation, data handling, time flow synchronization and communication features necessary for complex model-based DSSs. Additionally, an architecture suitable for representing and manipulating pond aquaculture facilities was developed in order to meet the design specifications of POND. This architecture includes a series of mini-databases, a number of knowledge-based components (‘experts’), models of the pond ecosystem, and various decision support features (e.g. assembling alternate management scenarios, economic analysis, and data visualization). A typical POND simulation consists of assembling a number of appropriate objects or entities (e.g. multiple ponds and fish lots), their management settings together with appropriate experts (e.g. an aquaculture engineer, an aquatic biologist, an economist, etc.), and projecting changes in the facility over time. Our experience with the development of POND and other simulation-based tools indicates that the object-based approach provides a robust foundation for developing tools which allow code reusability, facilitate maintenance of complex software, and enable partition of program development among multiple programmers. Experience gained with POND users suggests that there are largely two groups of aquaculture personnel interested in such applications, namely commercial growers and educators. These two groups have substantially different interests and needs. Consequently, a single tool such as POND may not optimally meet the requirements of both groups. Recent development work on POND, and the need to involve users in the design process of such tools are discussed.

AN OBJECT-BASED ENVIRONMENT (OPUSDEI) FOR SOFTWARE DEVELOPMENT AND MAINTENANCE

This paper discusses an object-based software development and maintenance environment, Opusdei, built and used for several years at Hitachi Software Engineering (HSK - Since 1994, University of Minnesota has been involved in the Opusdei project.) Industrial software is usually large, has many versions, undergoes frequent changes, and is developed concurrently by multiple programmers. Opusdei was designed to handle various problems inherent in such industrial environments. In Opusdei, all information needed for development is stored using an uniform representation in a central repository, and the various documentation and views of the software artifacts can be generated automatically using the tool repository. Opusdeis’ innovative capabilities are 1) uniform software artifacts representation 2) inter-relation and traceability maintenance among software artifacts 3) tools coordination and tool integration using tool composition scenarios 4) automatic documentation and versioning control. Tool coordination and composition has been discussed in the literature as a possible way to make software development environments more intelligent. Opusdei provides a uniform representation of software artifacts and tools which is an essential first step in addressing the issues of tool coordination and composition. Opusdei has been operational for several years and has been used in many large software development projects. The productivity gain reported for some of these projects, by using Opusdei ranged from 50–90%.

Conflict management in a source version management system

To support concurrent development a source version management system must support multiple programmers concurrently accessing shared source code, while maintaining the integrity of the source database. This problem is similar to the problem of concurrency control in database systems, but has a few significant differences. This leads us to view the possible solutions as variations on database transaction management and concurrency control. In particular we consider the possibility of letting transactions interact and managing the conflicts which result. 1

Programming in the large

It is asserted that ad-hoc programming techniques do not work in the development of big software systems. The programs faced in developing large software include starting from fuzzy and incomplete requirements; enforcing a methodology on the developers; coordinating multiple programmers and managers; achieving desired reliability and performance in the system; managing a multitude of resources in a meaningful way; and completing the system within a limited time frame. The authors examine some of the trends in requirement specification; life cycle modeling; programming environments; design tools; and other software engineering areas for tackling the above problems. The authors suggest several phase-independent and phase-dependent techniques for programming in the large. It is shown how research in automatic programming, knowledge-based systems, metrics, and programming environments can make a significant difference in the ability to develop large systems.

A Software Development System for Reliable Applications

This paper describes a Software Development System (SDS) that was implemented at Bell Laboratories to support the development of software for Electronic Switching Systems (ESS). The SDS supports multiple programmers and multiple releases. It permits incremental development in a timely and efficient manner while maintaining project management control and tracking capabilities. Software testing and debugging tools are also provided. The SDS was implemented and is currently being used to support the development and maintenance of software used in the No. 2B and No. 3 ESS manufactured by Western Electric for the Bell System. There are approximately 500 of these systems currently serving telephone subscribers. This paper describes the SDS implementation for the No. 2B ESS, and discusses some of the user and project experiences.