Dynamic Programming Language Research Articles

Pelatihan dan Pendampingan Pemrograman Python Dalam Meningkatkan Kompetensi Siswa SMKN 5 Palu

Python programming is a multipurpose interpretive programming language with a design philosophy that focuses on code readability. Python is a language that combines capabilities with very clear code syntax and is equipped with the functionality of a large and comprehensive standard library. Python supports multiple programming paradigms. One of the features available in Python is that it is a dynamic programming language equipped with automatic memory management. This Community Service Activity is carried out by providing training material starting from a basic introduction to the Python programming language, basic rules for writing Python syntax, an introduction to variables and data types in Python, operators in Python, and learning structures and functions in Python. The mentoring process is also carried out to provide direct experience to students. This activity went well and received appreciation from the school, and the students hope that this activity can be continued so that students are able to apply Python programming well.

Development of a natural language chatbot interface for website users

Today, there are a variety of technology solutions for creating chatbots, including universal platforms such as Google's Dialogflow, Microsoft's Azure Bot Service, and IBM's Watson Assistant, as well as chatbot builders such as ActiveChat, SendPulse, and BotPress. The disadvantage of the considered platforms and designers is the limitation of the free plan. This study considered the development and integration of an informative chatbot into the department's website in order to create a virtual assistant for potential applicants and applicants. The relevance of the study is due to the modern conditions of admission, limited opportunities to conduct career guidance events in connection with the consequences of the COVID 19 pandemic and the war on the territory of Ukraine. The object of research is a system of informing website users using natural language. A software product has been developed, which is an information system for applicants. The dynamic JavaScript programming language combined with the Node.js code execution environment and the Telegraf library was chosen to create the chatbot. The Heroku cloud platform with an integrated Heroku PostgreSQL database became the server for the operation of the chatbot. The system is implemented using the @BotFather Telegram service, which makes it possible to integrate it into any web resource. The stages of chatbot development are highlighted with examples of information, linguistic, and technical support. An analysis of the compliance of the developed chatbot with regard to the criteria of informativeness, multimodality, emotionality, productivity, and interactivity was carried out. The structure of the information content of the chatbot, which includes a set of modules, has been developed. A test version of the chatbot has been designed, tested, and integrated into the website of the Department of Applied Linguistics, which will continue to be tested and improved in 2023–2024. Practical significance: the structure of information content and the method of developing a chatbot could be used to develop authentic systems for informing applicants in institutions of higher education

An integrated self-optimizing programmable chemical synthesis and reaction engine

Robotic platforms for chemistry are developing rapidly but most systems are not currently able to adapt to changing circumstances in real-time. We present a dynamically programmable system capable of making, optimizing, and discovering new molecules which utilizes seven sensors that continuously monitor the reaction. By developing a dynamic programming language, we demonstrate the 10-fold scale-up of a highly exothermic oxidation reaction, end point detection, as well as detecting critical hardware failures. We also show how the use of in-line spectroscopy such as HPLC, Raman, and NMR can be used for closed-loop optimization of reactions, exemplified using Van Leusen oxazole synthesis, a four-component Ugi condensation and manganese-catalysed epoxidation reactions, as well as two previously unreported reactions, discovered from a selected chemical space, providing up to 50% yield improvement over 25–50 iterations. Finally, we demonstrate an experimental pipeline to explore a trifluoromethylations reaction space, that discovers new molecules.

Combining behavioral insights with artificial intelligence: New perspectives for technology assessment

Policy decisions concerning technology applications can have far-reaching societal consequences. Rationality-enhancing procedures are thus essential to ensure that such decisions are in the best interest of society. We propose a novel framework addressing this challenge. It combines a structured approach to decision-making, the mediating assessments protocol (MAP), with artificial intelligence (AI) methods to mitigate human bias and handle uncertainty in a normative manner. We introduce the steps for implementing MAP and discuss how it can be complemented and improved by AI methods such as dynamic programming, reinforcement learning and natural language processing. As a potential practical application, we consider the construction of a new wind park in a community and highlight critical aspects warranting special caution.

