Popular Programming Languages Research Articles

Refining ChatGPT-Generated Code: Characterizing and Mitigating Code Quality Issues

Since its introduction in November 2022, ChatGPT has rapidly gained popularity due to its remarkable ability in language understanding and human-like responses. ChatGPT, based on GPT-3.5 architecture, has shown great promise for revolutionizing various research fields, including code generation. However, the reliability and quality of code generated by ChatGPT remain unexplored, raising concerns about potential risks associated with the widespread use of ChatGPT-driven code generation. In this article, we systematically study the quality of 4,066 ChatGPT-generated programs of code implemented in two popular programming languages, i.e., Java and Python, for 2,033 programming tasks. The goal of this work is threefold. First, we analyze the correctness of ChatGPT on code generation tasks and uncover the factors that influence its effectiveness, including task difficulty, programming language, time that tasks are introduced, and program size. Second, we identify and characterize potential issues with the quality of ChatGPT-generated code. Last, we provide insights into how these issues can be mitigated. Experiments highlight that out of 4,066 programs generated by ChatGPT, 2,756 programs are deemed correct, 1,082 programs provide wrong outputs, and 177 programs contain compilation or runtime errors. Additionally, we further analyze other characteristics of the generated code through static analysis tools, such as code style and maintainability, and find that 1,930 ChatGPT-generated code snippets suffer from maintainability issues. Subsequently, we investigate ChatGPT’s self-repairing ability and its interaction with static analysis tools to fix the errors uncovered in the previous step. Experiments suggest that ChatGPT can partially address these challenges, improving code quality by more than 20%, but there are still limitations and opportunities for improvement. Overall, our study provides valuable insights into the current limitations of ChatGPT and offers a roadmap for future research and development efforts to enhance the code generation capabilities of artificial intelligence models such as ChatGPT.

Python scikit-fuzzy: developing a fuzzy expert system for diabetes diagnosis

Nowadays, improvements in diabetes detection that provide patients with vital information are needed. This is due to the fact that Diabetes mellitus has generated a worldwide epidemic that costs society and people. Also, patients tend to misread symptoms, and clinicians who collect insufficient data may produce erroneous outcomes. Therefore, this study aims to demonstrate that a programme that integrates expert advice such as decisions, recommendations, or solutions is an excellent method for reducing the incidence of diabetes. Specifically, this study intends to implement a fuzzy expert system that can detect and report the early stages of diabetes as a viable approach. Furthermore, since this programme is available to everyone, people may easily self-diagnose themselves if they have a blood glucose monitoring device. However, developing the fuzzy expert system for real-world situations, such as diabetes patients, using any programming tools is not straightforward. Therefore, this study will provide a comprehensive approach to constructing a fuzzy expert system using the popular programming language Python.

Python tools for structural tasks in chemistry.

In recent decades, the use of computational approaches and artificial intelligence in the scientific environment has become more widespread. In this regard, the popular and versatile programming language Python has attracted considerable attention from scientists in the field of chemistry. It is used to solve a variety of chemical and structural problems, including calculating descriptors, molecular fingerprints, graph construction, and computing chemical reaction networks. Python offers high-quality visualization tools for analyzing chemical spaces and compound libraries. This review is a list of tools for the above tasks, including scripts, libraries, ready-made programs, and web interfaces. Inevitably this manuscript does not claim to be an all-encompassing handbook including all the existing Python-based structural chemistry codes. The review serves as a starting point for scientists wishing to apply automatization or optimization to routine chemistry problems.

Finding Cross-Rule Optimization Bugs in Datalog Engines

Datalog is a popular and widely-used declarative logic programming language. Datalog engines apply many cross-rule optimizations; bugs in them can cause incorrect results. To detect such optimization bugs, we propose an automated testing approach called Incremental Rule Evaluation (IRE), which synergistically tackles the test oracle and test case generation problem. The core idea behind the test oracle is to compare the results of an optimized program and a program without cross-rule optimization; any difference indicates a bug in the Datalog engine. Our core insight is that, for an optimized, incrementally-generated Datalog program, we can evaluate all rules individually by constructing a reference program to disable the optimizations that are performed among multiple rules. Incrementally generating test cases not only allows us to apply the test oracle for every new rule generated—we also can ensure that every newly added rule generates a non-empty result with a given probability and eschew recomputing already-known facts. We implemented IRE as a tool named Deopt, and evaluated Deopt on four mature Datalog engines, namely Soufflé, CozoDB, μZ, and DDlog, and discovered a total of 30 bugs. Of these, 13 were logic bugs, while the remaining were crash and error bugs. Deopt can detect all bugs found by queryFuzz, a state-of-the-art approach. Out of the bugs identified by Deopt, queryFuzz might be unable to detect 5. Our incremental test case generation approach is efficient; for example, for test cases containing 60 rules, our incremental approach can produce 1.17× (for DDlog) to 31.02× (for Soufflé) as many valid test cases with non-empty results as the naive random method. We believe that the simplicity and the generality of the approach will lead to its wide adoption in practice.

