General-purpose Programming Language Research Articles

Building a Graphical Modelling Language for Efficient Homomorphic Encryption Schema Configuration: HomoLang

Homomorphic encryption (HE) is an emerging technology that enables computing on data while the data is encrypted. It has advantages, but it also has a significant difficulty. Programmers that use General-Purpose Programming Languages (GPPLs) may find it difficult to handwrite the script code for the HE correctly. This paper presents the front-end compiler design for the first graphical modelling language (DSML) to implement HE schemas, called HomoLang. It is providing a graphical environment with graphical building nodes that represent the HE concepts to enable the building of HE schemas. A high degree of abstraction and a decrease in grammatical and runtime errors improved the expressiveness and efficiency of implementation. Six security tests for security analysis were provided. The efficiency of the submitted language was evaluated using four subjective metrics. This paper provides a detailed explanation of the attributes, evaluation details, and design of the submitted HomoLang.

SBMLToolkit.jl: a Julia package for importing SBML into the SciML ecosystem.

Julia is a general purpose programming language that was designed for simplifying and accelerating numerical analysis and computational science. In particular the Scientific Machine Learning (SciML) ecosystem of Julia packages includes frameworks for high-performance symbolic-numeric computations. It allows users to automatically enhance high-level descriptions of their models with symbolic preprocessing and automatic sparsification and parallelization of computations. This enables performant solution of differential equations, efficient parameter estimation and methodologies for automated model discovery with neural differential equations and sparse identification of nonlinear dynamics. To give the systems biology community easy access to SciML, we developed SBMLToolkit.jl. SBMLToolkit.jl imports dynamic SBML models into the SciML ecosystem to accelerate model simulation and fitting of kinetic parameters. By providing computational systems biologists with easy access to the open-source Julia ecosystevnm, we hope to catalyze the development of further Julia tools in this domain and the growth of the Julia bioscience community. SBMLToolkit.jl is freely available under the MIT license. The source code is available at https://github.com/SciML/SBMLToolkit.jl.

Genetic algorithms as a tool for the formation and evolution of trading strategies in the securities market

Subject. This article deals with the tools for the formation and evolution of trading strategies in the securities market. Objectives. The article aims to develop a mathematical framework and a formalized algorithm for the formation and evolution of trading strategies in the securities market. Methods. For the study, I used a genetic algorithm as an evolutionary optimization model. Results. The article presents an original mathematical description of a tool for the formation and evolution of strategies using genetic algorithms and a formalized algorithm sufficient for implementation in general-purpose programming languages. Conclusions and Relevance. The results obtained are the basis for further research in the field of autonomous evolution of trading strategies, and the described models will allow further research on the basis of specific software tools. The work is of practical value for private and institutional investors, for whom the trading strategy in the securities market is one of the fundamental aspects of their activities.

A Proposal of Naturalistic Software Development Method

Naturalistic programming purports to include natural language elements in programming languages to increase software expressiveness. Even though natural language is inherently ambiguous, it is richer and thus more expressive than any artificial language. Currently, the Naturalistic Programming Paradigm (NPP) is supported by its conceptual model and three general-purpose naturalistic programming languages that can generate executable binary code. Nevertheless, to date, no research efforts have been concentrated on applying the NPP within a software development process. To address this gap, in this article, we propose a naturalistic software development method to test the advantages of the NPP. The method focuses on the analysis and design stages of the software development process and seeks to contribute to closing the gap between the problem and the solution domains. We also present an example of an implementation using Cal-4700, a naturalistic programming language, showing the differences in expressiveness of programming with a traditional programming language, like Python. 

Assessing the Impact of Compiler Optimizations on GPUs Reliability

Graphics Processing Units (GPUs) compilers have evolved in order to support general-purpose programming languages for multiple architectures. NVIDIA CUDA Compiler (NVCC) has many compilation levels before generating the machine code and applies complex optimizations to improve performance. These optimizations modify how the software is mapped in the underlying hardware; thus, as we show in this article, they can also affect GPU reliability. We evaluate the effects on the GPU error rate of the optimization flags applied at the NVCC Parallel Thread Execution (PTX) compiling phase by analyzing two NVIDIA GPU architectures (Kepler and Volta) and two compiler versions (NVCC 10.2 and 11.3). We compare and combine fault propagation analysis based on software fault injection, hardware utilization distribution obtained with application-level profiling, and machine instructions radiation-induced error rate measured with beam experiments. We consider eight different workloads and 144 combinations of compilation flags, and we show that optimizations can impact the GPUs’ error rate of up to an order of magnitude. Additionally, through accelerated neutron beam experiments on a NVIDIA Kepler GPU, we show that the error rate of the unoptimized GEMM (-O0 flag) is lower than the optimized GEMM’s (-O3 flag) error rate. When the performance is evaluated together with the error rate, we show that the most optimized versions (-O1 and -O3) always produce a higher amount of correct data than the unoptimized code (-O0).