An Empirical Study on the Impact of Python Dynamic Typing on the Project Maintenance

Python is a popular typical dynamic programming language. In Python, dynamic typing is one of the most critical dynamic features. The lack of type information is likely to hinder the maintenance of Python projects. However, existing work has seldom focused on studying the impact of Python dynamic typing on project maintenance. This paper focuses on the two most common practices of Python dynamic typing, i.e. inconsistent-type assignments (ITA) and inconsistent variable types (IVT). Two approaches are proposed to identify ITA and IVT, i.e. identifying ITA by analyzing Abstract Syntax Trees and comparing identifiers types and identifying IVT by constructing a type dependency graph. In empirical experiments, we first locate the usage of ITA and IVT in 10 open-source Python projects. Then, we investigate the relations between the occurrence of ITA and IVT and the results of maintenance tasks. The study results show that projects are more prone to change as the number of dynamic typing identifiers increases. There is a weak connection between change-proneness and variable dynamic typing. There is a high probability that maintenance time and the acceptance of commits decrease as dynamic typing identifiers increase in projects. These results implicate that dynamic and static variables should be divided while developing new programming languages. Dynamic typing identifiers may not be the direct root causes for most software bugs. The categories of these bugs are worth exploring.

NetworkDynamics.jl-Composing and simulating complex networks in Julia.

NetworkDynamics.jl is an easy-to-use and computationally efficient package for simulating heterogeneous dynamical systems on complex networks, written in Julia, a high-level, high-performance, dynamic programming language. By combining state-of-the-art solver algorithms from DifferentialEquations.jl with efficient data structures, NetworkDynamics.jl achieves top performance while supporting advanced features such as events, algebraic constraints, time delays, noise terms, and automatic differentiation.

World age in Julia: optimizing method dispatch in the presence of eval

Dynamic programming languages face semantic and performance challenges in the presence of features, such as eval, that can inject new code into a running program. The Julia programming language introduces the novel concept of world age to insulate optimized code from one of the most disruptive side-effects of eval: changes to the definition of an existing function. This paper provides the first formal semantics of world age in a core calculus named juliette, and shows how world age enables compiler optimizations, such as inlining, in the presence of eval. While Julia also provides programmers with the means to bypass world age, we found that this mechanism is not used extensively: a static analysis of over 4,000 registered Julia packages shows that only 4-9% of packages bypass world age. This suggests that Julia's semantics aligns with programmer expectations.

Automated high-order curved mesh generator with high-level dynamic programming language julia for photonic applications

A powerful automated high-order unstructured curved mesh generator is proposed in this work with a high-level dynamic programming language Julia. This generator uses higher-order one-sided curved triangular finite elements for the domains having curved borders with parabolic arcs. The proposed approach of the mesh generator can be successfully applied for solving several industrial problems inclusive of photonics with the finite element method. The use of the parabolic arcs method to obtain node relations for the curved geometry enhances the performance of the technique with the subparametric mappings. The mesh generator suggested is based on the prominent Gmsh mesh generator. For all geometry, the presented technique can be implemented. The methodology is applied in this paper to illustrate a few photonic crystal domains.

Investigation of production costs in manufacturing environment using innovative tools

Material Requirement Planning plays a vital role in manufacturing environment. The cost calculations for a component receive major attention in the MRP and also require skill labour, Knowledge about materials, involvement of various departments etc. In order to reduce the complexity in calculating the manufacturing cost in earlier phase of production. A user-friendly software is developed using object oriented dynamic programming language Python. By giving input parameters like Geometric Section Shape, Density, and Cost per unit weight of the material and other parameters the and production cost for that component is determined.

HorseIR: bringing array programming languages together with database query processing

