Python Interpreter Research Articles

Evaluation of Programming in C using WSM Method

Programming in C. The machine-oriented programming language C is mostly used to create many applications and operating systems, like Windows, as well as other complicated programmers, such the Oracle database, Kit, the Python interpreter, and games. Computer programmers and low-level programming applications are often written in the procedural or structured programming language C. Concatenation, data hiding, data compression, inheritance, and polymorphism are some extra aspects of C++ despite the fact that it is an object-oriented programming language. Multiple entities of the same type can be grouped together into a larger group using the C concept of an array. These entities or components may be user-defined data types or structures, such as integer, float, double, or float data types. C-written programmers compile and execute far more quickly than those written in other languages. This is because there are no additional processing overheads like garbage collection. As a result, when compared to other programming languages, the language is quick. An algorithm is a series of actions carried out in a preset order to address a challenge or finish a task. A function is a section of code that is called and carried out by other software elements. An operating system is made using it. The "C" programming language is used to create operating systems like Apple's OS X, Microsoft's Windows, and Symbian. It is utilized to create platforms for desktop and mobile devices. It is used to create compilers. One C feature that contains symbols for doing mathematical, relational, bitwise, conditional, or logical manipulations is the C operator. There are many built-in operators in the C programming language that can be used to carry out different tasks as needed by the application. C has an advantage over other dynamic languages since it is a statically typed programming language. Also, C is a compiler-based programming language, in contrast to Python and Java, which are interpreter-based. It expedites the compilation and execution of code. Weighted Sum works by multiplying the designated field values Indian Technical Institution or appraising the alternatives Analysis in Simply types, Enum types, Struct types, Nullable types. Evaluation parameters in Class types, Interface types, Array types, and Delegate types. Simply types, Enum types, Struct types, Nullable types. Class types, Interface types, Array types, and Delegate types. Nullable types got the first rank whereas Simply types have the lowest rank.

Enumerating Valid Non-Alpha-Equivalent Programs for Interpreter Testing

Skeletal program enumeration (SPE) can generate a great number of test programs for validating the correctness of compilers or interpreters. The classic SPE generates programs by exhaustively enumerating all possible variable usage patterns into a given syntactic structure. Even though it is capable of producing many test programs, the exhaustive enumeration strategy generates a large number of invalid programs, which may waste plenty of testing time and resources. To address the problem, this article proposes a tree-based SPE technique. Compared to the state-of-the-art, the key merit of the tree-based approach is that it allows us to take the dependency information into consideration when producing test programs and, thus, make it possible to (1) directly generate non-equivalent programs and (2) apply dominance relations to eliminate invalid test programs that have undefined variables. Hence, our approach significantly saves the cost of the naïve SPE approach. We have implemented our approach into an automated testing tool, IFuzzer , and applied it to test eight different implementations of Python interpreters, including CPython, PyPy, IronPython, Jython, RustPython, GPython, Pyston, and Codon. In three months of fuzzing, IFuzzer detected 142 bugs, of which 87 have been confirmed to be previously unknown bugs, of which 34 have been fixed. Compared to the state-of-the-art SPE techniques, IFuzzer takes only 61.0% of the time cost given the same number of testing seeds and improves 5.3% source code function coverage in the same time budget of testing.

Python source code Analysis for Bug Detection using Transformers

Effective bug detection is pivotal in software development, with the identification and localization of defects being crucial for robust applications. In Python-based programs, the conventional bug detection process relies on a Python interpreter, causing workflow interruptions due to sequential error detection. As Python's adoption surges, the demand for efficient bug detection tools intensifies. This paper addresses the challenges associated with bug detection in Python, focusing on the prevalence of built-in type bugs that can lead to code crashes. Building on recent advancements, this survey explores bug detection methodologies across programming languages, emphasizing Python, JavaScript, and C. The diverse array of techniques covered includes static and dynamic analyses, machine learning-based bug detection, and predictive analysis engines(specifically deep-learning based). The survey provides insights into bug detection in Python programs, offering perspectives on addressing built-in type bugs and optimizing tools within the language's constraints.

Feasibility Study for a Python-Based Embedded Real-Time Control System