Design and Development of a Digital Personalized Learning Track: Bridging the Gap Between Textual and Visual Programming

Due to swift technological changes in society, programming tasks are proliferating in formal and informal education around the globe. However, challenges arise regarding the acquisition of programming skills. Many students are unequipped to develop programming skills due to limited instruction or background and therefore feel insecure when encountering programming in higher education. Some after-school initiatives focus on teaching younger students programming skills, however, not all students have the opportunity to attend. It can also be very challenging for teachers to teach programming—even more so due to significant differences in students’ knowledge and interests. To alleviate these challenges, we designed and developed a digital personalized learning (DPL) track for programming in the first grade of secondary education (12–14 year-old students) with a threefold purpose: (a) to encourage students bridging the gap between visual and more general-purpose textual programming languages (b) to meet differences in students’ programming knowledge by challenging them, albeit on their own pace, and subsequently (c) to support teachers in the delivery of programming education with relevant supportive learning materials. The design was tested by students and teachers, both of varying technical abilities. Assessments of the DPL-track were positive, with students identifying the tasks as challenging and the tools as motivating. Teachers praised the adaptivity, as well as the gradual transition from visual to textual programming. We present several suggestions for design improvement and dilemmas while reflecting on our design case.

When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism

Type inference in the presence of first-class or “impredicative” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like (𝜆𝑥. (𝑥 123, 𝑥 True)) id reliably. We show that a type inference approach based on multi-bounded polymorphism, a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F {≤} , a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F {≤} types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.

Mathematical model for investigation of alkylbenzenes sulfonation

The relevance. Lack of experimental data that allow developing a scientifically based method for calculating and designing film-type reactors, which are also used to produce alkylbenzenesulfonic acids. These acids, in their turn, are currently the main components of synthetic detergents. The issue of increasing reactor equipment efficiency can be most effectively solved using mathematical models built on a physical and chemical basis. The aim. Development of a mathematical model of alkylbenzenes sulfonation, taking into account a substance mass transfer from a gas phase to a liquid phase. Software implementation of the developed model, as well as the use of the developed mathematical model for studying the influence of the process parameters on its efficiency. Object. Alkylbenzenes sulfonation with sulfuric anhydride in a multitube film reactor. Methods. Mathematical modeling is used to perform all computational operations, a modern high-level general-purpose programming language with automatic memory management is used. The quantum-chemical methods for determining thermodynamic parameters of chemical reactions were used. Results. The paper considers the principles of constructing a mathematical model of sulfonation. The authors have developed the calculation program in the Python programming language and assessed the accuracy of description of a real process and the influence of the system technological parameters on a product yield and quality, taking into account a substance interfacial transfer. The system of practical recommendations for improving the alkylbenzenes sulfonation resource efficiency was developed. The mathematical model adequately describes the process. The calculated data are compared with the real data from the operating unit for alkylbenzenes sulfonation with sulfuric anhydride.

Synchronization Possibilities and Features in Java

Abstract In this paper we have discussed one of the greatest features of the general-purpose computer programming language –Java. This paper represents concepts of Synchronization possibilities and features in Java. Today’s operating systems support concept of “Multitasking”. Multitasking achieved by executing more than one task at a same time. Tasks runs on threads. Multitasking runs more than one task at a same time. Multitasking which means doing many things at the same time is one of the most fundamental concepts in computer engineering and computer science because the processor execute given tasks in parallel so it makes me think that are executing simultaneously. Multitasking is related to other fundamental concepts like processes and threads. A process is a computer program that is executing in a processor, while a thread is a part of a process that has a way of execution: it is a thread of execution. Every process has at least one thread of execution. There are two types of multitasking: process – based and thread – based. Process-based multitasking, means that on a given computer there can be more than one program or process that is executing, while thread-based multitasking, which is also known as multithreading, means that within a process, there can be more than one thread of execution, each of them doing a job and so accomplishing the job of their process. When there are many processes or many threads within processes, they may have to cooperate with each other or concurrently try to get access to some shared computer resources like: processor, memory and input/output devices. They may have to, for example: print a file in a printer or write and/or read to the same file. We need a way of setting an order, where processes and/or threads could do their jobs (user jobs) without any problem, we need to synchronize them. Java has built-in support for process and thread synchronization, there are some constructs that we can use when we need to do synchronization.This paper, a first phase discussed the concept of Parall Programming, threads, how to create a thread, using a thread, working with more than one thread. Second phase is about synchronization, what is in general and in the end we disscused the synchronization possibilities and feautures in Java.

