Target Programming Language Research Articles

Integration of the methods of algebra of algorithms and computational intelligence for automation of program systems design

An approach to the creation of intelligent systems is considered, which combines the ideas of Glushkov’s algebra of algorithms with the well-known neuroevolutionary algorithms of computational intelligence, which can be used to automate the design and synthesis of programs. The method of neuroevolution of augmenting topologies is intended to reduce the dimensionality of the space for searching for neural network parameters in the form of gradual development of its structure in the process of evolution. A software toolkit has been developed to support the approach, which is based on the construction of high-level specifications of algorithms represented in systems of algorithmic algebras, and generation of corresponding programs based on implementation templates in a target programming language. Parameterized algorithms called hyperschemes are used to solve a certain class of problems. Setting specific values of parameters and subsequent interpretation of hyperschemes allows obtaining algorithms adapted to specific application conditions. The developed program design and synthesis toolkit provides step-by-step development of programs, starting from a high-level algebraic-algorithmic specification. At the output of the toolkit, a program is automatically generated in one of the target programming languages (С, С++, Java, Python), that also include a subject-oriented language for designing neural networks. The mentioned language includes operators and conditions for working with populations, configurations, genomes, and fitness function. The work of the toolkit is illustrated by the example of designing a parameterized evaluation algorithm for a binary multiplexer and generation of a program for the single-pole balancing problem

Post-Refactoring Recovery of Unit Tests: An Automated Approach

— In application development lifecycle, specifically in test-driven development, refactoring plays a crucial role in sustaining ease. However, in-spite of bringing ease, refactoring does not ensure the desired behaviour of code after it is applied. Because refactoring tends to worsen the alignments between source code and its corresponding units. One significant solution to the aforementioned issue is the technique called unit testing. As unit testing enable the developers to confidently apply refactoring while avoiding undesired code behaviour. Unit testing provides effective preventive measures for avoiding bugs by providing immediate feedback, thus assisting to mitigate the fear of change. In this work, we present a tool called GreenRefPlus which efficiently enables the developers to maintain the veracity of code after the process of refactoring is applied. The proposed tool provides automatic recovery for the unit tests after the code is refactored. In this work, we consider Java as our target programming language and we focus on five various types of refactoring, which include Rename Method, Extract Method, Move Method, Parameter Addition and Parameter Removal. Our experiments indicate that the proposed tool GreenRefPlus enables us to consistently refactor the code and apply unit tests. The results presented in our work reveal that the proposed tool assists developers in saving approximately 43% of the total time required to manually recover from broken unit tests.

PARAMETER-DRIVEN GENERATION OF EVALUATION PROGRAM FOR A NEUROEVOLUTION ALGORITHM ON A BINARY MULTIPLEXER EXAMPLE

Context. The problem of automated development of evaluation programs for the neuroevolution of augmenting topologies. Neuroevolution algorithms apply mechanisms of mutation, recombination, and selection to find neural networks with behavior that satisfies the conditions of a certain formally defined problem. An example of such a problem is finding a neural network that implements a certain digital logic.
 Objective. The goal of the work is the automated design and generation of an evaluation program for a sample neuroevolution problem (binary multiplexer).
 Method. The methods and tools of Glushkov’s algebra of algorithms and hyperscheme algebra are applied for the parameterdriven generation of a neuroevolution evaluation program for a binary multiplexer. Glushkov’s algebra is the basis of the algorithmic language intended for multilevel structural design and documentation of sequential and parallel algorithms and programs in a form close to a natural language. Hyperschemes are high-level parameterized specifications intended for solving a certain class of problems. Setting parameter values and subsequent interpretation of hyperschemes allows obtaining algorithms adapted to specific conditions of their use.
 Results. The facilities of hyperschemes were implemented in the developed integrated toolkit for the automated design and synthesis of programs. Based on algorithm schemes, the system generates programs in a target programming language. The advantage of the system is the possibility of describing algorithm schemes in a natural-linguistic form. An experiment was conducted consisting in the execution of the generated program for the problem of evaluating a binary multiplexer on a distributed cloud platform. The multiplexer example is included in SharpNEAT, an open-source framework that implements the genetic neuroevolution algorithm NEAT for the .NET platform. The parallel distributed implementation of the SharpNEAT was proposed in the previous work of the authors.
 Conclusions. The conducted experiments demonstrated the possibility of the developed distributed system to perform evaluations on 64 cloud clients-executors and obtain an increase in 60–100% of the maximum capabilities of a single-processor local implementation.

