Source Code Generation Research Articles

Generating Adversarial Examples for Holding Robustness of Source Code Processing Models

Automated processing, analysis, and generation of source code are among the key activities in software and system lifecycle. To this end, while deep learning (DL) exhibits a certain level of capability in handling these tasks, the current state-of-the-art DL models still suffer from non-robust issues and can be easily fooled by adversarial attacks.Different from adversarial attacks for image, audio, and natural languages, the structured nature of programming languages brings new challenges. In this paper, we propose a Metropolis-Hastings sampling-based identifier renaming technique, named \fullmethod (\method), which generates adversarial examples for DL models specialized for source code processing. Our in-depth evaluation on a functionality classification benchmark demonstrates the effectiveness of \method in generating adversarial examples of source code. The higher robustness and performance enhanced through our adversarial training with \method further confirms the usefulness of DL models-based method for future fully automated source code processing.

Methodology and Tools for Designing Binary Neural Networks

This paper presents results of a research in the field of software development, design methods, as well as training and synthesis of binary neural networks. The research is based on the model of a biomorphic neuron proposed by A.A. Zhdanov, which features noise immunity and is capable of forgetting and additional training. Software tools for designing and visualizing the modeling of binary neural structures are described. Use cases and features of a formal markup language for neural network models, as well as principles of generating deep learning structures, are discussed. A neural network markup language interpreter can automatically generate source code in Verilog with the description of the neural-like implementation of intelligent systems for software and hardware solutions on programmable logic devices (PLDs).

Язык PDA для динамического анализа криптографических протоколов

Purpose of the article: development of an algorithm for dynamic analysis of the source codes of cryptographic protocols using the PDA language for the possibility of using your own attack models. Method: a source code generation method was used to simulate the attacker’s side when transmitting messages between legal parties according to the Dolev-Yao model. The method of false termination is also used, which is used in dynamic analysis and allows detecting attacks during simulation. Results: this paper presents the PDA language for dynamic analysis of the source codes of cryptographic protocols. An approach to dynamic analysis based on the principle of false termination is described. The process of modeling an active attack by an intruder is presented. The elements of the PDA language are described and an example of the description of the test protocol in this language is given. A test protocol in the C# programming language has been implemented. The effectiveness of the dynamic analysis was tested by simulating a replay attack. The security verification of the test cryptographic protocol was carried out using the well-known verification tools Scyther and Avispa. The comparison of the main indicators of the known means and the dynamic protocol analyzer proposed by the authors is carried out. The main advantages of the approach proposed by the authors are presented. The further direction of work is described.

MoDAr-WA: Tool Support to Automate an MDA Approach for MVC Web Application

Model-driven engineering (MDE) uses models during the application development process. Thus, the MDE is particularly based on model-driven architecture (MDA), which is one of the important variants of the Object Management Group (OMG). MDA aims to generate source code from abstract models through several model transformations between, and inside the different MDA levels: computation independent model (CIM), platform independent model (PIM), and platform specific model (PSM) before code. In this context, several methods and tools were proposed in the literature and in the industry that aim to automatically generate the source code from the MDA levels. However, researchers still meet many constraints—model specifications, transformation automation, and level traceability. In this paper, we present a tool support, the model-driven architecture for web application (MoDAr-WA), that implements our proposed approach, aiming to automate transformations from the highest MDA level (CIM) to the lowest one (code) to ensure traceability. This paper is a continuity of our previous works, where we automate transformation from the CIM level to the PIM level. For this aim, we present a set of meta-models, QVT and Acceleo transformations, as well as the tools used to develop our Eclipse plug-in, MoDAr-WA. In particular, we used QVT rules for transformations between models and Acceleo for generating code from models. Finally, we use MoDAr-WA to apply the proposed approach to the MusicStore system case study and compare the generated code from CIM to the original application code.

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.

Symbolic Tensor Neural Networks for Digital Media – from Tensor Processing via BNF Graph Rules to CREAMS Applications

