Towards the Software Autogeneration

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.

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.

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.

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.

This project introduces a Cloud-Based Web Application for Result Management that revolutionizes the traditional approach to academic result handling. Leveraging the power of cloud computing and distributed systems, the application provides a robust, scalable, and secure platform that ensures real-time data accessibility and management. Designed under a Software-as-a-Service (SaaS) model, the system offers significant operational efficiencies by minimizing manual processes and mitigating errors commonly associated with paper-based or standalone systems.The architecture is built on a multi-tier framework that integrates cloud databases and microservices, ensuring high availability and fault tolerance through load balancing and distributed data processing. Role-based access control is a core feature, granting tailored permissions to students, teachers, and administrators, thereby safeguarding sensitive information and streamlining user interactions.Additionally, the platform is equipped with real-time analytics and reporting tools that provide actionable insights into student performance, enabling institutions to make informed decisions swiftly. Automated notifications and alerts further enhance the user experience by keeping all stakeholders updated on result releases and system activities. By reducing operational overhead and ensuring data integrity, this cloud-based solution not only enhances user satisfaction but also empowers educational institutions to adopt a modern, agile approach to academic administration.Overall, the Cloud-Based Web Application for Result Management stands as a comprehensive solution that addresses the challenges of conventional result management systems while offering a future-proof, scalable, and secure alternative for modern educational environments. Keyword :Cloud Computing,Result Management , SaaS,,Distributed System,Server Scalability

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.

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.

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.

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.

In today’s era of Generative AI, the Large Language Model (LLMs)applications are largely used to generate functioning source code. These applications simply does not require any programming skill except a prompt. However, the LLM generated codes are prone to safety and efficiency concerns. A common safety concerns in popular programming languages source code like Java, C++ and C are SQL injection, pointer dereferencing, improper input validation, etc. There are several academic studies and industry approaches to enable a strong and safe AI code generation such as prompt inversion, formal verification, and many more. In this paper, we analyze both the industry and academic approach to reduce and fix the threats over AI generated code and discussed key findings. The platform like Veracode that uses static analysis, dynamic testing and the platform CrowdStrike working to develop self-learning, multi-agent AI systems that employ Red Teaming capabilities. The academic benchmark like CodeLMSec that proposed black-box vulnerability probing framework, FormAI-v2 applies a large-scale formal verification for C language vulnerabilities, and the CodeSecEval benchmark that is based on prompt inversion to evaluate secure code generation and repair. Our studies on the mentioned benchmark highlights that the currently LLM generated source code persists vulnerabilities due to lack of benchmark dataset. The unsafe code fixes are approached in one direction only, either based on static analysis or dynamic analysis.

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.

Generating tools from graph-based specifications

Since the source code is only one of many types of documents that must be maintained as a software system evolves, modern software development could be improved by better interoperability between source code and other software documents. The Software Concordance is a prototype programming environment that uses hypermedia services and a uniform document model to achieve this interoperability. The Software Concordance editor allows developers to enhance their inline documentation with multimedia objects and hyperlinks, while still supporting advanced program analysis including lexing, parsing and type checking. We motivate the need for environments like the Software Concordance, describe the design and implementation of its program editor, and discuss lessons learned while creating it. The system is based on a uniform, Web compatible document model for both program source code and nonprogram software documents and a corresponding API. Important technical problems addressed by this research include creating a persistent representation of program lexemes that the analysis suite considers to be ephemeral (such as keywords), providing a simple incremental parsing system, and embedding multimedia in source code without disrupting program analysis. Based on insight gained in the process of implementing the document API, a new approach to the design of a more suitable program analysis infrastructure is suggested.