Backend Bug Finder — a platform for effective compiler fuzzing

Introduction: The standard way to check the quality of a compiler is manual testing. However, it does not allow to cover a vast diversity of programs that can be written in a target programming language. Today, in addition to manual written tests there are many automated compiler testing methods, among which fuzzing is one of the most powerful and useful. A compiler fuzzer is a tool that generates a random program in a target language and checks how the compiler works in this language. Purpose: To develop a platform for compiler fuzzing and, based on it, to develop a tool for Kotlin compiler testing. Results: We have developed Backend Bug Finder which is a platform for compiler fuzzing is. We have chosen a mutation-based approach as a method for generating random programs. First, an existing program is entered to the mutator as the input to be then transformed in some way. Mutations can be both trivial, for example, replacing arithmetic operators with others, and complex, changing the structure of the program. Next, the resulting program is fed to the input of the compiler with the following check of its operation. The developed test oracle can detect three types of errors: crashes, miscompilations, and performance degradations. If an error is detected, the test case is fed into the post-processing module, where reduction and deduplication algorithms are applied. We have developed a tool for fuzzing the Kotlin language compiler based on the platform for its approbation, which showed the applicability of the proposed approach for finding errors in modern compilers. Practical relevance: Over a year and a half of work, our tool has found thousands of different Kotlin compiler bugs, more than 200 of which were sent to the developers, and more than 80 have been fixed.

Автоматизована генерація програм для одного класу параметричних алгоритмів нейроеволюції

The facilities of algebra of hyperschemes are applied for automated generation of neuroevolution algorithms on an example of a binary multiplexer evaluation problem, which is a part of the SharpNEAT system. SharpNEAT is an open-source framework developed in C# programming language, which implements a genetic neuroevolution algorithm for the .NET platform. Neuroevolution is a form of artificial intelligence, which uses evolution algorithms for creating neural networks, parameters, topology, and rules. Evolution algorithms apply mutation, recombination, and selection mechanisms for finding neural networks with behavior that satisfies to conditions of some formally defined problem. In this paper, we demonstrate the use of algebra of algorithms and hyperschemes for the automated generation of evaluation programs for neuroevolution problems. Hyperscheme is a high-level parameterized specification of an algorithm for solving some class of problems. Setting the values of the hyperscheme parameters and further interpretation of a hyperscheme allows obtaining algorithms adapted to specific conditions of their use. Automated construction of hyperschemes and generation of algorithms based on them is implemented in the developed integrated toolkit for design and synthesis of programs. The design of algorithms is based on Glushkov systems of algorithmic algebra. The schemes are built using a dialogue constructor of syntactically correct programs, which consists in descending design of algorithms by detailing the constructions of algorithmic language. The design is represented as an algorithm tree. Based on algorithm schemes, programs in a target programming language are generated. The results of the experiment consisting in executing the generated binary multiplexer evaluating program on a cloud platform are given.

Автоматизоване розпаралелювання програми моделювання внутрішньочастинкової дифузії й абсорбції в неоднорідних нанопористих середовищах