This tutorial material on Convolutional Neural Networks (CNN) and its applications in digital media research is based on the concept of Symbolic Tensor Neural Networks. The set of STNN expressions is specified in Backus-Naur Form (BNF) which is annotated by constraints typical for labeled acyclic directed graphs (DAG). The BNF induction begins from a collection of neural unit symbols with extra (up to five) decoration fields (including tensor depth and sharing fields). The inductive rules provide not only the general graph structure but also the specific shortcuts for residual blocks of units. A syntactic mechanism for network fragments modularization is introduced via user defined units and their instances. Moreover, the dual BNF rules are specified in order to generate the Dual Symbolic Tensor Neural Network (DSTNN). The joined interpretation of STNN and DSTNN provides the correct flow of gradient tensors, back propagated at the training stage. The proposed symbolic representation of CNNs is illustrated for six generic digital media applications (CREAMS): Compression, Recognition, Embedding, Annotation, 3D Modeling for human-computer interfacing, and data Security based on digital media objects. In order to make the CNN description and its gradient flow complete, for all presented applications, the symbolic representations of mathematically defined loss/gain functions and gradient flow equations for all used core units, are given. The tutorial is to convince the reader that STNN is not only a convenient symbolic notation for public presentations of CNN based solutions for CREAMS problems but also that it is a design blueprint with a potential for automatic generation of application source code.

Multiparty Session Type-safe Web Development with Static Linearity

Modern web applications can now offer desktop-like experiences from within the browser, thanks to technologies such as WebSockets, which enable low-latency duplex communication between the browser and the server. While these advances are great for the user experience, they represent a new responsibility for web developers who now need to manage and verify the correctness of more complex and potentially stateful interactions in their application. In this paper, we present a technique for developing interactive web applications that are statically guaranteed to communicate following a given protocol. First, the global interaction protocol is described in the Scribble protocol language -- based on multiparty session types. Scribble protocols are checked for well-formedness, and then each role is projected to a Finite State Machine representing the structure of communication from the perspective of the role. We use source code generation and a novel type-level encoding of FSMs using multi-parameter type classes to leverage the type system of the target language and guarantee only programs that communicate following the protocol will type check. Our work targets PureScript -- a functional language that compiles to JavaScript -- which crucially has an expressive enough type system to provide static linearity guarantees. We demonstrate the effectiveness of our approach through a web-based Battleship game where communication is performed through WebSocket connections.

Проектування програми візуалізації земної поверхні з використанням алгебро-алгоритмічного інструментарію

One of the important challenges in meteorological forecasting is a computer visualization of prognosis data, in particular, three-dimensional modeling of terrain surface relief. One of the most popular software tools for developing data visualization applications is OpenGL, a cross-language, cross-platform application programming interface for rendering two-dimensional and three-dimensional vector graphics. Data visualization is a fairly complex task, therefore it is necessary to develop special tools intended for automated generation of source code for such tasks. The paper deals with the further development of previously developed algebra-algorithmic tools in the direction of automated design and synthesis of OpenGL programs. Automated construction of programs is implemented using a high-level language based on Glushkov’s system of algorithmic algebra. The approach is illustrated on designing a terrain surface relief visualization program for weather forecasting task.

Генерация исходных кодов для тематических коллекций научных данных

Генерация исходных кодов для тематических коллекций научных данных

Desarrollo de Sistemas Distribuidos de Tiempo Real y de Criticidad Mixta a través del Estándar DDS

<p>El uso de middleware de distribución facilita la programación de sistemas distribuidos de tiempo real heterogéneos, y por extensión también puede facilitar la generación automática de código como parte de una estrategia de desarrollo basada en modelos. Sin embargo, esta clase de middleware presenta una complejidad añadida que dificulta su uso en sistemas con ciertos requisitos de criticidad o de tiempo real. En este trabajo se hace una revisión de algunos estudios previos en los que se muestra la posibilidad de utilizar un middleware de distribución centrado en los datos (DDS, Data Distribution Service) para la integración de aplicaciones con criticidad mixta en sistemas distribuidos.</p>

