Analysis and Comparison of Automatic Code Generation and Transformation Techniques on Low-Code Platforms

The gap between design and implementation always exists because changes happen frequently throughout software development process, along with rapid release cycles, and accompanied by time constraints and limited resources. The focus of our work is to reduce this gap for service-oriented projects. We proposed an approach which considers both technical strategies and agile methods, trying to streamline the progression from design to implementation at a relatively early phase, and then throughout the whole development lifecycle. Automatic code generation has the potential to reduce above problems to a certain extent. This paper describes our efforts to enable rapid and continuous delivery while leveraging parallelism in development via automatic code generation — specifically making domain models instantly executable. We describe a code generator that has been built to enable parallel development of services. It uses UML class diagram to model the problem domain, then rapidly realize the domain model as a set of NoSQL database collections, automate the generation of common database access functions, and automate the wrapping of these database functions within a set of RESTful APIs. We also consider several common deployment scenarios (e.g. requirements for media-handling, security, scalability) to ensure the flexibility and reusability of the target source code for subsequent development iterations. Several empirical project instances have been built using this code generation technique. Combine with agile methods, we attempt to shorten development schedule in both design and implementation stages, and to eliminate the risks caused by evolutionary development. The result shows a great saving of effort on development and less issues in implementation stage.

A software package for the numerical solution of systems of linear and nonlinear partial differential equations by grid methods is presented, which combines symbolic computations and automatic code generation techniques. Discretization of differential equations is carried out by the methods of finite volumes and finite differences on two-dimensional and three-dimensional regular rectangular grids. The solution of the systems of nonlinear algebraic equations obtained as a result of discretization is performed by Newton’s method with employment of third-party SLAE solvers. The generated code can exploit shared and distributed memory parallelisms and take advantage of heterogeneous computations. The results of the numerical solutions of two sample CFD problems of the fluid flow generation in a cylindrical cavity filled with electrically conductive liquid driven the by traveling and rotating magnetic fields are presented.

The development of avionics software demands more and more human intervention. The software development process is rather highly expensive and risky since it must undergo certification. Automation of such a process can reduce errors and human interaction. Automated development tools usually deal with automatic code generation. These approaches are actually based on pre-defined fixed rules and policies to automatically generate software code which still demands considerable hand-coded software. This paper presents a self-directed development process that is able to make decisions by its own to generate software code. The automated decision-making process relies on a reasoner, and an ontological database that captures development skills from human developers as well as the dynamic configurations and capabilities of the system under development. The knowledge captured enables highlevel reasoning to automatically generate the control software code. A case study based on the development of Embedded Control Software (ECS) for Distributed Aircraft Fuel Management (DAFM) is presented. Details of the reasoning ontology to develop ECS, and experimental results from ECS for DAFM automatically generated are presented.

A new technique for automatic retargetable code generation is presented. This technique is based on the observation that a ‘reduced instruction set’ subset can always be found for a target machine instruction set; the rest of the instructions are seen to be equivalent to sequence of the reduced instruction set instructions. Given a target machine description, a method is presented which partitions it into two: one partition contains the reduced instruction set; the other contains the rest of the instructions, along with corresponding simulation sequences — these simulation sequences are unique with respect to the partition. In view of the above, the code generation problem, more precisely the instruction selection problem, is seen as a sequence of two phases: The first phase generates reduced instruction set code; the second phase finds opportunities for optimization through compaction of sub sequences in the generated code, to complex instructions. The full capability of the target machine can be potentially utilized due to the latter phase. Retargetability is achieved by automatically generating the above phases from the information in the partition. The phases are based on tree-pattern-matching, implemented through LR parsing. The technique has been tested for the MC 68000; simple comparisons show the generated code to be satisfactory.

"Software development is an important area in software engineering, which is why a wide range of techniques, methods, and approaches has emerged to facilitate software development automation. This paper presents an analysis and evaluation of tools for automated software development and automatic code generation in order to determine whether they meet a set of quality metrics. Diverse quality metrics were considered such as effectiveness, productivity, safety, and satisfaction in order to carry out a qualitative and quantitative evaluation. The tools evaluated are CASE tools, frameworks, and Integrated Development Environments (IDEs). The evaluation was conducted to measure not only the tools’ ability to be employed, but also their support for automated software development and automatic source code generation. The aim of this work is to provide a methodology and a brief review of the most important works to identify the main features of these works and present a comparative evaluation in qualitative and quantitative terms of quality metrics. This would provide software developers with the information they need to decide the tools that can be useful for them."