Visual Low-Code Language for Orchestrating Large-Scale Distributed Computing

Distributed, large-scale computing is typically performed using textual general-purpose programming languages. This requires significant programming skills associated with the parallelisation and distribution of computations. In this paper, we present a visual (graphical) programming language called the Computation Application Language (CAL) to raise abstraction in distributed computing. CAL programs define computation workflows by visualising data flowing between computation units. The goal is to reduce the amount of traditional code needed and thus facilitate development even by non-professional programmers. The language follows the low-code paradigm, i.e. its implementation (the editor and the runtime system) is available online. We formalise the language by defining its syntax using a metamodel and specifying its semantics using a two-step approach. We define a translation of CAL into an intermediate language which is then defined using an operational approach. This formalisation was used to develop a programming and execution environment. The environment orchestrates computations by interpreting the intermediate language and managing the instantiation of computation modules using data tokens. We also present an explanatory case-study example that shows a practical application of the language.

An Analysis of the Usage of Various Programming Languages to Classify Whether they are Relevant, Extinct, or on the Verge of Extinction

The first modern high level general purpose programming languages appeared over seventy years ago. Since then, with the exponential increase in the usage of different types of computer software and developments in computer hardware, numerous high level programming languages have been created for various purposes, with each language having its own relative advantages and disadvantages. Usually, specific general purpose high level programming languages are appropriate for specific applications or problems because of the nature of capabilities of the languages such as efficiency, memory consumption, expressiveness, availability of compilers, and tools etc. Newer languages incorporate significant functionalities of older languages which may serve as an “inspiration” for it while introducing new features and functionalities. However, the creation of newer programming languages does not necessarily mean the obsolescence of older languages because of factors such as programming effort, familiarity, and popularity. However, their usage for newer and upcoming applications may eventually decrease and familiarity and popularity might consequently fade away with it. In this paper, we take a look at 38 different programming languages that have been invented and identify the least used programming languages to provide an overall estimate of the least used programming languages in today’s time and the programming languages on the verge of death

DESnets: A Graphical Representation for Discrete Event Simulation and Cost-Effectiveness Analysis

Cost-effectiveness analysis (CEA) is used increasingly in medicine to determine whether the health benefit of an intervention is worth the economic cost. Discrete event simulation (DES) is playing an increasing role in CEA thanks to several advantages, such as the possibility of modeling time and heterogeneous populations. It is usually implemented with general-purpose programming languages or commercial software packages. To our knowledge, no artificial intelligence technique has been applied to DES for CEA. Our objective is to develop a graphical representation, an algorithm, and a software tool that allows non-programmers to easily build models and perform CEA. We present DESnets (discrete event simulation networks) as a new type of probabilistic graphical model inspired by probabilistic influence diagrams, an algorithm for evaluating and an implementation as an OpenMarkov plug-in. DESnets are compared qualitatively and empirically with six alternative tools using as a running example a model about osteoporosis by the British National Institute for Health and Care Excellence (NICE). In our experiments, the implementation of DESnets allowed the building of a typical DES model declaratively. Its evaluation process ranked among the most efficient. DESnets compare favorably with alternative tools in terms of ease of use, expressive power, transparency, and computational efficiency.

Hardware Emulation of Step-Down Converter Power Stages for Digital Control Design

This paper proposes a methodology of delivering the emulation hardware of several step-down converter power stages. The generalized emulator design methodology follows these steps: first, the power stage is described using an ordinary differential equation system; second, the ordinary differential equation system is solved using Euler’s method, and thus an accurate time-domain model is obtained; next, this time-domain model can be described using either general-purpose programming language (MATLAB, C, etc.) or hardware description language (VHDL, Verilog, etc.). As a result, the emulator has been created; validation of the emulator may be carried out by comparing it to SPICE transient simulations. Finally, the validated emulator can be implemented on the preferred target technology, either in a general-purpose processor or a field programmable gate array. As the emulator relies on the ordinary differential equation system of the power stage, it has better behavioral accuracy than the emulators based on average state space models. Moreover, this paper also presents the design methodology of a manually tuned proportional–integrative–derivative controller deployed on a field programmable gate array.