Relational database management systems (RDBMS) are operationally similar to a dynamic language processor. They take SQL queries as input, dynamically generate an optimized execution plan, and then execute it. In recent decades, the emergence of in-memory databases with columnar storage, which use array-like storage structures, has shifted the focus on optimizations from the traditional I/O bottleneck to CPU and memory. However, database research so far has primarily focused on CPU cache optimizations. The similarity in the computational characteristics of such database workloads and array programming language optimizations are largely unexplored. We believe that these database implementations can benefit from merging database optimizations with dynamic array-based programming language approaches. Therefore, in this paper, we propose a novel approach to optimize database query execution using a new array-based intermediate representation, HorseIR, that resides between database queries and compiled code. Furthermore, we provide a translator to generate HorseIR from database execution plans and a compiler that optimizes HorseIR and generates efficient code. We compare HorseIR with the MonetDB RDBMS, by testing standard SQL queries, and show how our approach and compiler optimizations improve the runtime of complex queries.

Lightweight Lexical Test Prioritization for Immediate Feedback

The practice of unit testing enables programmers to obtain automated feedback on whether a currently edited program is consistent with the expectations specified in test cases. Feedback is most valuable when it happens immediately, as defects can be corrected instantly before they become harder to fix. With growing and longer running test suites, however, feedback is obtained less frequently and lags behind program changes. The objective of test prioritization is to rank tests so that defects, if present, are found as early as possible or with the least costs. While there are numerous static approaches that output a ranking of tests solely based on the current version of a program, we focus on change-based test prioritization, which recommends tests that likely fail in response to the most recent program change. The canonical approach relies on coverage data and prioritizes tests that cover the changed region, but obtaining and updating coverage data is costly. More recently, information retrieval techniques that exploit overlapping vocabulary between change and tests have proven to be powerful, yet lightweight. In this work, we demonstrate the capabilities of information retrieval for prioritizing tests in dynamic programming languages using Python as example. We discuss and measure previously understudied variation points, including how contextual information around a program change can be used, and design alternatives to the widespread \emph{TF-IDF} retrieval model tailored to retrieving failing tests. To obtain program changes with associated test failures, we designed a tool that generates a large set of faulty changes from version history along with their test results. Using this data set, we compared existing and new lexical prioritization strategies using four open-source Python projects, showing large improvements over untreated and random test orders and results consistent with related work in statically typed languages. We conclude that lightweight IR-based prioritization strategies are effective tools to predict failing tests in the absence of coverage data or when static analysis is intractable like in dynamic languages. This knowledge can benefit both individual programmers that rely on fast feedback, as well as operators of continuous integration infrastructure, where resources can be freed sooner by detecting defects earlier in the build cycle.

Analisa Faktor Dominan Mahasiswa Kesulitan Memahami Bahasa Pemrograman Menggunakan Metode C4.5

Students' understanding of teaching and learning is determined by academic performance and lecturers who give teachings to students. Among them is the education of programming languages. Programming language is one of the main subjects at AMIK Tunas Bangsa Pematangsiantar. Many students buy programs in the final project so that students have difficulty answering questions from examiners n during the trial. The statement of students in difficulty understanding different programming languages. The factors used in the study are lecturer factors, programming language factors, facility factors, lab assistant factors and interest factors. The purpose of this study is to provide academic decision makers in taking solutions to overcome this. The method used in this study is Classification using the C4.5 method as many as 90 data. The results of the study have an accuracy of 84.44% with a Factor Interest is the highest factor in the analysis and Lecturer Factors as the highest factor of students who do not understand the category of Good and Less. It can be concluded that academics provide good education and provide motivation for dynamic programming languages to keep up with the times, especially in the industrial world. With the results of this study, it contributed greatly to AMIK Tunas Bangsa in making decisions to minimize students buying programs. Academic success in educating students is by giving students an acceptable degree in the industry in accordance with the education and teaching provided.

Tuning the Performance of a Computational Persistent Homology Package.

In recent years, persistent homology has become an attractive method for data analysis. It captures topological features, such as connected components, holes, and voids from point cloud data and summarizes the way in which these features appear and disappear in a filtration sequence. In this project, we focus on improving the performance of Eirene, a computational package for persistent homology. Eirene is a 5000-line open-source software library implemented in the dynamic programming language Julia. We use the Julia profiling tools to identify performance bottlenecks and develop novel methods to manage them, including the parallelization of some time-consuming functions on multicore/manycore hardware. Empirical results show that performance can be greatly improved.