In seeking to maximise opportunity for achieving common understanding and real progress on specific issues, the announcement for the 5th Process Workshop adopts a somewhat narrow view of the role of Process Models. By so focussing the discussion, the fact that desirable characteristics of models will vary with the purpose for which they are to be used, the benefit one hopes to derive from their development or use and the value attached to benefit to gained from such activity has had to be disregarded. Yet process models can serve many purposes as summarised, for example, in the introduction to the Proceedings of the 4th workshop [SPW88] and also on the attached table. Though the roles included in that table are neither newly identified nor controversial they are listed so that they may be kept in the back of our minds as the Workshop discussion progresses.The individual importance of these roles can clearly not be ordered or even quantified. Their relative significance will depend on the goals of the work during which they are developed or used. The primary motivation underlying my work with process models over the past years has been the search for a better understanding of the software development and evolution process. This has led to conclusions which are, perhaps, self evident to many Computer Scientists, [DEM79], [FET88], [VAR79, 89] (as extreme examples) and others [BON77]. They are, however, not widely understood by the general public and, more importantly, by those involved in the definition and acquisition of computer systems for specific applications. In view of the increasing dependence of mankind on computers and, hence, on software it appears important to bring these, explicitly, into the open and to also examine their implications in the narrower confines of the topics discussed in the process workshop series.In the first instance my studies concentrated on an examination of models of program evolution in recognition of the fact that understanding and controlling that phenomenon demanded understanding and control of the programming process [LEH69, 85a]. This investigation led directly to the SPE classification scheme in which E-type programs, in particular, are defined as programs that implement applications or solve problems from and in the real world. In developing this schema process models played a fundamental role [LEH80b]. These models had no direct or immediate relationship to development practice but, nevertheless, led to the insight that is reflected in the LST process model [LEH84] that later formed the conceptual underpinning of a working environment [LEH85b].The work led to the view that an E-Type program is a model of a model of a … model of an application in the real world [LEH80b]. This abstract total-process model was enriched by Turski's view [TUR81] which regarded successive model pairs as a theory and a model of that theory or, equally, as a specification and an implementation of that specification. At the First Process Workshop [SPW84] Turski's interpretation of the “three-legged” model was, in fact, to see both the real world application (concept) and the final implementation as models of a specification that forms the bridge between concept and realisation. Equally, the source and target representations at the core of each step of the LST process, for example, may be viewed as a theory and a model of that theory.From Turski's view it follows that each implementation is Godel incomplete. Its properties, including functional properties, cannot be completely known from within the system. By their involvement in the development process and through system usage humans become an integral part of the system. It is their insights, viewpoints, theories, algorithms, definitions, formalisations, reactions, interpretations and so on that drive and direct the abstraction, refinement and evolution processes. They determine the degree of satisfaction that the final solution system yields. Hence it may be observed that for any software system implementing a solution to a real world problem, modelling some aspect of the real world, there exists a degree of Godel-type uncertainty about its properties [LEH89]. The definition, specification and development process must seek to limit this uncertainty so that it is of no practical significance; reflecting only abstract representational incompleteness.This is not the only type of uncertainty related to program behaviour under execution relative to the operational environment. A primary property of E-type programs is the fact that installation and operation of a system change the application and its operational domain. Implicitly if not explicitly, the system includes a model of itself. Also the acts of conceiving, developing, installing, using and adapting a software system change understanding of the application and its needs, methods of solution, the relative value of specific features of system functionality, opportunities for enhancement and human perception of all these. This leads to declining satisfaction with the system unless the system is adapted to the new reality. Because of the many feedback paths the system displays Heisenberg-type uncertainty [LEH77]. The more precise the knowledge of the application, of system properties and of their respective domains the less satisfaction does the solution system deliver in terms of what are, at the time of usage, the system properties perceived to be desirable. Mismatch between system properties and human needs and desires cannot be removed, except momentarily. Development, adaptation and evolution processes and their management are key to minimisation of the consequences of this inherent uncertainty.There is also a third type of uncertainty. The domain of an E-type application is, in general, unbounded and, effectively, continuous. The solution system is finite and discrete. The process of deriving one from the other involves a variety of abstractions on the basis of assumptions, about the application, its domain, perceived needs and opportunities, human responses to real world and solution system events, computational algorithms, theories about all these and so on. Some assumptions will be explicitly stated, others will be implicit. All will be built into the final system. But the real world is essentially dynamic, forever changing. Even without feedback effects as discussed above, exogenous changes in the real world will change the facts on which the assumption set is based. However careful and complete the control on the validity of assumptions is at the time they are built into the system some, at least, will, at best, be less than fully valid when the program is executed, or better, when the results of execution are applied. That is when, to be fully satisfactory, a program needs to be correct. Initial correctness at the time of implementation is merely a means to an end. The assumption set must be maintained correct without significant delay by appropriate changes to program or documentation texts, an impossible task even if assumptions could be precisely pinpointed. Pragmatic uncertainty in system behaviour is inevitable.This analysis leads to the following Uncertainty Principle for Computer Application: The outcome of software system operation in the real world is inherently uncertain with the precise area of uncertainty also not knowable.This position paper is not the place to explore this assertion in detail. Some aspects have been discussed elsewhere [LEH77, 89]. More immediately the principle throws a new light on the expectations to be associated with Software Engineering, the system and software development process and the models constructed to represent that process. One may have many views of the process. The new one that emerges from the above discussion is of software engineering in general and the software development and evolution (maintenance) process in particular as the means to minimise uncertainty, the consequences of uncertainty and the maintenance of user satisfaction. Project models must reflect this responsibility