Heterogeneous media consisting of thin layers of particles of forked porous structure with different physical-chemical properties are widely used in science-intensive technologies and priority sectors of industry, medicine, ecology, etc. Such layers are distributed systems of pores consisting of two main spaces: micro- and nanopores of particles and macropores and cavities between particles. Mass transfer in the system of heterogeneous media causes two types of mass transfer: diffusion in macropores, owing to interparticle space, and diffusion in the system of micro- and nanopores inside particles of the heterogeneous medium. Intraparticle space has a higher level of adsorptive capacity, and at the same time, has a lower velocity of diffusion intrusion in comparison with interparticle space. In modeling concentra- tion and gradient fields for various diffusible components, an important scientific problem is the identification of kinetic parameters of a transfer, predetermining mass transfer velocity on macro- and micro levels, and also equilibrium conditions. The results of designing and parallelization of a program implementing a Crank-Nicolson scheme using algebra-algorithmic specifications represented in a natural- linguistic form are given. The tools for automated design, synthesis and auto-tuning of programs were applied that provided the translation of algebra-algorithmic schemes into source code in a target programming language and its tuning for execution environment to increase the program performance. Numerical distributions of values of diffusion coefficients for intraparticle transfer along coordinate of medium thickness for various time snapshots were obtained. Based on the results of the identification, the models were checked for adequacy and numerical modeling and analysis of concentration and gradient fields of mass transfer were carried out. The experiment results of auto- tuning the software implementation demonstrated high multiprocessor speedup on test data input.

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.

SPESC-Translator: Towards Automatically Smart Legal Contract Conversion for Blockchain-Based Auction Services

In recent years, advanced smart contract languages (ASCLs) have been proposed to solve the problem of difficult reading, comprehension, and collaboration when writing smart legal contracts among people in different fields. However, this kind of languages are still hard to put into practice due to the lack of an effective conversion method from the ASCLs to executable smart contract programs. Aiming at this problem, we take SPESC as example to explore how to design conversion rules from the contract in it to the target programming language in Solidity, and to propose a three-layer smart contract framework, including advanced smart-contract layer, general smart-contract layer, and executable machine-code layer. These rules provide an approach to convert the definition of SPESC contracting parties into party-contracts on target language, as well as to produce SPESC contract terms into main-contract on target language. Moreover, the proposed framework specifies not only program architecture and storage structure on general smart-contract layer, but also important mechanisms, including personnel management, timing control, exception handling, etc., which can assist programmers to write smart contract programs. Furthermore, taking four SPESC contracts as testing objects, we provide the whole process of converting from SPESC contracts to Solidity programs by the SPESC-Translator, and verify the efficiency and security of the conversion process, including coding, deploying, running, and testing through Ethereum. The instance results show that the conversion rules and the three-layer framework can simplify the writing of smart contracts, standardize the program structure, and help programmers to verify the correctness of the contract programs.

Автоматизоване проектування та розпаралелювання програм для гетерогенних платформ із використанням алгебро-алгоритмічного інструментарію

Methods and software tools for automated design and generation of OpenCL programs based on the algebra of algorithms are proposed. OpenCL is a framework for developing parallel software that executes across heterogeneous platforms consisting of general-purpose processors and/or hardware accelerators. The proposed approach consists in using high-level algebra-algorithmic specifications of programs represented in natural linguistic form and rewriting rules. The developed software tools provide the automated design of algorithm schemes based on a superposition of Glushkov algebra constructs that are considered as reusable components. The tools automatically generate code in a target programming language on the basis of the specifications. In most computing problems, a large part of hardware resources is utilized by computations inside loops, therefore the use of automatic parallelization of cyclic operators is most efficient for them. However, the existing automatic code parallelizing tools, such as Par4All, don’t account the limited amount of accelerator’s onboard memory space while real-life problems demand huge amounts of data to be processed. Thus, there is a need for the development of a parallelization technique embracing the cases of massive computational tasks involving big data. In the paper, a method and a software tool for semi-automatic parallelization of cyclic operators based on loop tiling and data serialization are developed. The parallelization technique uses rewriting rules system to transform programs. The framework for parallelization of loops for optimization of computations using graphics processing units allows semi-automatic parallelization of sequential programs. The approach is illustrated on an example of developing a parallel OpenCL image convolution program.