A Multiple Phases Approach for Design Patterns Recovery Based on Structural and Method Signature Features

Design patterns describe both structure, behavior of classes and their relationships. They can improve software documentation, speed up the development process and enable large-scale reuse of software architectures. This article presents a multiple levels detection approach (MLDA) to recover design pattern instances from Java source code. MLDA is able to recover design pattern instances based on a generated class level representation of a subject system. Specifically, MLDA presents what is the so-called Structural Search Model (SSM) which incrementally builds the structure of each design pattern based on the generated source code model. Moreover, MLDA uses a rule-based approach to match the method signatures of the candidate design instances to that of the subject system. As the experiment results illustrate, MLDA is able to recover 23 design patterns with reasonable detection accuracy.

Mosaicode and the visual programming of web application for music and multimedia


 
 
 The development of audio application demands a high knowledge about this application domain, traditional program- ming logic and programming languages. It is possible to use a Visual Programming Language to ease the application development, including experimentations and creative exploration of the language. In this paper we present a Visual Programming Environment to create Web Audio applications, called Mosaicode. Different from other audio creation platforms that use a visual approach, our environment is a source code generator based on code snippets to create complete applications.
 
 
 

Moving Object Detection Using a Parallax Shift Vector Algorithm

There are various algorithms currently in use to detect asteroids from ground-based observatories, but they are generally restricted to linear or mildly curved movement of the target object across the field of view. Space-based sensors in high inclination, low Earth orbits can induce significant parallax in a collected sequence of images, especially for objects at the typical distances of asteroids in the inner solar system. This results in a highly nonlinear motion pattern of the asteroid across the sensor, which requires a more sophisticated search pattern for detection processing. Both the classical pattern matching used in ground-based asteroid search and the more sensitive matched filtering and synthetic tracking techniques, can be adapted to account for highly complex parallax motion. A new shift vector generation methodology is discussed along with its impacts on commonly used detection algorithms, processing load, and responsiveness to asteroid track reporting. The matched filter, template generator, and pattern matcher source code for the software described herein are available via GitHub.

A Systematic Literature Review on the Application of Ontologies in Automatic Programming

One of the main goals of the Software Engineering discipline is to find higher abstraction levels and ways to reuse software in order to increase its productivity and quality. Ontologies, which are typically considered as a technique or an artifact used in one or more software lifecycle phases, may be used to help achieve that goal. This paper provides a systematic literature review of the proposed solutions for applying ontologies in automatic and generative programming. The paper aims to identify ontologies and software development tools, frameworks, prototypes, design patterns and methodologies that use them as development artifacts for source code generation or product derivation. The review provides researchers with the state of the art, while also identifying challenges and gaps that require further exploration and development.

Shock-wave/boundary-layer interactions in the automatic source-code generation framework OpenSBLI

Laminar shock-wave/boundary-layer interactions were simulated using OpenSBLI, a Python-based source code generation framework. Shock-capturing was performed by a 5th order finite-difference Weighted Essentially Non-Oscillatory (WENO)-Z scheme applied in characteristic space. Oblique shock conditions were imposed for a shock angle of θ=32.58∘ and Mach 2 free-stream, impinging on a laminar flat-plate boundary-layer. Performance of the code was assessed on different architectures for CPU, GPU and Xeon Phi.

MODEL CHECKING EARLY REQUIREMENTS SPECIFICATIONS IN ALLOY

Automation generated source code and verifying are essential sector for software engineering. There are many ways to generate source code and verify from the specification languages. In this paper, we propose an approach that automatically generated code from a specification language Alloy. From this specification language, we will describe how to translate from one language to the Java source. An application in this paper is a gardening game program. Applied after the findings will be organized according to the MVC (Model-View-Controller) architectural pattern. Besides, we will also verify the identity of the structure of the application and the content of the Alloy specification. We built an tool as GmDSL, we have verified the aplication in GmDSL. The application was created from the tool also shows the correctness of the early constraints. Simultaneously, we also compares be verified through the GmDSL tool with NuSVM tool.