A class of models for large zero-inflated spatial data

AbstractSpatially correlated data with an excess of zeros, usually referred to as zero-inflated spatial data, arise in many disciplines. Examples include count data, for instance, abundance (or lack thereof) of animal species and disease counts, as well as semi-continuous data like observed precipitation. Spatial two-part models are a flexible class of models for such data. Fitting two-part models can be computationally expensive for large data due to high-dimensional dependent latent variables, costly matrix operations, and slow mixing Markov chains. We describe a flexible, computationally efficient approach for modeling large zero-inflated spatial data using the projection-based intrinsic conditional autoregression (PICAR) framework. We study our approach, which we call PICAR-Z, through extensive simulation studies and two environmental data sets. Our results suggest that PICAR-Z provides accurate predictions while remaining computationally efficient. An important goal of our work is to allow researchers who are not experts in computation to easily build computationally efficient extensions to zero-inflated spatial models; this also allows for a more thorough exploration of modeling choices in two-part models than was previously possible. We show that PICAR-Z is easy to implement and extend in popular probabilistic programming languages such as and .

Distributions for Compositionally Differentiating Parametric Discontinuities

Computations in physical simulation, computer graphics, and probabilistic inference often require the differentiation of discontinuous processes due to contact, occlusion, and changes at a point in time. Popular differentiable programming languages, such as PyTorch and JAX, ignore discontinuities during differentiation. This is incorrect for parametric discontinuities —conditionals containing at least one real-valued parameter and at least one variable of integration. We introduce Potto, the first differentiable first-order programming language to soundly differentiate parametric discontinuities. We present a denotational semantics for programs and program derivatives and show the two accord. We describe the implementation of Potto, which enables separate compilation of programs. Our prototype implementation overcomes previous compile-time bottlenecks achieving an 88.1x and 441.2x speed up in compile time and a 2.5x and 7.9x speed up in runtime, respectively, on two increasingly large image stylization benchmarks. We showcase Potto by implementing a prototype differentiable renderer with separately compiled shaders.

Analysis of Interaction Mechanisms between Java and JavaScript Programming Languages: from LiveConnect to Graal.js

The article is devoted to the study of the mechanisms of interaction between the popular programming languages Java and JavaScript using a retrospective approach. The author consistently examines the development of tools of this kind, starting from LiveConnect technology and Java applets of the mid-1990s and ending with the interpreters of the last decade. Particular attention is paid to comparing the performance of the currently relevant tools Nashorn and Graal.js. The latter is an implementation of the JavaScript language based on the Truffle framework and Context API, which is a Polyglot context for executing all supported guest languages with the Graal JIT compiler, ensuring their optimal performance. The author gives a definition to the term "warm-up", which is recommended by the GraalVM developers to achieve the highest performance. This is a kind of pre-compilation mode, the process of repeated preliminary execution of JavaScript code by the interpreter before its actual usage in order to obtain information about the most frequently utilized fragments of the program, its functions, types and data structures, alongside with their subsequent caching and optimization. The results of testing based on a project from Oracle and the authors application made it possible to verify the results declared by the GraalVM developers and can be used to optimize and improve the performance of multilingual projects using a unified technology stack, as well as when migrating the server code base from Java to JavaScript.

On the use of statistical machine translation for suggesting variable names for decompiled code: The Pharo case

