Automatic Flight Code Generation with Integrated Static Run-Time Error Checking and Code Analysis

To increase and maintain web application security, developers could use some different methods, one of them is static code analysis. This method could find security vulnerabilities inside a source code without the need of running the program. It could also be automated by using tools, which considered more efficient than manual reviews. One specific method which is commonly used in static code analysis is taint analysis. Taint analysis usually utilizes source code modeling to prepare the code for analysis process to detect any untrusted data flows into security sensitives computations. While this kind of analysis could be very helpful, static code analysis tool for Laravel-based web application is still quite rare, despite its popularity. Therefore, in this research, we want to know how static code (taint) analysis could be utilized to detect security vulnerabilities and how the projects (Laravel-based) should be modeled in order to facilitate this analysis. We then developed a static analysis tool, which models the application’s source code using AST and dictionary to be used as the base of the taint analysis. The tool first parsed the route file of Laravel project to get a list of controller files. Each file in that list would be parsed in order to build the source code representation, before actually being analyzed using taint analysis method. The experiments was done using this tool shows that the tools (with taint analysis) could detect 13 security vulnerabilities from 6 Laravel-based projects with one False Negative. An ineffective sanitizer was the suspected cause of this False Negative. This also shows that proposed modeling technique could be helpful in facilitating taint analysis in Laravel-based projects. For future development and studies, this tool should be tested with more Laravel and even other framework based web application with a wider range of security vulnerabilities.

The ever increasing need to ensure that code is reliably, efficiently and safely constructed has fueled the evolution of popular static binary code analysis tools. In identifying potential coding flaws in binaries, tools such as IDA Pro are used to disassemble the binaries into an opcode/assembly language format in support of manual static code analysis. Because of the highly manual and resource intensive nature involved with analyzing large binaries, the probability of overlooking potential coding irregularities and inefficiencies is quite high. In this paper, a light-weight, unsupervised data flow methodology is described which uses highly-correlated data flow graph (CDFGs) to identify coding irregularities such that analysis time and required computing resources are minimized. Such analysis accuracy and efficiency gains are achieved by using a combination of graph analysis and unsupervised machine learning techniques which allows an analyst to focus on the most statistically significant flow patterns while performing binary static code analysis.

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.

This chapter demonstrates how high-level code is automatically generated for multi-core processors. The code generation capability of the Verifiable Embedded Real-Time Application Framework (VERTAF) was extended to support multi-core processors in the new VERTAF/Multi-Core (VMC) framework for embedded systems. After users specify embedded software requirements via SysML models along with parallel task, parallel data, and parallel dataflow specifications, the code generator automatically generates parallel code. Using the digital video recording (DVR) system as a case study, we show the correctness and advantages of the VMC code generator. The main inputs of VMC code generator include the block definition diagrams, state machine diagrams, and requirement diagrams of the system to be designed. The proposed code generation in VMC not only significantly decreases the amount of manually-written code, but also provides a formal procedure for model-conforming code generation of multi-core embedded software.

The large number of industrial control systems based on PLCs (Programmable Logic Controllers) available at CERN implies a huge number of programs and lines of code. The software quality assurance becomes a key point to ensure the reliability of the control systems. Static code analysis is a relatively easy-to-use, simple way to find potential faults or error-prone parts in the source code. While static code analysis is widely used for general purpose programming languages (e.g. Java, C), this is not the case for PLC program languages. We have analyzed the possibilities and the gains to be expected from applying static analysis to the PLC code used at CERN, based on the UNICOS framework. This paper reports on our experience with the method and the available tools and sketches an outline for future work to make this analysis method practically applicable.

In order to address the difficult problem of hardware implementation of complex communication algorithm, this paper takes digital phase modulation as an example, and uses model-based design approach to quickly complete the algorithm modeling, simulation and automatic generation of HDL code. Model-based design is a fast and effective design process for algorithm modeling, simulation, testing and automatic code generation. The simulation results show that the model-based design method cannot only quickly accomplish the modeling and testing of the algorithm, but also improve the design accuracy.