Because of its simplicity and the support of numerous useful libraries, Python has become one of the most popular programming languages for application development, even in embedded systems. However, in existing control systems where specific tasks must meet specific temporal deadlines and support schedulability with proper priority assignments, the Python interpreter may not satisfy real-time requirements, owing to features such as the global interpreter lock and garbage collector. This paper addresses these constraints with an approach that executes periodic real-time tasks under the fixed-priority preemptible scheduler of RT-Preempt. First, we implemented a Python real-time module that allows users to create and execute periodic tasks with fixed priorities based on Python. Then, we conducted experiments on an open embedded system, in this case, a Raspberry Pi 4. We evaluated the real-time performance, focusing on test metrics for control systems, such as task periodicity, responsiveness, and interrupt response. The results were then compared to those of conventional real-time tasks developed using the C language to validate the feasibility of the proposed method. Finally, we performed experimental validation by tracking the position of EtherCAT servo motors to demonstrate the feasibility of a Python-based real-time control system in a practical application.

Synthesis of nested loop exercises for practice in introductory programming

Novice programmers struggle to comprehend specific programming constructs such as arrays, recursion, and loops. One way to address this challenge is to provide practice problems for students in these topics that are considered difficult to comprehend — such as nested loops. It is proven that practice aids program comprehension, hence, since it is time consuming to manually create many practice problems; synthesising these problems is an Expert Artificial Intelligence Task that is worth investigating. In this paper we present the synthesis of nested loop exercises in Python for practice using a context-free grammar. We defined the grammar rules for modeling program templates. Algorithms were designed and implemented for the generation of structurally different nested loop exercises based on the defined production rules of the context-free grammar. Each program generated consists of two or more looping statements, with a nesting, and the context-free grammar rules also allow for the spawning of infinitely many sub-loops for every loop. We checked for the correctness of the synthesised nested loop programs with an experimental procedure of iteratively supplying these programs to the Python interpreter. The first 120,000 iterations returned no syntactic bugs, hence, showing that these programs do compile and have outputs. Furthermore, an evaluation of the programs was carried out in a survey with 210 participants (novice and expert programmers). The results of the evaluation show that over 82% of the participants agreed that the synthesised exercises were correctly generated, solvable and can be used as practice exercises for novice programmers in introductory programming modules. 120,000 iterations of synthesised loop programs can be found at: https://tinyurl.com/nestedloops2021.

PyC2MC: An Open-Source Software Solution for Visualization and Treatment of High-Resolution Mass Spectrometry Data.

Complex molecular mixtures are encountered in almost all research disciplines, such as biomedical 'omics, petroleomics, and environmental sciences. State-of-the-art characterization of sample materials related to these fields, deploying high-end instrumentation, allows for gathering large quantities of molecular composition data. One established technological platform is ultrahigh-resolution mass spectrometry, e.g., Fourier-transform mass spectrometry (FT-MS). However, the huge amounts of data acquired in FT-MS often result in tedious data treatment and visualization. FT-MS analysis of complex matrices can easily lead to single mass spectra with more than 10,000 attributed unique molecular formulas. Sophisticated software solutions to conduct these treatment and visualization attempts from commercial and noncommercial origins exist. However, existing applications have distinct drawbacks, such as focusing on only one type of graphic representation, being unable to handle large data sets, or not being publicly available. In this respect, we developed a software, within the international complex matrices molecular characterization joint lab (IC2MC), named "python tools for complex matrices molecular characterization" (PyC2MC). This piece of software will be open-source and free to use. PyC2MC is written under python 3.9.7 and relies on well-known libraries such as pandas, NumPy, or SciPy. It is provided with a graphical user interface developed under PyQt5. The two options for execution, (1) a user-friendly route with a prepacked executable file or (2) running the main python script through a Python interpreter, ensure a high applicability but also an open characteristic for further development by the community. Both are available on the GitHub platform (https://github.com/iC2MC/PyC2MC_viewer).

Artificial neural network model for automatic code generation in graphical interface applications