Computation Against a Neighbour: Addressing Large-Scale Distribution and Adaptivity with Functional Programming and Scala

Recent works in contexts like the Internet of Things (IoT) and large-scale Cyber-Physical Systems (CPS) propose the idea of programming distributed systems by focussing on their global behaviour across space and time. In this view, a potentially vast and heterogeneous set of devices is considered as an "aggregate" to be programmed as a whole, while abstracting away the details of individual behaviour and exchange of messages, which are expressed declaratively. One such a paradigm, known as aggregate programming, builds on computational models inspired by field-based coordination. Existing models such as the field calculus capture interaction with neighbours by a so-called "neighbouring field" (a map from neighbours to values). This requires ad-hoc mechanisms to smoothly compose with standard values, thus complicating programming and introducing clutter in aggregate programs, libraries and domain-specific languages (DSLs). To address this key issue we introduce the novel notion of "computation against a neighbour", whereby the evaluation of certain subexpressions of the aggregate program are affected by recent corresponding evaluations in neighbours. We capture this notion in the neighbours calculus (NC), a new field calculus variant which is shown to smoothly support declarative specification of interaction with neighbours, and correspondingly facilitate the embedding of field computations as internal DSLs in common general-purpose programming languages -- as exemplified by a Scala implementation, called ScaFi. This paper formalises NC, thoroughly compares it with respect to the classic field calculus, and shows its expressiveness by means of a case study in edge computing, developed in ScaFi.

Enriching UML Statecharts through a Metamodel: A Model Driven Approach for the Graphical Definition of DEVS Atomic Models

The Discrete Event System Specification (DEVS) formalism provides a set of mathematical elements for modeling time-varying systems. However, when DEVS models are implemented in an executable representation (i.e., using a general-purpose programming language), some deviation from the formalism is unavoidable. One way to bridge the gap between modeling and simulation theory and practice is to define new artifacts that support both views during the specification. When the specification is supported with a graphical representation, the formalization task is less complex and can be performed by non-expert modelers. For DEVS atomic models, most common graphical representation is through UML statecharts. In this paper, we present a theoretical and practical metamodel for the definition of atomic models structured following the Classic DEVS with Ports formalization. Such a metamodel is the core of a model-driven approach used to develop a modeling software tool that employs enriched UML statecharts for the graphical representation of the DEVS behavior. In here, the traditional UML statechart representation is enriched with a set of new components with the aim to provide a broad definition of DEVS atomic models. The final software tool is deployed as a plugin for Eclipse Platform.

Exploring changes in depression and radiology-related publications research focus: A bibliometrics and content analysis based on natural language processing.

This study aims to construct and use natural language processing and other methods to analyze major depressive disorder (MDD) and radiology studies' publications in the PubMed database to understand the historical growth, current state, and potential expansion trend. All MDD radiology studies publications from January 2002 to January 2022 were downloaded from PubMed using R, a statistical computing language. R and the interpretive general-purpose programming language Python were used to extract publication dates, geographic information, and abstracts from each publication's metadata for bibliometric analysis. The generative statistical algorithm "Latent Dirichlet allocation" (LDA) was applied to identify specific research focus and trends. The unsupervised Leuven algorithm was used to build a network to identify relationships between research focus. A total of 5,566 publications on MDD and radiology research were identified, and there is a rapid upward trend. The top-cited publications were 11,042, and the highly-cited publications focused on improving diagnostic performance and establishing imaging standards. Publications came from 76 countries, with the most from research institutions in the United States and China. Hospitals and radiology departments take the lead in research and have an advantage. The extensive field of study contains 12,058 Medical Subject Heading (MeSH) terms. Based on the LDA algorithm, three areas were identified that have become the focus of research in recent years, "Symptoms and treatment," "Brain structure and imaging," and "Comorbidities research." Latent Dirichlet allocation analysis methods can be well used to analyze many texts and discover recent research trends and focus. In the past 20 years, the research on MDD and radiology has focused on exploring MDD mechanisms, establishing standards, and constructing imaging methods. Recent research focuses are "Symptoms and sleep," "Brain structure study," and "functional connectivity." New progress may be made in studies on MDD complications and the combination of brain structure and metabolism.

Digital Twin applications using the SIMULTAN data model and Python