Automatic code generation for production automotive powertrain applications introduces many challenges for the tool vendor. Resource efficiency, reliability, and product process development issues need to be addressed. Automatic code generation used for rapid prototyping systems usually will not satisfy the requirements necessary for production oriented code generation. Some of the requirements critical to automatic code generation are not immediately obvious to a tool vendor who is not active in the user's industry. The purpose of this paper is to address some of the most common requirements for production automotive powertrain code generation.

Basically, aircraft engines can be divided into a control embedded system and a controlled system with its environment. The behaviour of the controlled system is given a priori, while the control system still needs to be designed in a way guaranteeing the correct overall behaviour under all operational conditions depending on the flight domain. A large quantity of functions in control systems can be described by a formal system expressed in block diagrams and state-based representations. These representations can be translated to formal based tools relying on the synchronous languages Signal and Statecharts. SACRES is a tool set supporting the design of safety-critical embedded control systems. It integrates the tools and specification techniques Statemate, Sildex, and Timing Diagrams with tool components for automatic code generation, formal verification based on model checking techniques, and an innovative approach for automatic code validation for target code generated from DC+. Technical achievements are The main benefits of the SACRES approach are reduced risks for design errors and decreased design times and costs for the development of dependable (safety critical) embedded systems. SACRES is an attempt to avoid unpredictability (particularly that arising from late feedback from testing) associated with development of safety critical systems, through the use of the maximum degree of automation, especially in respect of code generation and verification. An outstanding property of SACRES is the combination of specification styles and specification tools being applied in practice with automatic tools to establish provable correctness with respect to required properties. Both dependability and productivity are increased by automatic code generation from high-level specifications such that the generated code can be validated against higher levels by rigorous proofs. These techniques allow traditional tests by sampling to be replaced by rigorous checking techniques which correspond to 100% coverage of test cases. In order to address a global innovative approach in the near future which match the whole software configuration, the SACRES tool set should be interfaced with asynchronous techniques matching the operating system development. This raises an open question in the software development future new process.

Current practice in simulation and implementation of robot controllers is usually undertaken with guidance from high-level design diagrams and pseudocode. Thus, no rigorous connection between the design and the development of a robot controller is established. This paper presents a framework for designing robotic controllers with support for automatic generation of executable code and automatic property checking. A state-machine based notation, RoboChart, and a tool (RoboTool) that implements the automatic generation of code and mathematical models from the designed controllers are presented. We demonstrate the application of RoboChart and its related tool through a case study of a robot performing an exploration task. The automatically generated code is platform independent and is used in both simulation and two different physical robotic platforms. Properties are formally checked against the mathematical models generated by RoboTool, and further validated in the actual simulations and physical experiments. The tool not only provides engineers with a way of designing robotic controllers formally but also paves the way for correct implementation of robotic systems.

In emergency response environments, variant entities with specific behaviors and interaction between them form a complex system that can be well modeled by multi-agent systems. To build such complex systems, instead of writing the code from scratch, one can follow the model-driven development approach, which aims to generate software from design models automatically. To achieve this goal, two important prerequisites are: a domain-specific modeling language for designing an emergency response environment model, and transformation programs for automatic code generation from a model. In addition, for modeling with the language, a modeling tool is required, and for executing the generated code there is a need to a platform. In this paper, a model-driven framework for developing multi-agent systems in emergency response environments is provided which includes several items. A domain-specific modeling language as well as a modeling tool is developed for this domain. The language and the tool are called ERE-ML and ERE-ML Tool, respectively. Using the ERE-ML Tool, a designer can model an emergency response situation and then validate the model against the predefined constraints. Furthermore, several model to code transformations are defined for automatic multi-agent system code generation from an emergency response environment model. For executing the generated code, an extension of JAMDER platform is also provided. To evaluate our framework, several case studies including the Victorian bushfire disaster are modeled to show the ability of the framework in modeling real-world situations and automatic transformation of the model into the code.