Introduction: Currently, the software development industry is living in its golden age due to the progress in areas related to machine learning, which is part of AI techniques. These advances have allowed tasks considered exclusively human to be solved using a computer. However, the complexity and the extensive area covered by new projects that must be developed using programming languages have slowed down project delivery times and affected the company's productivity. Objective: This research presents the methodology carried out for constructing a recurrent neural network model for the automatic generation of source code related to graphical user interfaces using Python programming language. Method: By constructing a natural language-related dataset for describing graphical interfaces programmed in Python, a deep neural network model is built to generate automatic source code. Results: The trained model achieves loss and perplexity values of 1.57 and 4.82, respectively, in the validation stage, avoiding overfitting in the model's training. Conclusions: A neural network model is trained to process the natural language related to the request to create graphical interfaces using the Python programming language to automatically generate source code that can be executed through the Python interpreter.

Comparison of the Sentiment Analysis Model's Code Complexity and Processing Time

Text processing, which includes sentiment analysis, obviously demands a lot of resources. The extent to which resources are used to promote environmental conservation is directly impacted by code complexity or computational time. Twitter users' responses on the Indonesian Language of religious moderation and tolerance are used to test the model. The phases of doing the research include determining the research's needs, gathering data, text preprocessing (case folding, tokenizing, stopword removal, and stemming), word weighting with TF/IDF, and classification with Multinomial Naive Bayes (MNB) and Support Vector Machine (SVM), validation, and the last step was calculation of the code complexity and computation time. The validation results showed that the performance of the two models was still low, with an average accuracy of 75.5%. Based on computation time, SVM has a faster computational time than MNB. However, when compared in terms of the code complexity, the Cyclomatic Complexity in both models was the same because both models used existing libraries in Python Interpreter, and the complexity of the libraries cannot be calculated directly. Based on the Raw Metrics, it can be seen that MNB and SVM not significantly different in LOC, LLOC, and SLOC. It was evident that SVM has a greater Halstead Complexity than SVM in all measures when comparing the program code of MNB and SVM. Particularly on programming effort and volume metrics, SVM required more bits to run than an MNB program, and it also required more mental effort to convert a prepared SVM algorithm into a program than an MNB.

RegCPython: A Register-based Python Interpreter for Better Performance

Interpreters are widely used in the implementation of many programming languages, such as Python, Perl, and Java. Even though various JIT compilers emerge in an endless stream, interpretation efficiency still plays a critical role in program performance. Does a stack-based interpreter or a register-based interpreter perform better? The pros and cons of the pair of architectures have long been discussed. The stack architecture is attractive for its concise model and compact bytecode, but our study finds that the register-based interpreter can also be implemented easily and that its bytecode size only grows by a small margin. Moreover, the latter turns out to be appreciably faster. Specifically, we implemented an open source Python interpreter named RegCPython based on CPython v3.10.1. The former is register based, while the latter is stack based. Without changes in syntax, Application Programming Interface, and Application Binary Interface, RegCPython is excellently compatible with CPython, as it does not break existing syntax or interfaces. It achieves a speedup of 1.287 on the most favorable benchmark and 0.977 even on the most unfavorable benchmark. For all Python-intensive benchmarks, the average speedup reaches 1.120 on x86 and 1.130 on ARM. Our evaluation work, which also serves as an empirical study, provides a detailed performance survey of both interpreters on modern hardware. It points out that the register-based interpreters are more efficient mainly due to the elimination of machine instructions needed, while changes in branch mispredictions and cache misses have a limited impact on performance. Additionally, it confirms that the register-based implementation is also satisfactory in terms of memory footprint, compilation cost, and implementation complexity.

A General Approach for Running Python Codes in OpenFOAM Using an Embedded PYBIND11 Python Interpreter

As the overlap between traditional computational mechanics and machine learning grows, there is an increasing demand for straight-forward approaches to interface Python-based procedures with C++-based OpenFOAM. This article introduces one such general methodology, allowing the execution of Python code directly within an OpenFOAM solver without the need for Python code translation. The proposed approach is based on the lightweight library pybind11, where OpenFOAM data is transferred to an embedded Python interpreter for manipulation, and results are returned as needed. Following a review of related approaches, the article describes the approach, with a particular focus on data transfer between Python and OpenFOAM, executing Python scripts and functions, and practical details about the implementation in OpenFOAM. Three complementary test cases are presented to highlight the functionality and demonstrate the effect of different data transfer approaches: a Python-based velocity profile boundary condition; a Python-based solver for prototyping; and a machine learning mechanical constitutive law class for solids4foam which performs field calculations.

