Automatic Source Code Generator Based on AUTOSAR RTE for Vehicular Applications

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 article presents the process Automatic source code generation for ChatBot using the Model Driven Development (MDD) for Facebook Messaging platform. We propose the use of metamodel to define the ChatBot, including the option of consuming external REST services. Two test scenarios are presented: the first one is a ChatBot oriented to the sales of pizzas and hamburgers, which requires to obtain external information (REST services) on the ingredients and the search for commercial establishments that satisfy the options defined by the user. Our second test scenario is aligned with elements of IoT (Internet Of Things), specifically manages the sensors of a Sense Hat on a RaspBerry Pi 3 card, considering sensors such as: humidity, temperature, pressure, accelerometer and an actuator represented by a Led matrix. Finally, the results of each of the ChatBot are shown. these are automatically generated from the conceptual specification. The Chatbots are deployed on the Facebook platform validating the consumption of information from external REST services.

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.

The low-code approach is an important area of research being developed to improve the rapid creation and performance of software applications. This approach allows developers and users to easily create software applications through an interactive interface. Existing research shows that the low-code approach accelerates the development process in innovative ways, saves effort and time, and reduces code complexity. This study analyses and compares automatic code generation and transformation techniques in low-code platforms. The study analyses the contributions of automatic code generation and transformation to software engineering processes and evaluates the impact of these techniques on software product quality and development speed. The importance of the Model-Based Development (MBD) approach in automated code generation processes is highlighted. It is stated that MBD provides benefits such as speeding up the software development process and reducing errors by enabling automatic code generation from high-level abstract models. In the study, various literature studies were evaluated to examine the impact of automatic code generation and transformation techniques on the application development process. These studies have shown how automatic code generation and transformation techniques are applied, what results are achieved and what contributions these techniques make to the software development process. The results of the study show that automatic code generation and transformation techniques have a great impact on the application development process. In particular, the acceleration of the software development process, the reduction of errors and the ability to produce more effective and efficient software products are important benefits of these techniques. In addition, it has been found that this approach increases the success of software projects by enabling software developers to produce fast and accurate solutions in complex systems. In this context, the importance of automatic code generation and transformation techniques plays an important role in software development processes.

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.

The rise of the number and complexity of pervasive systems is a fact. Pervasive systems developers need advanced development methods in order to build better systems in an easy way. Software Factories and the Model Driven Architecture (MDA) are two important trends in the software engineering field. This paper applies the guidelines and strategies described by these proposals in order to build a methodological approach for pervasive systems development. Software Factories are based on the definition of software families supported by frameworks. Individual systems requirements are specified by means of domain specific languages. Following this strategy, our approach defines a framework and a domain specific language for pervasive systems. We use the MDA guidelines to support the development of our domain specific language and the automatic generation of the specific source code of a particular system. The approach presented in this paper raises the abstraction level in the development of pervasive systems and provides high reusable assets to reduce the effort in the development projects.KeywordsModel TransformationGraph TransformationSoftware Product LineGraph GrammarMeeting RoomThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Many safety-critical real-time embedded systems need to meet stringent timing constraints such as preserving delay bounds between input and output events. In model-based development, a system is often implemented by using a code generator to automatically generate source code from system models, and integrating the generated source code with a platform. It is challenging to guarantee that the implemented systems preserve required timing constraints, because the timed behavior of the source code and the platform is closely intertwined. In this paper, we address this challenge by proposing a model transformation approach for the code generation. Our approach compensates the platform-processing delays by adjusting the timing parameters in system models, based on an Integer Linear Programming problem formulation. We demonstrate the usefulness of our approach via a case study of infusion pump systems. Experimental results show that the code generated using our approach can better preserve the timing constraints.

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.

Generating tools from graph-based specifications

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.