Algorithm source codes generation for ensuring N-version software diversity

Diversity is one of the fundamental principles for N-version software development. The development of redundant versions can significantly improve the reliability of software, but it is more time and labour consuming. Business and manufacturing require a higher level of software reliability. The task of reducing the lead-time and cost effectiveness becomes more important when developing N-version software for such industries. It is proposed to use automatic source code generation to create N-version software. The use of domain-specific language for the intermediate representation of the algorithm simplifies code generation in the target programming language. The authors discuss a new conceptual model of two-step code translation for N-version software. The proposed approach will simplify the process of N-version software development and reduce the number of required resources. The paper contains an example of C code generation as a target programming language, using flowcharts as a graphical representation of the source algorithm. The described approach is intended for use in safety-critical industries.

From Object-Z Specification to Groovy Implementation

So far, valuable researches have been conducted on mapping object-oriented specification notations, such as Object-Z, to different object-oriented programming languages, such as C++. However, the results of selecting JVM-based programming languages for mapping have not covered most of basic Object-Z structures. In this paper, the Groovy language, as a dynamic JVM-based language, is selected to overcome some of the existing limitations. As the main contribution, the rules required for mapping Object-Z specifications to executable Groovy code are introduced. The proposed rules cover notions such as multiple inheritance, inverse specification of functions, functions defined on generic definitions, and free type constructors. These notions have not been covered in previous methods for formal program development from object-oriented specifications, regardless of the selected formal specification language and target programming language. In addition, in this paper, the parallel composition construct is mapped to a parallel, executable code to improve the faithfulness of the final code to the initial specification. We also introduce a mapping rule for the class union construct, which has not yet been provided for any JVM-based language. Unlike previous works, instead of presenting the mapping rules in terms of natural languages, we present them in terms of some formal mapping rules.

Aspect composition for multiple target languages using LARA

Usually, Aspect-Oriented Programming (AOP) languages are an extension of a specific target programming language (e.g., AspectJ for Java and AspectC++ for C++). Although providing AOP support with target language extensions may ease the adoption of an approach, it may impose constraints related with constructs and semantics. Furthermore, by tightly coupling the AOP language to the target language the reuse potential of many aspects, especially the ones regarding non-functional requirements, is lost. LARA is a domain-specific language inspired by AOP concepts, having the specification of source-to-source transformations as one of its main goals. LARA has been designed to be, as much as possible, independent of the target language and to provide constructs and semantics that ease the definition of concerns, especially related to non-functional requirements. In this paper, we propose techniques to overcome some of the challenges presented by a multilanguage approach to AOP of cross-cutting concerns focused on non-functional requirements and applied through the use of a weaving process. The techniques mainly focus on providing well-defined library interfaces that can have concrete implementations for each supported target language. The developer uses an agnostic interface and the weaver provides a specific implementation for the target language. We evaluate our approach using 8 concerns with varying levels of language agnosticism that support 4 target languages (C, C++, Java and MATLAB) and show that the proposed techniques contribute to more concise LARA aspects, high reuse of aspects, and to significant effort reductions when developing weavers for new imperative, object-oriented programming languages.

On the Effectiveness of Contracts as Test Oracles in the Detection and Diagnosis of Functional Faults in Concurrent Object-Oriented Software

Design by contract (DbC) is a software development methodology that focuses on clearly defining the interfaces between components to produce better quality object-oriented software. Though there exists ample support for DbC for sequential programs, applying DbC to concurrent programs presents several challenges. Using Java as the target programming language, we tackle such challenges by augmenting the Java Modelling Language (JML) and modifying the JML compiler (jmlc) to generate runtime assertion checking code to support DbC in concurrent programs. We applied our solution in a carefully designed case study on a highly concurrent industrial software system from the telecommunications domain to assess the effectiveness of contracts as test oracles in detecting and diagnosing functional faults in concurrent software. Based on these results, clear and objective requirements are defined for contracts to be effective test oracles for concurrent programs whilst balancing the effort to design them. Effort is measured indirectly through the contract complexity measure (CCM), a measure we define. Main results include that contracts of a realistic level of completeness and complexity can detect around 76 percent of faults and reduce the diagnosis effort for such faults tenfold. We, therefore, show that DbC can be applied to concurrent software and can be a valuable tool to improve the economics of software engineering.

