Platform-Specific Code Generation from Platform-Independent Timed Models

Decompilation, recovering source code from binary, is useful in many situations where it is necessary to analyze or understand software for which source code is not available. Source code is much easier for humans to read than binary code, and there are many tools available to analyze source code. Existing decompilation techniques often generate source code that is difficult for humans to understand because the generated code often does not use the coding idioms that programmers use. Differences from human-written code also reduce the effectiveness of analysis tools on the decompiled source code. To address the problem of differences between decompiled code and human-written code, we present a novel technique for decompiling binary code snippets using a model based on Recurrent Neural Networks. The model learns properties and patterns that occur in source code and uses them to produce decompilation output. We train and evaluate our technique on snippets of binary machine code compiled from C source code. The general approach we outline in this paper is not language-specific and requires little or no domain knowledge of a language and its properties or how a compiler operates, making the approach easily extensible to new languages and constructs. Furthermore, the technique can be extended and applied in situations to which traditional decompilers are not targeted, such as for decompilation of isolated binary snippets; fast, on-demand decompilation; domain-specific learned decompilation; optimizing for readability of decompilation; and recovering control flow constructs, comments, and variable or function names. We show that the translations produced by this technique are often accurate or close and can provide a useful picture of the snippet's behavior.

This paper describes the IOPT-Tools cloud-based tool-chain, offering a complete set of tools supporting design automation for embedded controller’s development, benefiting from adopting a model-driven development attitude. The tools are freely available online at http://gres.uninova.pt/IOPT-Tools/ . The tool-chain relies on IOPT nets (Input-Output Place-Transition nets) to describe the controller behavior, allowing an explicit representation of constraints on input and output signals and events, which is necessary for the development of controllers. The IOPT-Tools tool-chain includes tools for interactive graphical IOPT nets models editing, simulation and test (token-player, timing diagram, remote debugging), as well as a state-space generator, state-space visualization, and a query system for properties verification. The tool-chain also supports the automatic generation of execution code to be directly deployed in the controllers’ implementation platforms, such as FPGA boards, as well as Arduino, Raspberry, and other Linux-based boards. Most notably, it is possible to obtain C code and VHDL code to be directly deployed into the referred boards without writing/changing a line in the generated code. The tool-chain uses the PNML format for storing the models and can import PNML models generated by other frameworks, automatically generating, if necessary, an associated graphical representation. After, it is possible to add input and output signals and events to create controller models. IOPT-Tools also supports net operations, namely net addition, allowing composition of sub-models, and net splitting, which in conjunction with the use of clock domains and dedicated communication channels support the development of distributed controllers.

Formal specifications of software systems are extremely useful because they can be rigorously analyzed, verified, and validated, giving high confidence that the specification captures the desired behavior. To transfer this confidence to the actual source code implementation, a formal link is needed between the specification and the implementation. Generating the implementation directly from the specification provides one such link. A program transformation system such as Paige's APTS can be useful in developing a source code generator. This paper describes a case study in which APTS was used to produce code generators that construct C source code from a requirements specification in the SCR (Software Cost Reduction) tabular notation. In the study, two different code generation strategies were explored. The first strategy uses rewrite rules to transform the parse tree of an SCR specification into a parse tree for the corresponding C code. The second strategy associates a relation with each node of the specification parse tree. Each member of this relation acts as an attribute, holding the C code corresponding to the tree at the associated nodes the root of the tree has the entire C program as its member of the relation. This paper describes the two code generators supported by APTS, how each was used to synthesize code for two example SCR requirements specifications, and what was learned about APTS from these implementations.

We propose a new approach to an automatic source code generator for the AUTOSAR-based vehicular software. The growing number of electrics/electronics software in vehicle systems makes more and more necessary the increasing demands. For example, it needs the essential requirements such as ensuring reliability, low production cost, coping with limited resources, and so on. Recently, there have been relative studies that point to this issue. An AUTOSAR development partnership is such a case. AUTOSAR is a standardized automotive software architecture which is an alliance of OEM and supplier. Now, the focus is mainly directed at a source code generator that deals with the AUTOSAR standard concept. In this paper, we present a novel source code generator which is based on the AUTOSAR software platform. The experimental process is presented to functionally verify the module, and structurally verify the generated source code.