Python Application: Visual Approach of Hopfield Discrete Method for Hiragana Images Recognition

Python is a dynamic object-oriented programming language. Python provides strong support for integration with other programming languages and other tools. Python programming is rarely used in the field of artificial intelligence, especially artificial neural networks. This research focuses on running Python programming to recognize hiragana letters. In learning the character of Hiragana, one can experience difficulties because of the many combinations of vowels that form new letters by different means of reading and meaning. Discrete Hopfield network is a fully connected, that every unit is attached to every other unit. This network has asymmetrical weights. At Hopfield Network, each unit has no relationship with itself. Therefore it is expected that a computer system that can help recognize the Hiragana Images. With this pattern recognition Application of Hiragana Images, it is expected the system can be developed further to recognize the Hiragana Images quickly and precisely.

Parallelization of dynamic languages: synchronizing built-in collections

Dynamic programming languages such as Python and Ruby are widely used, and much effort is spent on making them efficient. One substantial research effort in this direction is the enabling of parallel code execution. While there has been significant progress, making dynamic collections efficient, scalable, and thread-safe is an open issue. Typical programs in dynamic languages use few but versatile collection types. Such collections are an important ingredient of dynamic environments, but are difficult to make safe, efficient, and scalable. In this paper, we propose an approach for efficient and concurrent collections by gradually increasing synchronization levels according to the dynamic needs of each collection instance. Collections reachable only by a single thread have no synchronization, arrays accessed in bounds have minimal synchronization, and for the general case, we adopt the Layout Lock paradigm and extend its design with a lightweight version that fits the setting of dynamic languages. We apply our approach to Ruby's Array and Hash collections. Our experiments show that our approach has no overhead on single-threaded benchmarks, scales linearly for Array and Hash accesses, achieves the same scalability as Fortran and Java for classic parallel algorithms, and scales better than other Ruby implementations on Ruby workloads.

Virtual machine design for parallel dynamic programming languages

To leverage the benefits of modern hardware, dynamic languages must support parallelism, and parallelism requires a virtual machine (VM) capable of parallel execution — a parallel VM. However, unrestricted concurrency and the dynamism of dynamic languages pose great challenges to the implementation of parallel VMs. In a dynamic language, a program changing itself is part of the language model. To help the VM, languages often choose memory models (MM) that weaken consistency guarantees. With lesser guarantees, local program state cannot be affected by every concurrent state change. And less interference allows a VM to make local assumptions about the program state which are not immediately violated. These local assumptions are essential for a VM’s just-in-time compiler for delivering state-of-the-art VM performance. Unfortunately, some dynamic languages employ MMs that give exceedingly strong consistency guarantees and thereby hinder the development of parallel VMs. Such is the case in particular for languages that depend on a global interpreter lock, which mandates a MM with sequential consistency and instruction atomicity. In this paper, we reflect on a first implementation of the Parallel RPython execution model, which facilitates the development of parallel VMs by decoupling language semantics from the synchronization mechanism used within the VM. The implementation addresses the challenges imposed by strong MMs through strict isolation of concurrent computations. This isolation builds on transactional parallel worlds, which are implemented with a novel combination of software techniques and the capabilities of modern hardware. We evaluate a set of parallel Python programs on a parallel VM that relies on Parallel RPython’s implementation. Compared with a serial baseline VM that relies on a global interpreter lock, the parallel VM achieves speedups of up to 7.5× on 8 CPU cores. The evaluation shows that our realization of Parallel RPython meets the challenges of dynamic languages, and that it can serve as a solid foundation for the construction of parallel dynamic language VMs.

ShareJIT: JIT code cache sharing across processes and its practical implementation