Aging societies, labor shortages and increasing wage costs call for assistance robots capable of autonomously performing a wide array of real-world tasks. Such open-ended robotic manipulation requires not only powerful knowledge representations and reasoning (KR&R) algorithms, but also methods for humans to instruct robots what tasks to perform and how to perform them. In this paper, we present a system for automatically generating executable robot control programs from human task demonstrations in virtual reality (VR). We leverage common-sense knowledge and game engine-based physics to semantically interpret human VR demonstrations, as well as an expressive and general task representation and automatic path planning and code generation, embedded into a state-of-the-art cognitive architecture. We demonstrate our approach in the context of force-sensitive fetch-and-place for a robotic shopping assistant. The source code is available at https://github.com/ease-crc/vr-program-synthesis.

Signature-based control flow monitoring is a representative technique for detecting control flow errors in run time. However, it is very inefficient and time consuming to manually insert the monitoring code into a monitor-target application. In particular, for performance improvements of control-flow monitoring, implementing a monitoring code that operates in multi-thread makes things more complicated. In this paper, we propose an automatic code-generation framework that automatically translate an application into the control-flow monitorable application. In the proposed framework, the applied technique for control-flow monitoring is based on separate signature-based control-flow monitoring (SSCFM) technique that is able to expect performance improvements in multi-threaded or multi-core environments by separating the signature update and the signature verification on the thread level. The proposed framework automatically analyzes a monitor-target application and generates a SSCFM-applied application based on the analysis results. We anticipate that our automatic multi-thread code generation framework for control flow monitoring lessens the burden in runtime control-flow monitoring field.

Pretrained Language Models for Automatic Source Code Generation: Evaluation and Application

The most important element of industrial software development is the creation of a common vocabulary of terms for exchanging information between software and industrial engineers. Based on this cooperation, technical domain knowledge is converted into data structures, algorithms and rules. Currently, when people are used to receiving short and quick messages, the most efficient way of knowledge extraction is work on examples or mockups to facilitate better understanding of the problem. Shorter rounds in the presentation of mockups allows continuous work on live object models rather than specifications which make experts more open for sharing their knowledge and provides quicker and more reliable feedback on the data structure and the completeness of the model. Latest research and progress in the area of Model Driven Architecture (MDA) resulted in advanced tools for the creation of models, automatic source code generation as well as whole frameworks for creating application skeletons based on these models. In this paper a collaborative process which uses MDA approach (model, tools and frameworks) for extracting knowledge from domain experts is presented. During presented process, a cooperation of a software engineer and a domain expert via phone calls and one live workshop resulted in a complete model of machine and drive including specific machine features and diagnostic processes. Finally, a working diagnostics application was verified by the domain expert proving that MDA resulted in the expected results. The diagnostics application was verified on real data collected on the winding machine for more than one month, collected diagnostics data included more than 150 signals and 20Gb of raw analog data to dig into before getting condensed diagnostics results. Additionally to the process itself, the article presents identified risks, benefits from applying the MDA approach and lessons learned from applying this new innovative process. For further work, the possibilities of extending and dynamically extending existing models should be studied. In previous works we have focused on an ontology based approach, which does not meet all expectations when it comes to application in real world environment. As simpler and more mature technology, MDA was shown to be more productive and easier to adapt for building industrial applications.

A free visual programming-based image analysis development environment for medical imaging applications called NeatVision was developed to provide high-level access to a wide range of image processing algorithms through a well-defined, easy-to-use graphical interface. The system contains over 300 image manipulation, processing, and analysis algorithms. For more advanced users, an upgrade path is provided to extend the core library with use of the developer's interface, giving users access to additional plug-in features, automatic source code generation, compilation with full error feedback, and dynamic algorithm updates. NeatVision was designed to allow users at all levels of expertise to focus on the computer vision design task for computer-aided diagnostic (CAD) applications rather than the subtleties of a particular programming language. The environment allows the designers of image analysis-based CAD techniques to implement their ideas in a dynamic and straightforward manner. Both NeatVision standard and developer's versions can be downloaded free of charge from the Internet and can run on a variety of computer platforms.