Adequately selecting variable names is a difficult activity for practitioners. In 2018, Jaffe et al. proposed the use of statistical machine translation (SMT) to suggest descriptive variable names for decompiled code. A large corpus of decompiled C code was used to train the SMT model. Our paper presents the results of a partial replication of Jaffe’s experiment. We apply the same technique and methodology to a dataset made of code written in the Pharo programming language. We selected Pharo since its syntax is simple – it fits on half of a postcard – and because the optimizations performed by the compiler are limited to method scope. Our results indicate that SMT may recover between 8.9% and 69.88% of the variable names depending on the training set. Our replication concludes that: (i) the accuracy depends on the code similarity between the training and testing sets; (ii) the simplicity of the Pharo syntax and the satisfactory decompiled code alignment have a positive impact on predicting variable names; and (iii) a relatively small code corpus is sufficient to train the SMT model, which shows the applicability of the approach to less popular programming languages. Additionally, to assess SMT’s potential in improving original variable names, ten Pharo developers reviewed 400 SMT name suggestions, with four reviews per variable. Only 15 suggestions (3.75%) were unanimously viewed as improvements, while 45 (11.25%) were perceived as improvements by at least two reviewers, highlighting SMT’s limitations in providing suitable alternatives.

An Eager Satisfiability Modulo Theories Solver for Algebraic Datatypes

Algebraic data types (ADTs) are a construct classically found in functional programming languages that capture data structures like enumerated types, lists, and trees. In recent years, interest in ADTs has increased. For example, popular programming languages, like Python, have added support for ADTs. Automated reasoning about ADTs can be done using satisfiability modulo theories (SMT) solving, an extension of the Boolean satisfiability problem with first-order logic and associated background theories. Unfortunately, SMT solvers that support ADTs do not scale as state-of-the-art approaches all use variations of the same lazy approach. In this paper, we present an SMT solver that takes a fundamentally different approach, an eager approach. Specifically, our solver reduces ADT queries to a simpler logical theory, uninterpreted functions (UF), and then uses an existing solver on the reduced query. We prove the soundness and completeness of our approach and demonstrate that it outperforms the state of the art on existing benchmarks, as well as a new, more challenging benchmark set from the planning domain.

AdaCCD: Adaptive Semantic Contrasts Discovery Based Cross Lingual Adaptation for Code Clone Detection

Code Clone Detection, which aims to retrieve functionally similar programs from large code bases, has been attracting increasing attention. Modern software often involves a diverse range of programming languages. However, current code clone detection methods are generally limited to only a few popular programming languages due to insufficient annotated data as well as their own model design constraints. To address these issues, we present AdaCCD, a novel cross-lingual adaptation method that can detect cloned codes in a new language without annotations in that language. AdaCCD leverages language-agnostic code representations from pre-trained programming language models and propose an Adaptively Refined Contrastive Learning framework to transfer knowledge from resource-rich languages to resource-poor languages. We evaluate the cross-lingual adaptation results of AdaCCD by constructing a multilingual code clone detection benchmark consisting of 5 programming languages. AdaCCD achieves significant improvements over other baselines, and achieve comparable performance to supervised fine-tuning.

PERFORMANCE EVALUATION OF PYTHON LIBRARIES FOR MULTITHREADING DATA PROCESSING

Topicality. The rapid growth of data in various domains has necessitated the development of efficient tools and libraries for data processing and analysis. Python, a popular programming language for data analysis, offers several libraries, such as NumPy and Numba, for numerical computations. However, there is a lack of comprehensive studies comparing the performance of these libraries across different tasks and data sizes. The aim of the study. This study aims to fill this gap by comparing the performance of Python, NumPy, Numba, and Numba.Cuda across different tasks and data sizes. Additionally, it evaluates the impact of multithreading and GPU utilization on computation speed. Research results. The results indicate that Numba and Numba.Cuda significantly optimizes the performance of Python applications, especially for functions involving loops and array operations. Moreover, GPU and multithreading in Python further enhance computation speed, although with certain limitations and considerations. Conclusion. This study contributes to the field by providing valuable insights into the performance of different Python libraries and the effectiveness of GPU and multithreading in Python, thereby aiding researchers and practitioners in selecting the most suitable tools for their computational needs.

On Detecting and Measuring Exploitable JavaScript Functions in Real-world Applications