Just-in-time (JIT) compilation coupled with code caching are widely used to improve performance in dynamic programming language implementations. These code caches, along with the associated profiling data for the hot code, however, consume significant amounts of memory. Furthermore, they incur extra JIT compilation time for their creation. On Android, the current standard JIT compiler and its code caches are not shared among processes—that is, the runtime system maintains a private code cache, and its associated data, for each runtime process. However, applications running on the same platform tend to share multiple libraries in common. Sharing cached code across multiple applications and multiple processes can lead to a reduction in memory use. It can directly reduce compile time. It can also reduce the cumulative amount of time spent interpreting code. All three of these effects can improve actual runtime performance. In this paper, we describe ShareJIT, a global code cache for JITs that can share code across multiple applications and multiple processes. We implemented ShareJIT in the context of the Android Runtime (ART), a widely used, state-of-the-art system. To increase sharing, our implementation constrains the amount of context that the JIT compiler can use to optimize the code. This exposes a fundamental tradeoff: increased specialization to a single process’ context decreases the extent to which the compiled code can be shared. In ShareJIT, we limit some optimization to increase shareability. To evaluate the ShareJIT, we tested 8 popular Android apps in a total of 30 experiments. ShareJIT improved overall performance by 9% on average, while decreasing memory consumption by 16% on average and JIT compilation time by 37% on average.

Hardware-software co-optimization of memory management in dynamic languages

Dynamic programming languages are becoming increasingly popular, yet often show a significant performance slowdown compared to static languages. In this paper, we study the performance overhead of automatic memory management in dynamic languages. We propose to improve the performance and memory bandwidth usage of dynamic languages by co-optimizing garbage collection overhead and cache performance for newly-initialized and dead objects. Our study shows that less frequent garbage collection results in a large number of cache misses for initial stores to new objects. We solve this problem by directly placing uninitialized objects into on-chip caches without off-chip memory accesses. We further optimize the garbage collection by reducing unnecessary cache pollution and write-backs through partial tracing that invalidates dead objects between full garbage collections. Experimental results on PyPy and V8 show that less frequent garbage collection along with our optimizations can significantly improve the performance of dynamic languages.

A Twitter Sentiment Analysis Using NLTK and Machine Learning Techniques

In today’s world, Social Networking website like Twitter, Facebook , Tumbler, etc. plays a very significant role. Twitter is a micro-blogging platform which provides a tremendous amount of data which can be used for various application of sentiment Analysis like predictions, review, elections, marketing, etc Sentiment Analysis is a process of extracting information from large amount of data, and classifies them into different classes called sentiments. Python is simple yet powerful, high-level, interpreted and dynamic programming language, which is well known for its functionality of processing natural language data by using NLTK (Natural Language Toolkit). NLTK is a library of python, which provides a base for building programs and classification of data. NLTK also provide graphical demonstration for representing various results or trends and it also provide sample data to train and test various classifier respectively. Sentiment classification aims to automatically predict sentiment polarity of users publishing sentiment data. Although traditional classification algorithm can be used to train sentiment classifiers from manually labelled text data, the labelling work can be time-consuming and expensive. Meanwhile, users often use some different words when they express sentiment in different domains. If we directly apply a classifier trained in one domain to other domains, the performance will be very low due to the difference between these domains. In this work, we develop a general solution to sentiment classification when we do not have any labels in target domain but have some labelled data in a different domain, regarded as source domain.

Reference Abstract Domains and Applications to String Analysis

Abstract interpretation is a well established theory that supports reasoning about the run-time behaviour of programs. It achieves tractable reasoning by considering abstractions of run-time states, rather than the states themselves. The chosen set of abstractions is referred to as the abstract domain. We develop a novel framework for combining (a possibly large number of) abstract domains. It achieves the effect of the so-called reduced product without requiring a quadratic number of functions to translate information among abstract domains. A central notion is a reference domain, a medium for information exchange. Our approach suggests a novel and simpler way to manage the integration of large numbers of abstract domains. We instantiate our framework in the context of string analysis. Browser-embedded dynamic programming languages such as JavaScript and PHP encourage the use of strings as a universal data type for both code and data values. The ensuing vulnerabilities have made string analysis a focus of much recent research. String analysis tends to combine many elementary string abstract domains, each designed to capture a specific aspect of strings. For this instance the set of regular languages, while too expensive to use directly for analysis, provides an attractive reference domain, enabling the efficient simulation of reduced products of multiple string abstract domains.