Automatic code generation of SIMUROSOT game strategies

Robot soccer is a multidisciplinary research field of growing academic interest. Scientific competitions worldwide have driven major technological advances in the field, since research institutes and universities often enroll their robotic teams and present the developments achieved during the previous year. The FIRA is a leading international organization that promotes such type of competition. One of its various competition categories is that of virtual robots competing in a simulation platform called SIMUROSOT. This 3D simulation platform is available so that researchers and students can develop robot teams and test their performance appropriately and repeatedly. The major problem with the mainstream encoding mechanism used in the preparation of robot teams for SimuroSot is the lack of a formal process to standardize the programming and model the game strategies. Such lack of standardization causes several limitations on the competition as a science promoter, namely: (1) the difficulty of understanding other's code, (2) absence of abstraction for the conceiving of game strategies, (3) need for high programming skills in order to produce effective game strategies and (4) lack of clear separation between robots movimentation primitives and specific application domain concerns - in this case, the soccer domain. This paper proposes a semi-formal specification for the modeling of team game strategies to the FIRA SIMUROSOT category. This specification defines two levels of mapping: (1) mapping of the application domain information - in this case, the soccer competition - to Finite State Machines and (2) mapping of Finite State Machines that represent game strategies of a team to their respective coding in a target programming language, making use of coding standards that ensure the readability and maintainability of the final code. Encodings of game strategies in the programming language Lingo has been provided following the proposal. The error-free execution of such encodings on the simulation platform shows the proposal feasibility.

Proving acceptability properties of relaxed nondeterministic approximate programs

Approximate program transformations such as skipping tasks [29, 30], loop perforation [21, 22, 35], reduction sampling [38], multiple selectable implementations [3, 4, 16, 38], dynamic knobs [16], synchronization elimination [20, 32], approximate function memoization [11],and approximate data types [34] produce programs that can execute at a variety of points in an underlying performance versus accuracy tradeoff space. These transformed programs have the ability to trade accuracy of their results for increased performance by dynamically and nondeterministically modifying variables that control their execution. We call such transformed programs relaxed programs because they have been extended with additional nondeterminism to relax their semantics and enable greater flexibility in their execution. We present language constructs for developing and specifying relaxed programs. We also present proof rules for reasoning about properties [28] which the program must satisfy to be acceptable. Our proof rules work with two kinds of acceptability properties: acceptability properties [28], which characterize desired relationships between the values of variables in the original and relaxed programs, and unary acceptability properties, which involve values only from a single (original or relaxed) program. The proof rules support a staged reasoning approach in which the majority of the reasoning effort works with the original program. Exploiting the common structure that the original and relaxed programs share, relational reasoning transfers reasoning effort from the original program to prove properties of the relaxed program. We have formalized the dynamic semantics of our target programming language and the proof rules in Coq and verified that the proof rules are sound with respect to the dynamic semantics. Our Coq implementation enables developers to obtain fully machine-checked verifications of their relaxed programs.

Parse-matrix evolution for symbolic regression

Data-driven model is highly desirable for industrial data analysis in case the experimental model structure is unknown or wrong, or the concerned system has changed. Symbolic regression is a useful method to construct the data-driven model (regression equation). Existing algorithms for symbolic regression such as genetic programming and grammatical evolution are difficult to use due to their special target programming language (i.e., LISP) or additional function parsing process. In this paper, a new evolutionary algorithm, parse-matrix evolution (PME), for symbolic regression is proposed. A chromosome in PME is a parse-matrix with integer entries. The mapping process from the chromosome to the regression equation is based on a mapping table. PME can easily be implemented in any programming language and free to control. Furthermore, it does not need any additional function parsing process. Numerical results show that PME can solve the symbolic regression problems effectively.