PyExaFMM: An Exercise in Designing High-Performance Software With Python and Numba

Numba is a game-changing compiler for high-performance computing with Python. It produces machine code that runs outside of the single-threaded Python interpreter and that fully utilizes the resources of modern CPUs. This means support for parallel multithreading and auto vectorization if available, as with compiled languages such as C++ or Fortran. In this article we document our experience developing PyExaFMM, a multithreaded Numba implementation of the Fast Multipole Method, an algorithm with a non-linear data structure and a large amount of data organization. We find that designing performant Numba code for complex algorithms can be as challenging as writing in a compiled language.

An Empirical Study on Bugs in Python Interpreters

Python is an interpreted programming language that has been widely used in many fields. The successful execution of a Python program depends on both the correctness of Python program and the correctness of Python interpreter. As an infrastructure software, there are many bugs in the Python interpreter. Exploring the bugs in Python interpreters can help developers and maintainers of Python interpreters detect and fix bugs and help users of Python avoid risks. In this article, we conduct an empirical study on the bugs in two mainstream Python interpreters: CPython and PyPy. By analyzing 25 958 fixed bugs, 18 824 revisions, 2 116 test cases, and root causes of randomly sampled 510 bugs, we have summarized the following findings. <list list-type="ordered" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><list-item><label>1)</label> The distribution of bugs in the Python interpreter is so uneven that the vast majority of bugs are distributed in a few components and source files. </list-item> <list-item><label>2)</label> The scales of the testing programs that reveal bugs are small. </list-item> <list-item><label>3)</label> The fixing works seem to be not complicated since the number of modified source files and lines of code are limited; however, most bugs need a long time to be fixed; nearly 15% of the bugs need more than one year to fix. </list-item> <list-item><label>4)</label> The priorities of bugs are independent of their locations, but they significantly correlate with duration of bugs. </list-item> <list-item><label>5)</label> Semantic bugs are the most frequent root causes of bugs, and their proportion exceeds other types of root causes. </list-item> </list> These results could indicate some potential problems during the detecting and fixing of Python interpreter’s bugs, and provide some assistance to developers and maintainers of Python interpreters, users of Python, as well as researchers in related fields.

Quantifying the interpretation overhead of Python

• Quantitative overhead analysis for the Python interpreter based on sampling. • Overhead decomposition from both opcode and project composition perspectives. • Investigation on the specific performance-affecting issues of the interpreter. • Suggestions for future efficiency optimization work. While Python has become increasingly popular for its convenience, it is also criticized for its suboptimal performance. To figure out what burdens the interpreter of Python and provide insights into possible optimizations, we conduct this empirical study on CPython's performance via sampling-based profiling. This sampling-based approach incurs a low runtime overhead and does not require any modification of the interpreter and the application code, thus providing convincing experimental results. Specifically, we use 48 benchmarks from the pyperformance project to analyze the runtime overhead of the interpreter. We compare the usage of different opcodes and decompose the overhead at various granularities (e.g., files, functions, and statements). It turns out that most parts contribute a small portion of the overhead, and the promising improvements lie in the minority, such as name access opcodes and reference counting functions. Furthermore, we pay attention to four specific performance-affecting issues: name access, dynamic typing, garbage collection, and opcode dispatch. The issue study reveals several promising optimization techniques, such as register-based virtual machine architecture and tracing-based garbage collection, as well as a few fruitless optimization points, such as operator overloading and dispatch.

Conceptual Design of Python IDE with Embedded Turkish Spoken Chatbot that Analyzes and Corrects the Syntax Errors