Python is an open, general-purpose programming language that is used in many tools, libraries and APIs for Building Performance Simulations (BPS). Advantages of Python in the context of digital twins are the simple and powerful capabilities to generate input files, automate processes, import libraries in many languages and a large number of useful modules. However, in order to use BPS tools and libraries with real time data, a comprehensive data model is required in which all necessary data such as geometry, system engineering, databases, sensors, or simulation parameters for the different BPS are defined. Python in combination with SIMULTAN as a suitable open Building Information Modelling (BIM) data model allows an effective use of these tools and libraries to perform and automate analyses. This paper presents a Python module that integrates the SIMULTAN model in Python and enables almost seamless integration with minor adaptations to existing tools or modules. The import is achieved using simple text-based templates for the data types and their mapping in the data model. The data model, the definition of the data types and the use of this module is demonstrated by calculating the trend of the CO2 concentration in a zone of a digital twin using real time data.

Fuzion - Safety through Simplicity

Fuzion is a modern, general purpose programming language that unifies concepts found in structured, functional and object-oriented programming languages into the concept of a Fuzion feature. It combines a powerful syntax and safety features based on the design-by-contract principle with a simple intermediate representation that enables powerful optimizing compilers and static analysis tools to verify correctness aspects. Fuzion maps different concepts into the concept of a Fuzion feature and uses a simple intermediate language that is friendly for static analysis tools as well as for optimizing compilers. Fuzion was influenced by many other languages including Java, Python, Eiffel, Rust, Ada, Go, Lua, Kotlin, C#, F#, Nim, Julia, Clojure, C/C++, Scala, and many more. The goal of Fuzion is to define a language that has the expressive power present in these languages and allow high-performance implementation and powerful analysis tools. Furthermore, Fuzion addresses requirements for safety-critical applications by adding support for contracts that enable formal specification and detailed control over runtime checks.

Advantages and disadvantages of (dedicated) model transformation languages

ContextModel driven development envisages the use of model transformations to evolve models. Model transformation languages, developed for this task, are touted with many benefits over general purpose programming languages. However, a large number of these claims have not yet been substantiated. They are also made without the context necessary to be able to critically assess their merit or built meaningful empirical studies around them.ObjectiveThe objective of our work is to elicit the reasoning, influences and background knowledge that lead people to assume benefits or drawbacks of model transformation languages.MethodWe conducted a large-scale interview study involving 56 participants from research and industry. Interviewees were presented with claims about model transformation languages and were asked to provide reasons for their assessment thereof. We qualitatively analysed the responses to find factors that influence the properties of model transformation languages as well as explanations as to how exactly they do so.ResultsOur interviews show, that general purpose expressiveness of GPLs, domain specific capabilities of MTLs as well as tooling all have strong influences on how people view properties of model transformation languages. Moreover, the Choice of MTL, the Use Case for which a transformation should be developed as well as the Skill s of involved stakeholders have a moderating effect on the influences, by changing the context to consider.ConclusionThere is a broad body of experience, that suggests positive and negative influences for properties of MTLs. Our data suggests, that much needs to be done in order to convey the viability of model transformation languages. Efforts to provide more empirical substance need to be undergone and lacklustre language capabilities and tooling need to be improved upon. We suggest several approaches for this that can be based on the results of the presented study.

METHOD OF THE DECLARATIVE METAPROGRAMMING BASED ON DOMAIN-SPECIFIC PROGRAMMING LANGUAGES

A concept of declarative metaprogramming which focuses on program code generation is considered. The method is based on using domain-specific languages that are implemented by means of existing general-purpose programming languages. Since metaprogramming is based on using programs that produce other programs, the declarative approach means that the input and the output program code must be as close as possible in terms of syntax or ideally identical. In order to generate a program code, it is required to write templates that hold the exact structure of a resulting generated code but contain placeholders for specifics of concrete generated instances. Such an approach is highly useful when there is a need of generating a large number of similar program files by structure but different in details. The simplest way to define such templates would be just by constructing them from string literals by injecting the specific details using a string interpolation mechanism for example. However, such an approach does not provide type safety and compile time validation, so there is no guarantee the generated code is a correct and compilable program. The domain-specific language, on the other hand, replicates all the syntactic constructions of the target programming language so that, the resulting generated code would be the same as code written by the programmer. Moreover, having preserved all the syntax validations by the compiler on which the domain-specific language is based. The paper considers a concrete example of a code generator for a Starlark programming language, a dialect of Python while the domain specific-language is based on Kotlin language. Using the toolset of Kotlin, such a domain-specific language replicates such Starlark constructs as variable assignments, list comprehensions, library functions, slices, etc with a required level of customizability.