Interoperable domain‐specific languages families for code generation

SUMMARYThis paper has been motivated by experience gained with specification and code generation of control elements for a software component platform and general‐purpose programming language like Java and C. The problem to be addressed is two‐fold: first, several domain‐specific languages (DSL) are to be employed to express different element concerns (architecture, deployment context, code pattern) and second, porting to another general‐purpose language should avoid modification of the specification and related code generation process as much as possible. In both respects, the classical template‐based code generation technique proved to be inflexible, requiring the code generator to be blurred with ad hoc encoded DSL facets. The paper addresses the problem by introducing the concept of interoperable DSL family. Each member of the family is built around its core language, which can be further specialized by embedding into a target programming language. Interoperability of these DSLs is achieved at the level of abstract syntax trees (ASTs) with help of queries. As a proof of the concept, we have implemented the queries via the AST transformation rules of the Stratego/XT framework. In the evaluation, we provide a comparison with the original template‐based implementation, which clearly indicates the DSL family and AST transformation benefits. We also provide examples of application areas where the concept of interoperable DSL family can be employed (and also indicate how this can be accomplished). Copyright © 2012 John Wiley & Sons, Ltd.

Problems and Perspectives of Code Generation from UML Class Diagram

Problems and Perspectives of Code Generation from UML Class Diagram As a result of increasing technological diversity, more attention is being focused on model driven architecture (MDA), and its standard - Unified Modeling Language (UML). UML class diagrams require correct diagram notation mapping to target programming language syntax under the framework of MDA. Currently there are plenty of CASE tools which claim that they are able to generate the source code from UML models. Therefore by combining the knowledge of a programming language, syntax rules and UML class diagram notation semantic, an experimental model for stressing the code generator can be produced, thus allowing comparison of quality of the transformation result. This paper describes a creation of such experimental models.

Automated and parallel code generation for finite-differencing stencils with arbitrary data types

Abstract Finite-Differencing and other regular and direct approaches to solving partial differential equations (PDEs) are methods that fit well on data-parallel computer systems. These problems continue to arise in many application areas of computational science and engineering but still offer some programming challenges as they are not readily incorporated into a general standard software library that could cover all possible PDEs. Achieving high performance on numerical solutions to PDEs generally requires exposure of the field data structures and application of knowledge of how best to map them to the memory and processing architecture of a particular parallel computer system. Stencil methods for solving PDEs are however readily implemented as semi-automatically generated skeletal frameworks. We have implemented semi-automated stencil source code generators for a number of target programming languages including data-parallel languages such as CUDA for graphics processing units (GPUs). We report on some performance evaluations for our generated PDE simulations on GPUs and other platforms. In this article we focus on (diffusive) PDEs with a non-trivial data type requirement such as having vector or complex field variables. We discuss the issues and compromises involved implementing equation solvers with fields comprising arbitrary data types on GPUs and other current compute devices.

Automatic code generation from high-level Petri-Nets for model driven systems engineering

One of the main concepts of the model driven architecture framework proposed by the OMG is the transformation of platform independent models into either platform dependent ones or into implementations. The latter needs generators which automatically translate models into code of a chosen target programming language. Nowadays most models in systems engineering are created with the UML as standardized set of notations. However, the UML is still largely undefined from a semantical point of view. Automatic code generation from these models is thus only possible if further semantic definitions are provided. Since Petri-Nets are frequently utilized for these purposes, the automatic generation of code from Petri-Nets is an important topic. Starting from this observation, this article gives an overview of different strategies to generate code from high-level Petri-Nets. One of these strategies is due to its characteristics investigated in more detail. Several improvements of the basic idea are introduced and also the impact of these enhancements in terms of efficient execution of generated code is illustrated with a benchmark.