Intelligent agents, in addition to act as a cognitive tool, they can also to be designed as learning agents. In this way, they can learn the user's behavior from users' past behaviors. Learning agents can analyze the user's / student's behavior to a task, build a database of past activities, and suggest better strategies. This study provides a detailed review of interactive guidance using intelligent agents, and then introduces a concept model for a Conversation-based Turkish Python Integrated development environment (IDE) that can analyze user syntax errors and help them to correct errors. The model proposed in this study consists of three layers. These are user interface layer, middle layer, and Python interpreter layers. User interface layer consists of code editor and chatbot components. Middle layer includes code structural control subsystem, code error manager, and intelligent agent subsystems. The code structural control module analyzes conditions, loops, branching, and other types of program flow controls in the user's code. The code error manager analyzes the error outputs of the user code which is generated by the Python interpreter. The intelligent learner, on the other hand, uses these inferences to understand the reason for the student's error and convey the necessary actions to the user by the help of chatbot and suggest possible corrections. The proposed Integrated development environment (IDE) has a well-designed UI that can be easily adapted by newcomers. The coding editor can be used as a stand-alone desktop software, or it can also connect to a cloud storage to store user codes in the cloud. A web application is also planned for our proposed IDE. The teacher will be able to assign homework to the student over the web. The student will be able to view these assignments on the web, do the assignments in the desktop editor and send them back to the teacher over the web. In addition, each user’s error characteristics will be analyzed, the success of the learning will be measured, and the deficiencies of the students will be determined using the Intelligent Agent Subsystem.

Applying Python’s Time Series Forecasting Method in Microsoft Excel – Integration as a Business Process Supporting Tool for Small Enterprises

The paper describes the current state of research, where integration of Microsoft Excel and Python interpreter, gives the business user the right tool to solve chosen business process analysis problems like: forecasting, classification or clustering. The integration is done by using Visual Basic for Application (VBA), as well as XLWings Python’s library. Both mechanisms serve as an interfaces between MS Excel and Python to allow the data exchange between each other. Creating the suitable Graphical User Interface (GUI) in Microsoft Excel, gives the business user opportunity to select specific data analysis method available in Python’s environment and set its parameters, without Python’s programming. Running the method by Python’s interpreter can bring the results, which are hard or even impossible to obtain by using Microsoft Excel only. However, the data analysis methods stored in the Python’s script, which are available to the business user, as well as VBA source code, must be designed and implemented by the data scientist. Sample, basic integration between Microsoft Excel and Python’s interpreter is presented in the paper. To present value-added of the proposed software solution, simple case study according to time series forecasting problem is described, where forecasting errors of different methods available in the Microsoft Excel and Python are presented and discussed. The paper ends with conclusions according to the results of the current researches and suggested directions of further research.

DJMol: An open-source modeling platform for computational chemistry and materials science with a Python interpreter.

We present a modular and extendable software suite, DJMol, for performing molecular simulations and it is demonstrated with DFTB+, Siesta, Atomic Simulation Environment, and OpenMD codes. It supports many of the standard features of an integrated development environment and consists of a structure builder and viewer, which could be connected with these electronic structure codes along with a set of data analyzers. This program comprises Java and Python modules and its libraries to carry out a different set of modeling tasks in materials science and chemistry. By adopting a Python interpreter into the software, a range of scriptable Python codes, such as Pymatgen can be incorporated into this programmable modeling platform. DJMol, through its common application programming interface (API), supports multiple modeling codes in the backend and several post-processing tools. It benefits an experienced user by increasing efficiency, while a nonexpert user by easy to use API.

АНГЛОМОВНИЙ БАЗИС МОВИ ПРОГРАМУВАННЯ PYTHON

The dynamic nature of the Python programming language, the accumulation of a certain linguosemiotic basis indicates the similarity of this language with the English language, which is the international one and mediates human communication in both real and virtual worlds. In this study, the English language is positioned as the linguistic basis of Python language of programming, which is widely used in industry, research, natural language processing, textual information retrieval, textual data processing, texts corpora, and more. English language, its lexical features, text representation and interaction with logical and functional basis in the context of Python programming language are considered further in this research. Thus, the unity of verbal units and symbols in the modern English-language digital discourse indicates both the order and variability of the constituents therein. The functionality of linguosemiotic elements produces a network of relationships, where each of these integrated elements can produce from a word or symbol a holistic set of units, which are extrapolated in the English-language digital discourse and mediates human communication with a machine. An overview of the basic properties of Python language, such as values, types, expressions, and operations are in focus of the study. Though users understand the responses of Python interpreter, there is a need to follow certain instructions and codes. To facilitate work with this programming language and prescribed English-language commands, it is necessary to involve linguists to cooperate with programmers to invent a certain logical and reasonable principle of Python commands operation.