In this paper a software engineering concept is described which permits the automatic solution of a nonlinear set of network equations. The power flow equation set can be seen as a defined subset of a network equation set. The automated solution process is the numerical Newton-Raphson solution process of the power flow equations where the key code parts are the numeric mismatch and the numeric Jacobian term computation. It is shown that both the Jacobian and the mismatch term source code can be automatically generated in a conventional language such as Fortran or C. Thereby one starts from a high level, symbolic language with automatic differentiation and code generation facilities. As a result of this software engineering process an efficient, very high duality Newton-Raphson solution code is generated which allows easier implementation of network equation model enhancements and easier code maintenance as compared to hand-coded Fortran or C code.

The model-based approach has been widely applied to the design of software. However, most of these approaches depend on simulation and manual code implementation, which reduces the efficiency and quality of software. In this paper, we present a new model-based approach, which automatically generates the executable C++ code running on the popular Robot Operation System (ROS). Our approach consists of three phases: modeling, verification, and automatic code generation. In the modeling phase, the internal interaction behaviors of robot systems are modeled as a network of timed automata. In the verification phase, the safety requirements are formalized and verified. In the code generation phase, a code generation tool can generate executable C++ code from the verified timed automata model. It bridges the gap between the formal model and the error-prone system implementation. Compared with existing method, the code generator provides the abstractions and mapping of ROS instructions, which realize the seamless connection between the generated code and ROS. The tool also supports most of the complex structures and advanced features of timed automata such as timer, committed location, and synchronous action. For evaluation, a real-industrial robot application of grasping a cup is conducted using our model-based design method, and the generated code can be directly deployed and successfully accomplishes the grasping task.

Automatic code generation has been around for a long time, and the core technologies used are constantly evolving. Around application development work in the demand for high quality code generated rapidly, this paper proposes a automatic code generation method based on sequence generative adversarial network, the method adopts the adversarial learning thought, using LSTM as a generator, CNN as a discriminator, both through against each other to generate higher quality code samples. Experiment results show that this method can generate code automatically at the second level, and is significantly better than the existing methods in terms of generation rate and accuracy, which explores a new way of automatic code generation.

The model-based design (MBD) is increasingly used in the field of electrical machine control because of the numerous advantages it offers, such as improving product quality and reducing development time. MBD is transforming the way of working of engineers and scientists since the design tasks of the laboratory and field are moved to a simulation environment in a desktop. The control system of an electrical machine can be rapidly prototyped using a simulation environment while in parallel, the software architecture necessary for its implementation in a microcontroller or DSP can be discussed and designed. The success of these two steps guarantees a better performance of the MiL, which is where the control of the machine on a simulated plant is evaluated, with a certain level of realism. If the control requirements are minimally met, where most of the errors are solved, the automatic code generation allows performing tests with the real plant, or on a PiL or HiL scenarios. In EV/HEV automotive systems, the plant is the vehicle which is also modeled to evaluate the control of the electric machine. In this chapter, the MBD is approached according to the above steps in a MiL level in a field-oriented control for induction machines. Two induction machines will be presented, one with 5 HP of power for industrial purposes, and other with 110 HP of power for electric vehicle (EV) application or full-electric aircraft propulsion propeller, both with a three-phase VSI .

. This paper presents a multi-language and multi-environment generation of nonlinear finite element codes. The system consists of two major components. The Mathematica package AceGen is used for the symbolic derivation of formulae needed in numerical procedures and automatic code generation. The Computational Templates package is a collection of prearranged modules for the automatic creation of the interface between the finite element code and the finite element environment. The AceGen and the Computational Templates packages together enable multi-language and multi-environment generation of nonlinear finite element codes from the same symbolic description. The approach implemented in AceGen avoids the usual problem of uncontrollable growth of expressions by combining several techniques: symbolic and algebraic capabilities of Mathematica, an automatic differentiation technique, automatic code generation, simultaneous optimization of expressions; and theorem proving by stochastic evaluation of the expressions.