JavaScript is often rated as the most popular programming language for the development of both client-side and server-side applications. Because of its popularity, JavaScript has become a frequent target for attackers who exploit vulnerabilities in the source code to take control over the application. To address these JavaScript security issues, such vulnerabilities must be identified first. Existing studies in vulnerable code detection in JavaScript mostly consider package-level vulnerability tracking and measurements. However, such package-level analysis is largely imprecise, as real-world services that include a vulnerable package may not use the vulnerable functions in the package. Moreover, even the inclusion of a vulnerable function may not lead to a security problem if the function cannot be triggered with exploitable inputs. In this article, we develop a vulnerability detection framework that uses vulnerable pattern recognition and textual similarity methods to detect vulnerable functions in real-world JavaScript projects, combined with a static multi-file taint analysis mechanism to further assess the impact of the vulnerabilities on the whole project (i.e., whether the vulnerability can be exploited in a given project). We compose a comprehensive dataset of 1,360 verified vulnerable JavaScript functions using the Snyk vulnerability database and the VulnCode-DB project. From this ground-truth dataset, we build our vulnerable patterns for two common vulnerability types: prototype pollution and Regular Expression Denial of Service (ReDoS). With our framework, we analyze 9,205,654 functions (from 3,000 NPM packages, 1,892 websites and 557 Chrome Web extensions), and detect 117,601 prototype pollution and 7,333 ReDoS vulnerabilities. By further processing all 5,839 findings from NPM packages with our taint analyzer, we verify the exploitability of 290 zero-day cases across 134 NPM packages. In addition, we conduct an in-depth contextual analysis of the findings in 17 popular/critical projects and study the practical security exposure of 20 functions. With our semi-automated vulnerability reporting functionality, we disclosed all verified findings to project owners. We also obtained 25 published CVEs for our findings, 19 of them rated as “Critical” severity and six rated as “High” severity. Additionally, we obtained 169 CVEs that are currently “Reserved” (as of Apr. 2023). As evident from the results, our approach can shift JavaScript vulnerability detection from the coarse package/library level to the function level and thus improve the accuracy of detection and aid timely patching.

Unlocking Societal Recognition and Acceptance: A Case Study of Python

This study employs Python, a high-level programming language, as a case study. By analyzing the inherent characteristics of Python within its social context, this study explores its advantages in meeting social needs, influencing social psychology, and garnering external support. The primary objective of this analysis is to disrupt the established monopoly held by older programming languages such as Java, Rust, and C++. As a result, Python has emerged as the most widely utilized and popular programming language globally. Using Python as a representative example, this study extends its focus to examine the conditions under which products across various societal domains not only gain recognition but also find widespread acceptance and application in the world. Through thorough scrutiny within the demanding landscape of society, the study contends that products meeting such conditions are well-positioned to contribute significantly to societal progress.

CNL2ASP: Converting Controlled Natural Language Sentences into ASP

Abstract Answer set programming (ASP) is a popular declarative programming language for solving hard combinatorial problems. Although ASP has gained widespread acceptance in academic and industrial contexts, there are certain user groups who may find it more advantageous to employ a higher-level language that closely resembles natural language when specifying ASP programs. In this paper, we propose a novel tool, called CNL2ASP, for translating English sentences expressed in a controlled natural language (CNL) form into ASP. In particular, we first provide a definition of the type of sentences allowed by our CNL and their translation as ASP rules and then exemplify the usage of the CNL for the specification of both synthetic and real-world combinatorial problems. Finally, we report the results of an experimental analysis conducted on the real-world problems to compare the performance of automatically generated encodings with the ones written by ASP practitioners, showing that our tool can obtain satisfactory performance on these benchmarks.

Approaches in Using Python for Image Processing

Image processing is an increasingly widespread field in computer science. On the other hand, it is increasingly used both in modern business and in social communication. We will look at image manipulation methods, emphasizing approaches for comparing them. We will offer ways to process images included in popular specialized applications. We emphasize the use of the popular Python programming language, which is becoming more and more popular due to its ease of use and large range of tools. We will look at some of the image processing and analysis libraries used in Python.

Smart contracts and business process automation: the technical aspect

Purpose. To analyze the process of implementing smart contracts for the automation of business processes, aimed at achieving high reliability and cybersecurity during contract execution, optimizing transaction costs, and maximizing the productivity of the enterprise’s internal operations. Methodology. The research results were obtained using special and general methods of scientific knowledge, namely descriptive, comparative, strategic analysis, abstract-logical and generalization. Findings. The study revealed the potential of smart contracts based on blockchain technology to improve business process efficiency, reduce costs, and ensure innovative development in the Ukrainian business environment. Originality. A comprehensive analysis of the technical aspects of using smart contracts based on blockchain technology to automate business processes has been conducted; their impact on the business environment has been assessed; a comparison of popular programming languages and blockchain platforms for the development and deployment of smart contracts has been made; a SWOT-analysis of the implementation of smart contracts at Ukrainian enterprises has been carried out, which opens up prospects for innovative approaches to business practices and their optimization. Practical value. The results of the study can be used to develop and implement innovative strategies in a business environment based on the integration of smart contracts based on blockchain technology in order to improve the efficiency of business processes.