This paper presents a new Web based Petri net Editor employing AJAX principles to allow the interactive design and edition of Petri net models using standard Web browsers. The editor includes an integrated plug-in architecture to simplify the addition of generic net operations without requiring the manipulation of internal editor data-structures. IOPT-nets are a non-autonomous Petri net class targeting the model-based development of embedded system controllers and combine the well know properties of Petri nets with input and output signals and events to establish the communication of controllers with the external world. The editor is a part of the IOPT-tools Web service that also contains model-checking and automatic code-generation tools, supporting a complete model-based development work-flow, starting from model design to the final controller code generation. All tools are available at the research group Web page (http://gres.uninova.pt).

Deep Learning (DL) techniques for Natural Language Processing have been evolving remarkably fast. Recently, the DL advances in language modeling, machine translation, and paragraph understanding are so prominent that the potential of DL in Software Engineering cannot be overlooked, especially in the field of program learning. To facilitate further research and applications of DL in this field, we provide a comprehensive review to categorize and investigate existing DL methods for source code modeling and generation. To address the limitations of the traditional source code models, we formulate common program learning tasks under an encoder-decoder framework. After that, we introduce recent DL mechanisms suitable to solve such problems. Then, we present the state-of-the-art practices and discuss their challenges with some recommendations for practitioners and researchers as well.

Towards the Software Autogeneration

Multi-Agent Based Intelligent Tutoring System Source Code Generation Using MASITS ToolSeveral agent development tools have been proposed. At the same time, specific tools for agent based Intelligent Tutoring System (ITS) development do not exist. However, ITSs have some specific characteristics that must be taken into consideration during the development. General purpose Agent Oriented Software Engineering (AOSE) methodologies and therefore development tools do not sufficiently correspond to the characteristics of ITSs. Additionally, the general purpose AOSE methodologies and tools do not allow plugging in domain specific rules and diagrams. Thus, usage of knowledge gained in ITS research during the development process is limited. In the absence of general tools that allow plugging in knowledge from ITS research, a specific tool named MASITS has been developed. The tool supports a specific agent based ITS development methodology named MASITS which takes into consideration specific characteristics of ITSs and integrates knowledge from ITS research. The tool supports all phases of ITS development, starting from requirements analysis and ending with deployment. Requirements analysis and design phases are supported by appropriate diagram creation tools. Implementation is supported by source code generation from diagrams created during the design phase. JADE platform is used for agent implementation. Thus, Java classes for ontology, agents and behaviours are generated from the design diagrams. The paper includes a brief overview of diagrams used in the source code generation and detailed algorithms for source code generation from the diagrams.

<div class="htmlview paragraph">Commercial vehicle manufacturers face unique challenges for the development of vehicle electronics systems. For one, customers typically have unique requirements coupled with an expectation of high reliability. Vehicle electronics is often the enabler for customized features. Ensuring that the vehicle will perform as demanded and promised adds a degree of burden on the vehicle manufacturers. Furthermore, the verification and testing of a large number of unique electronic system configurations is very expensive and time-consuming. This paper will explore how Model-Based Design can be used to meet these challenges and provide a high degree of confidence for both the manufacturer and the customer that requirements have been met. It will discuss factors to consider to support configurability, approaches for defining a system architecture that facilitates reuse, and capabilities for modeling state-based systems.</div>

Early phases of the Software Development Life Cycle (SDLC) like requirements elicitation and model design are often critical for the project success. These phases are also linked to several project problems and failure causes, delaying the project finalization and increasing its total cost. Several strategies to mitigate the effects of errors in these early stages have been proposed. Some of these include: GUI based fast prototyping; agile software development methodologies; and, as in this work, automatic model (or source code) generation from a natural language specification. Although these approaches can reduce production time and costs, they can also be slow and imprecise leading to development difficulties. This work proposes an approach to obtain a functional prototype of a web-based process-oriented information system, using only a restricted natural language specification as an input. This approach allows the processing of the input to be faster and more precise than the approaches proposed previously. Two case studies are presented in order to validate the proposal and demonstrate its applicability.

All software systems execute within an environment or context. Reasoning about the correct behavior of such systems is a ternary relation linking the requirements, system and context models. Formal methods are concerned with providing tool (automated) support for the synthesis and analysis of such models. These methods have quite successfully focused on binary relationships, for example: validation of a formal model against an informal one, verification of one formal model against another formal model, generation of code from a design, and generation of tests from requirements. The contexts of the systems in these cases are treated as second-class citizens: in general, the modelling is implicit and usually distributed between the requirements model and the system model. This paper is concerned with the explicit modelling of contexts as first-class citizens and illustrates concepts related to implicit and explicit semantics on an example using the Event B language.KeywordsVerificationmodellingContextsDomains

We present a novel design of a source code generator for distributed automotive systems in this paper. The expanding functional complexity leads to an increase in software embedded defects and several problems. Clearly, software development methods will need to innovate. The AUTOSAR architecture has served as a platform for vehicle applications in leading OEMs and Tier1 suppliers. The standard provides a basic infrastructure for the management of vehicle functions The aim of this research is to add a RTE module for the earlier development tool, and design a new vehicle code generator based on the AUTOSAR platform. The paper also performed code generation process. Through the test, we got error free application source code.

With the rise of data visualization techniques, dashboard engineering has attracted a great deal of attention in the last decade, but has been hampered by a lack of automation tools. In today’s enterprise systems, business users expect dashboards to be more process-oriented in addition to being context-sensitive. While many commercial business intelligence tools offer role-based dashboard, the idea of constructing a process-oriented dashboard has drawn the attention of scholars in recent years. The paper reports on our preliminary work in the generation of such a dashboard by iterating through all the pools and data objects visually depicted in a business process and generating the computer-interpretable source code that represents the corresponding visualization charts. To make this process-oriented dashboard lively visible, we load a real dataset together with the generated source code into a dashboard-rendering library. To demonstrate the relevance of our work, we walk through a real-life digital advertising project and illustrate how a dashboard could be generated and rendered for a given business process.

Graphical languages of various sorts are increasingly used for the specification and the design of high-integrity real-time systems. Their coverage however does not extend with as much success to automated source code generation. Several hurdles cause the model-to-code translation to often lapse in the preservation of the desired semantics. This paper illustrates the choices we have made to provide the HRT-UML design method with an automated Ravenscar-compliant source code generation engine. Compliance with the Ravenscar computational model warrants static analysability of the source code and predictability of execution. By elevating this compliance to the design stage, we earn semantic preservation across the whole development process.

Source code generation is an essential part of wide range of applications, including transcompilers, parser generators and preprocessors. The common technology based on code templates is often cumbersome and error-prone. This paper introduces syngen, an automatic tool, written in Scheme, designed to produce frameworks for building syntactically correct fragments of source code.