Guided linking: dynamic linking without the costs

Dynamic linking is extremely common in modern software systems, thanks to the flexibility and space savings it offers. However, this flexibility comes at a cost: it’s impossible to perform interprocedural optimizations that involve calls to a dynamic library. The basic problem is that the run-time behavior of the dynamic linker can’t be predicted at compile time, so the compiler can make no assumptions about how such calls will behave. This paper introduces guided linking , a technique for optimizing dynamically linked software when some information about the dynamic linker’s behavior is known in advance. The developer provides an arbitrary set of programs, libraries, and plugins to our tool, along with constraints that limit the possible dynamic linking behavior of the software. By taking advantage of the constraints, our tool enables any existing optimization to be applied across dynamic linking boundaries. For example, the NoOverride constraint can be applied to a function when the developer knows it will never be overridden with a different definition at run time; guided linking then enables the function to be inlined into its callers in other libraries. We also introduce a novel code size optimization that deduplicates identical functions even across different parts of the software set. By applying guided linking to the Python interpreter and its dynamically loaded modules, supplying the constraint that no other programs or modules will be used, we increase speed by an average of 9%. By applying guided linking to a dynamically linked distribution of Clang and LLVM, and using the constraint that no other software will use the LLVM libraries, we can increase speed by 5% and reduce file size by 13%. If we relax the constraint to allow other software to use the LLVM libraries, we can still increase speed by 5% and reduce file size by 5%. If we use guided linking to combine 11 different versions of the Boost library, using minimal constraints, we can reduce the total library size by 57%.

Application of free software FreeFem++/Gmsh and FreeCAD/CalculiX for simulation of static elasticity problems

The paper discusses the stages of computer numerical simulation of engineering problems and ways to improve the accuracy of simulation; provides a brief overview of free software for simulation elasticity problems by the finite element method, as well as trends in the development of free CAD and CAE software. For a successful engineering study, it is necessary to choose a convenient tool that takes into account all the features of the problem being solved. Based on the solution of a test static problem of linear elasticity, two approaches to engineering modeling were demonstrated. The first approach requires programming skills - the full modeling cycle was written in the programming language of the FreeFem++ software. Additionally, the method mesh generating in the Gmsh program with subsequent use in the FreeFem++ program is shown. In the second approach, the full cycle of modeling is carried out through the interface of the FreeCAD program with the built-in CalculiX solver, which does not require programming skills. A way to parameterize the task using the Python interpreter built into FreeCAD is also proposed. The simulation results obtained using both approaches are compared for an object to which an external action is applied, determined by the Dirichlet or Neumann boundary conditions, and two types of object fastening are analyzed: rigid embedding and limitation by a plane with zero friction. The analysis of the use of computing resources by various direct and iterative methods is carried out. Within the framework of the considered test problem of static linear elasticity, the most optimal method in FreeFem++ is the iterative method of conjugate gradients CG both in terms of computation time and in terms of the memory used. The highest speed of calculations is provided by the Cholesky iterative method with conditioning by the incomplete Cholesky expansion in the CalculiX program.

Making an RDBMS data scientist friendly

We are currently witnessing the rapid evolution and adoption of various data science frameworks that function external to the database. Any support from conventional RDBMS implementations for data science applications has been limited to procedural paradigms such as user-defined functions (UDFs) that lack exploratory programming support. Therefore, the current status quo is that during the exploratory phase, data scientists usually use the database system as the "data storage" layer of the data science framework, whereby the majority of computation and analysis is performed outside the database, e.g., at the client node. We demonstrate AIDA, an in-database framework for data scientists. AIDA allows users to write interactive Python code using a development environment such as a Jupyter notebook. The actual execution itself takes place inside the database (near-data), where a server component of AIDA, that resides inside the embedded Python interpreter of the RDBMS, manages the data sets and computations. The demonstration will also show the visualization capabilities of AIDA where the progress of computation can be observed through live updates. Our evaluations show that AIDA performs several times faster compared to contemporary external data science frameworks, but is much easier to use for exploratory development compared to database UDFs.