Understanding biochemistry: basic aspects of statistics for life sciences.

If the biological world is one thing it is variable. As scientists we seek to measure, quantify and explain the causes of this variation. The approach we take to this is remarkably similar whether our research is exploring global temperature, blood pressure, cancer incidence or enzyme kinetics. This approach involves defining clear research questions and applying statistical methods to answer them robustly. This article will introduce a practical example that will be used throughout, specifically whether genetic variation can explain variation in coffee consumption. We assume little experience with statistics and walk through the statistical approach that biologists can use, firstly by describing our data with summary statistics and then by using statistical tests to help arrive at answers to our research question. A General Linear Model (GLM) approach will be used as this is what many common statistical tests are. We explore how to visualise and report results, while checking the assumptions of our analysis. The better we can understand and apply statistics to biological problems, the better we can communicate results and future research to others. The popular statistical programming language R will be used throughout.

The Evolution of Computer Programming Languages

This research paper aims to study the progression and evolution of Computer Languages. How have evolved over time and also examines the evidence that newer programming languages are powerful than older ones, take the best of what older languages have to offer, so that older languages weaknesses can be eliminated and add the new strengths. The paper studies the progression of programming languages by examining the features of the most prominent languages and how these features have been adopted by newer languages. Finally, the paper presents a list of languages that may become the most popular programming languages.

COPS: An improved information retrieval-based bug localization technique using context-aware program simplification

Information Retrieval Based Bug Localization (IRBL) techniques are well suited for large-scale software debugging with fewer external dependencies and lower execution costs. However, existing IRBL techniques have several challenges, including localization granularity and applicability. First, existing IRBL techniques have not yet achieved statement-level bug localization. Second, almost all studies are limited to Java-based projects, while their effectiveness for other popular programming languages (e.g., Python) is unknown. The reason for these deficiencies is that existing IRBL techniques mainly rely on conventional NLP techniques to analyze the bug reports and have not yet fully utilized the stack traces attached to the bug reports. To improve the IRBL technique, we propose a context-aware program simplification technique – COPS – that can localize defective statements in suspicious files by analyzing the stack traces in bug reports, enabling statement-level bug localization for Python-based projects. Our experiment is based on 948 bug reports, and the results show that COPS can effectively localize buggy statements. First, compared to the original stack traces, Top@10 is improved by 102.6%, MAP@10 by 56.2%, and MRR@10 by 95.6%. We found that actual buggy code entities are more likely to appear in the first five frames of the stack trace. Second, COPS can achieve equally good localization performance compared to state-of-the-art statement-level bug localization techniques and achieve 92% buggy statement coverage with a full-scope search. Finally, experiments found that the stack trace’s first two-thirds of information is more conducive to localizing buggy statements.

PlotnineSeqSuite: a Python package for visualizing sequence data using ggplot2 style

BackgroundThe visual sequence logo has been a hot area in the development of bioinformatics tools. ggseqlogo written in R language has been the most popular API since it was published. With the popularity of artificial intelligence and deep learning, Python is currently the most popular programming language. The programming language used by bioinformaticians began to shift to Python. Providing APIs in Python that are similar to those in R can reduce the learning cost of relearning a programming language. And compared to ggplot2 in R, drawing framework is not as easy to use in Python. The appearance of plotnine (ggplot2 in Python version) makes it possible to unify the programming methods of bioinformatics visualization tools between R and Python.ResultsHere, we introduce plotnineSeqSuite, a new plotnine-based Python package provides a ggseqlogo-like API for programmatic drawing of sequence logos, sequence alignment diagrams and sequence histograms. To be more precise, it supports custom letters, color themes, and fonts. Moreover, the class for drawing layers is based on object-oriented design so that users can easily encapsulate and extend it.ConclusionsplotnineSeqSuite is the first ggplot2-style package to implement visualization of sequence -related graphs in Python. It enhances the uniformity of programmatic plotting between R and Python. Compared with tools appeared already, the categories supported by plotnineSeqSuite are much more complete. The source code of plotnineSeqSuite can be obtained on GitHub (https://github.com/caotianze/plotnineseqsuite) and PyPI (https://pypi.org/project/plotnineseqsuite), and the documentation homepage is freely available on GitHub at (https://caotianze.github.io/plotnineseqsuite/).