Extension of the Modeling Tool Suite for Development of Embedded Systems for the Space Domain

A technique for automatic code generation of USN applications based on Nano-Qplus is proposed in this paper. Nano-Qplus is a sensor network platform developed by ETRI. Programs of nodes such as sensors, routers, sinks and actuators in a sensor network are automatically generated through the technique. Developers can implement USN applications from models of sensor networks. The execution code is generated by setting attribute values of each node according to the model through the script proposed in this paper. Through the technique of this paper, developers can easily implement USN applications even if they do not know the details of low-level information. The development effort of USN applications also will be decreased because execution codes are automatically generated. Furthermore, developers can perform early test through rapid code generation, so the verified code is generated by correcting errors in the early development stage.

<div class="section abstract"><div class="htmlview paragraph">Instrument clusters that display all information on a TFT-LCD screen, also known as reconfigurable instrument clusters, have become the new trend in automotive interiors. DENSO mass-produced the world's first reconfigurable instrument cluster in 2008. To satisfy customer requirements, large quantities of resources were required. Coupled with an iterative process due to requirement changes, development costs became very high. Reducing development costs was vital in order to expand the reconfigurable instrument cluster products line. One solution was to use existing human machine interface (HMI) tools. However, most HMI tools are geared toward software developers and not graphic artists. Furthermore, each tool has its own unique method for image and scene creation, creating an ineffective and sometimes difficult environment for artists familiar with industry-leading computer graphics (CG) software to learn and use the tools. As a result, the artist-to-target workflow suffered from inefficiencies because software developers had to remodel the artists designs created with the CG software. Each time the design was changed, both artists and developers had to reiterate the development process.</div><div class="htmlview paragraph">The instrument cluster is not only a primary source of information to the driver, but also connects the driver to the rest of the vehicle, establishing a somewhat personal relationship between human and machine. It is imperative that the instrument cluster design reflect clarity, precision and beauty. An artist-centric approach was proposed to reduce the development effort by introducing a data converter and real-time 3D rendering engine. The goal was to achieve minimal loss in the development cycle, from concept to production. The artist's idea, as expressed with industry-leading CG software (Autodesk® 3ds Max®), must be precisely replicated at the target level. The new proposed workflow was as followed: First, an artist created a 3D model and scene in 3D CG software. Next, the 3D model and scene were exported and converted for use in the rendering engine. The converted data included parameters and shader code for the rendering engine. Finally, the data was run on the rendering engine. The rendering engine called the appropriate OpenGL ES commands based on the converted data from the artist and dynamic input data from the developer's application code. With the new workflow, any changes the artist makes are immediately and seamlessly applied to the target.</div><div class="htmlview paragraph">It is important that the rendering engine interprets the converted data on the embedded platform as close as possible to the artist's intended design. Using automatic shader code generation and frame rate improvement techniques contributed to rendering a high quality image on a TFT-LCD screen. The data converter was able to generate and optimize the shader code automatically based on parameters set by the artist in the 3D CG software.</div><div class="htmlview paragraph">The new workflow was evaluated during a mass production development project and resulted in improved software development efficiency. While DENSO has succeeded in automating graphics development with data conversion and a rendering engine, the next goal is to integrate a model-based development tool to improve development efficiency.</div></div>

Wind energy has the advantages of wide distribution, renewable, and non-polluting, so it is receiving more and more attention from more and more countries. As more and more wind power systems are integrated into the grid, it has an impact on the stability of the grid. To keep the power system stable, there is an urgent need for a grid simulator that can simulate various behaviors of the grid and test the reliability of the wind turbine before grid integration. Inverters, especially multilevel inverters, as the core part of the grid simulator, have been widely studied by scholars in recent years. However, compared to conventional inverters, multilevel inverters are characterized by high code development effort, great difficulty, and a long development period. In this paper, we adopt an automatic DSP code generation method with MATLAB hardware support package and give a complete system design method and development flow based on MATLAB and TMSF28335 automatic code generation. Finally, we take the closed-loop three-level MMC inverter as an example, propose an equalization algorithm suitable for automatic code generation for the capacitor-voltage balancing part, and verify the feasibility of the DSP automatic code generation in a multilevel inverter development. The feasibility of DSP automatic code generation in the development of a multilevel inverter is verified. The experimental results show that the proposed equalization algorithm with variable reference coefficient and DSP automatic code generation method can be used in the development of a multilevel inverter, which can improve development efficiency and reduce development costs.