Построение модульного программного обеспечения на основе однородной компонентой модели

Modern real-time operating systems are complex embedded product made by many vendors: OS vendor, board support package vendor, device driver developers, etc. These operating systems are designed to run on different hardware; the hardware often has limited memory. Embedded OS contains many features and drivers to support different hardware. Most of the drivers are not needed for correct OS execution on a specific board. OS is statically configured to select drivers and features for each board. Modularity of OS simplifies both configuration and development. Splitting OS to isolated modules with well-specified interfaces reduces developers’ needs to interact during joint development. The configurator, in turn, can easily compose isolated components without component developers. We use formal models to specify components and their composition. Formal model describes the behavior of components and their interaction. Usage of formal models has many benefits. Models contain enough information to generate source code in C language. Our model is executable; this allows configurator to quickly verify the correctness of component configurations. Moreover, model contains constraints on its parameters. These constraints are internal consistency or some external properties. Constraints are translated into asserts in generated source code. Therefore, we can check these constraints both at model simulation and at source code execution. This paper presents our approach to describe such models at Scala language. We successfully tested the approach in RTOS JetOS.

Systematic mapping study of template-based code generation

Context: Template-based code generation (TBCG) is a synthesis technique that produces code from high-level specifications, called templates. TBCG is a popular technique in model-driven engineering (MDE) given that they both emphasize abstraction and automation. Given the diversity of tools and approaches, it is necessary to classify existing TBCG techniques to better guide developers in their choices.Objective: The goal of this article is to better understand the characteristics of TBCG techniques and associated tools, identify research trends, and assess the importance of the role of MDE in this code synthesis approach.Method: We survey the literature to paint an interesting picture about the trends and uses of TBCG in research. To this end, we follow a systematic mapping study process.Results: Our study shows, among other observations, that the research community has been diversely using TBCG over the past 16 years. An important observation is that TBCG has greatly benefited from MDE. It has favored a template style that is output-based and high-level modeling languages as input. TBCG is mainly used to generate source code and has been applied to many domains.Conclusion: TBCG is now a mature technique and much research work is still conducted in this area. However, some issues remain to be addressed, such as support for template definition and assessment of the correctness and quality of the generated code.

A Computationally Efficient Implementation of Tabulated Combustion Chemistry based on Polynomials and Automatic Source Code Generation

The simulation of turbulent combustion is a multiphysics and multiscale problem, in which two different domains - fluid mechanics and chemistry - have to be coupled. One solution is a CFD-based simulation framework that performs lookups on tabulated chemistry using flamelets. The tables can become very large when the resolution is increased and modelling parameters and solution values are added. This makes dynamic memory management and its runtime requirements a crucial issue in these simulations. A novel approach for the efficient memory management of tabulated chemistry at reduced computational cost is developed in this study. The original interpolation-focused database is converted into a polynomial description, which is stored in a shared library as a set of functions. This step enables automatic compiler optimization techniques to achieve minimal data movement and the best use of modern computer architecture. The performance and properties of the method are evaluated in a generic test case and a fully coupled flame simulation.

Translation of ATL to AGT and application to a code generator for Simulink

Analysing and reasoning on model transformations has become very relevant for various applications such as ensuring the correctness of transformations. ATL is a model transformation language with rich semantics and a focus on usability, making its analysis not straightforward. Conversely, algebraic graph transformation (AGT) is an approach with strong theoretical foundations allowing for formal analyses that would be valuable in the context of ATL. In this paper, we propose a translation of ATL to the AGT framework in the objective of bringing theoretical analyses of AGT to ATL transformations. We show that this transformation supports a sufficient subset of ATL to be used on an industrial application example: QGen, a qualifiable Simulink\(^{\circledR }\) to source code generator developed at AdaCore. In addition to this example, we validate our proposal by translating a set of feature-rich ATL transformations to the Henshin AGT framework. We execute the ATL and AGT versions on the same set of models and verify that the result is the same.