This work describes the results of an experiment to compare conventional software development with software development using automatic code generation from Simulink and mathematically based code verification (proof). A real industrial scale, safety critical system was used as the basis for the experiment in order to validate results, although this imposed some constraints. The principal aims for the experiment were to answer the following three questions. 1. Could automatic code generation be integrated with the verification tools to give a software development process to produce software that would pass the existing functional unit tests? 2. Would the code be of sufficient quality to be flown, i.e. was it certifiable? 3. What were the cost implications of adopting the process as part of a development lifecycle? The experiment showed how to integrate the techniques into existing development processes and indicated where processes could be streamlined. The code and the technique were independently assessed as being certifiable for safety critical applications. The results of the experiment were generally positive indicating the potential for reductions of 60%-70% of the software development costs alone, that would translate into a 30%-40% reduction in software life cycle costs.

This paper describes a reengineering solution for a Smart House controllers system using model-based development approach, emphasizing automatic code generation. Starting with the analysis of an existing system, based on a network of controllers, named as Tiny-Domots, the behavioral models associated with each controller was built using state diagrams as primary modeling formalism. A set of rules for manual translation between state diagrams and IOPT Petri Nets (Input-Output Place-Transition nets) is proposed. Editing of IOPT nets models was accomplished using the tool Snoopy-IOPT, which allows generation of PNML representations. In this work a tool for automatic generating C code was used (PNML2C), allowing the deployment of the generated code into the selected implementation platform (which is the PIC18F4620 low-cost microcontroller from Microchip). In this sense, a system of smart house controllers exhibiting the same features of the existing system was obtained, however, created with the support from model based automatic code generation tools. A comparative analysis between the two types of code is produced (manual and automatically generated). Starting with the IOPT net model, addition of new features to the current system were introduced and successful deployed into the Tiny-Domots controllers, taking advantage of model-based development flow and automatic code generation tool. In summary, the paper presents successful introduction of “reverse engineering” techniques in combination with model-based development techniques in the definition and validation of a methodology for embedded systems development in the Smart Houses application area; results obtained are applicable to other embedded systems application domains.

Modern safety-critical systems (e.g., combined pacemaker/deliberator devices, distributed patient therapy delivery systems) incorporate more functionality than similar devices of the past. The development of these complex systems challenges existing quality assurance techniques; results in significantly longer development times; and demands greater staffing resources to ensure quality and timely product completion. This is an interim report on a case study of the efficacy and viability of automatic code generation (ACG) techniques applied in the development of real-time, safety-critical software-dependent systems (Whalen, 1997). The research uses model-based software engineering (MBSE) practices that incorporate integrated analysis and design iterations throughout the development process. The focus of these investigations is the application of automated code generation tools that embody various methodologies, in the development of safety critical systems. There was no attempt to embark on explicit tool comparisons or evaluations.

Incorporation of modeling and autocode technologies into the systems and software development process opens new ways for increasing quality of products and faster delivery to the customer. We describe the practical steps of the Matlab/Simulink/Stateflow model-based development process with the focus on automatic code generation as part of the process. We discuss a way to flawless integration of autocode technology into the established software production development process. We describe the structure of an autocode-ready Simulink/Stateflow model, shows the effect of code generator usage at the stage of software verification and introduces a formal method to estimate the development time for autocoded software. We list the tools and utilities that Delphi has developed to support the transition to model-based and autocode-based software development process.

Background: Static verification is a sound programming methodology that permits automated reasoning about the correctness of an implementation with respect to its formal specification before its execution. Unified Modelling Language is most commonly used modelling language which describes the client’s requirement. Object Constraint Language is a formal language which allows users to express textual constraints regarding the UML model. Therefore, UML/OCL express formal specification and helps the developers to implement the code according to the client’s requirement through software design. Objective: This paper aims to compare the existing approaches generating Java, C++, C# code or JML, Spec# specifications from UML/OCL. Methods: Nowadays, software system is developed via automatic code generation from software design to implementation when using formal specification and static analysis. In this paper, the study considers transformation from design to implementation and vice versa using model transformation, code generation or other techniques. Results: The related tools, which generate codes, do not support verification at the implementation phase. On the other hand, the specification generation tools do not generate all the required properties which are needed for verification at the implementation phase. Conclusion: If the generated system supports the verification with all required properties, code developer needs less efforts to produce correct software system. Therefore, this study recommends introducing a new framework which can act as an interface between design and implementation to generate verified software systems.