GEF: A Self-Programming Robot Using Grammatical Evolution

Grammatical Evolution generates computer programs automatically in any arbitrary language using Backus-Naur Form of Context-free Grammar in automatic programming. Variable-length Genetic Algorithm is used as a learning algorithm in Grammatical Evolution. Fireworks algorithm is a recently developed new Swarm Intelligent algorithm used for function optimization. This paper proposes Grammatical Fireworks algorithm which uses Fireworks algorithm as a learning algorithm in place of variable-length Genetic Algorithm in Grammatical Evolution to evolve computer programs automatically. Grammatical Fireworks algorithm is applied on three well-known benchmark problems such as Santa Fe ant trail, symbolic regression and 3-input multiplexer problems. A comparative study is made with Grammatical Evolution, Grammatical Swarm, Grammatical Artificial Bee Colony, and Grammatical Differential Evolution. The experimental results demonstrate that the proposed Grammatical Fireworks algorithm can be applied in automatic computer program generation.

A massively parallel Grammatical Evolution technique with OpenCL

This paper introduces an approach to evolving computer programs using an Attribute Grammar (AG) extension of Grammatical Evolution (GE) to eliminate ineffective pieces of code with the help of context-sensitive information.The standard Context-Free Grammars (CFGs) used in GE, Genetic Programming (GP) (which uses a special type of CFG with just a single non-terminal) and most other grammar-based system are not well-suited for codifying information about context. AGs, on the other hand, are grammars that contain functional units that can help determine context which, as this paper demonstrates, is key to removing ineffective code.The results presented in this paper indicate that, on a selection of grammars, the prevention of the appearance of ineffective code through the use of context analysis significantly improves the performance of and resistance to code bloat over both standard GE and GP for both Santa Fe Trail (SFT) and Los Altos Hills (LAH) trail version of the ant problem with same amount of energy used.

This chapter discusses some of the fundamental principles from Molecular Biology that can be exploited by an Evolutionary Automatic Programming system. In particular, we focus on those aspects that have provided inspiration for Grammatical Evolution. We will see later in chapter 4 how some of these principles have been adopted successfully by the Grammatical Evolution system.

The data of unplanned flight attendant events has characteristics such as diversity and complexity, which pose great challenges to data preprocessing and analysis. This study proposes a preprocessing and analysis method for unplanned flight attendant event data based on Convolutional Neural Networks (CNN) and Gated Recurrent Units (GRU). Firstly, an efficient word vector tool is used to preprocess the raw data, improving its quality and consistency. Then, convolutional neural networks are taken to extract local features of the data, combined with gated loop units to capture dynamic changes in time series, thus achieving effective analysis and prediction of unplanned events in air crew. The results showed that in the 6-class task, the research model exhibited the highest accuracy at 99.24%, the lowest accuracy at 94.24%, and an average accuracy of 98.53%. The highest, lowest, and average accuracies in the 10-class task were 96.63%, 90.17%, and 93.21%, respectively. The performance of the research model was superior to support vector machine, K-nearest neighbor algorithm, and some advanced algorithms. This study provides a more accurate analysis tool for unplanned event data of flight attendants, to assist in the efficiency of aviation emergency event handling and improve aviation safety.

Recently, general purpose GPU (GPGPU) programming has spread rapidly after CUDA was first introduced to write parallel programs in high-level languages for NVIDIA GPUs. While a GPU exploits data parallelism very effectively, task-level parallelism is exploited as a multi-threaded program on a multicore CPU. For such a heterogeneous platform that consists of a multicore CPU and GPU, we propose an automatic code synthesis framework that takes a process network model specification as input and generates a multithreaded CUDA code. With the model based specification, one can explicitly specify both function-level and loop-level parallelism in an application and explore the wide design space in mapping of function blocks and selecting the communication methods between CPU and GPU. The proposed technique is complementary to other high-level methods of CUDA programming.KeywordsGPGPUCUDAmodel-based designautomatic code synthesis

The popular slogan “write once, run anywhere” effectively renders the expressive capabilities of the JAVA programming framework for developing, deploying, and reusing target-independent applets. Its generality and simplicity has driven most attention of the compiler technology community to developing just-in-time and runtime compilation techniques, local and compositional optimization algorithms. When it comes to real-time JAVA and to the implementation of embedded software, this approach is however far from satisfactory, especially in hard real-time system design (e.g. airborne systems) where conformance to real-time specifications is critical. We show that synchronous design tools, and particularly the design workbench POLYCHRONI, allow for a complete modeling of embedded software written in a high-level and general purpose programming language such as JAVA. The synchronous approach provides a formal engineering model and methodology, using global transformation and optimization techniques, that allow for a JAVA program written once to be mapped on any distributed target architecture. We present a technique to import a resource constrained, multi-threaded, RT JAVA program, together with its runtime system API, into POLYCHRONI. We put this modeling technique to work by considering a formal, refinement-based, design methodology that allows for a correct by construction remapping of the initial threading architecture of a given JAVA program on either a single-threaded target or a distributed architecture. This technique allows to generate stand-alone (Jvm-less) executables and to remap threads onto a given distributed architecture or a prescribed target real-time operating system. As a result, it allows for a complete separation between the virtual threading architecture of the functional-level system design (in JAVA) and its actual, real-time and resource constrained implementation.

Compilers and interpreters are systems-software programs which are used to implement high-level languages; they facilitate the running of high-level language programs on a particular computer, even though the computer can only directly execute programs written in its own, low-level, machine code. Each compiler, or interpreter, implements only one high-level language, and so a computer system will usually have several of them, so that programs in several different high-level languages can be executed.

Hydrologists need simple, yet powerful, open source framework for developing and testing mathematical models. Such framework should ensure long-term interoperability and high scalability. This can be done by implementation of the existing, already tested standards. At the moment two interesting options exist: Open Modelling Interface (OpenMI) and Object Modeling System (OMS). OpenMI was developed within the Fifth European Framework Programme for integrated watershed management, described in the Water Framework Directive. OpenMI interfaces are available for the C# and Java programming languages. OpenMI Association is now in the process of agreement with Open Geospatial Consortium (OGC), so the spatial standards existing in OpenMI 2.0 should be better implemented in the future. The OMS project is pure Java, object-oriented modeling framework coordinated by the U.S. Department of Agriculture. Big advantage of OMS compared to OpenMI is its simplicity of implementation. On the other hand, OpenMI seems to be more powerful and better suited for hydrological models. Finally, OpenMI model was selected as the base interface for the proposed open source hydrological framework. The existing hydrological libraries and models focus usually on just one GIS package (HydroFOSS – GRASS) or one operating system (HydroDesktop – Microsoft Windows). The new hydrological framework should break those limitations. To make hydrological models’ implementation as easy as possible, the framework should be based on a simple, high-level computer language. Low and mid-level languages, like Java (SEXTANTE) or C (GRASS, SAGA) were excluded, as too complicated for regular hydrologist. From popular, high-level languages, Python seems to be a good choice. Leading GIS desktop applications – GRASS and QGIS – use Python as second native language, providing well documented API. This way, a Python-based hydrological library could be easily integrated with any GIS package supporting this programming language. As the OpenMI 2.0 standard supported interfaces only for Java and C#, the Python interface for OpenMI standard, presented in this paper, is the first step done towards the open and interoperable hydrological framework. GIS-related issues of the OpenMI 2.0 standard are also outlined and discussed.

Much of computer system development today is programming in the large - systems of millions of lines of code distributed across servers and the web. At the same time, microcontrollers have also become pervasive in everyday products, economical to manufacture, and represent a different level of learning about system development. Real world systems at this level require integrated development of custom hardware and software.How can academic institutions give students a view of this other extreme - programming on small microcontrollers with specialized hardware? Full scale system development including custom hardware and software is expensive, beyond the range of any but the larger engineering oriented universities, and hard to fit into a typical length course. The course described here is a solution using microcontroller programming in high level language, small hardware components, and the Arduino open source microcontroller. The results of the hands-on course show that student programmers with limited hardware knowledge are able to build custom devices, handle the complexity of basic hardware design, and learn to appreciate the differences between large and small scale programming.

Decompilation is a reconstruction of a program in a high-level language from a program in a low-level language. Typical applications of decompilation are software security assessment, malware analysis, error correction and reverse engineering for interoperability. Native code decompilation is traditionally considered in the context of the C programming language. C++ presents new challenges for decompilation, since the rules of translation from C++ to assembly language are far more complex than those of C. In addition, when decompiling a program that was originally written in C++, reconstruction of C++ specific constructs is desired. In this paper we discuss new methods that allow partial recovery of C++ specific language constructs from a low-level code provided that this code was obtained from a C++ compiler. The challenges that arise when decompiling such code are described. These challenges include reconstruction of polymorphic classes, class hierarchies, member functions and exception handling constructs. An approach to decompilation that is used to overcome these challenges is presented. Smart Dec, a native code to C++ decompiler that is being developed by the authors at Select LTD is presented. It reconstructs expressions, function arguments, local and global variables, integral and composite types, loops and compound conditional statements, C++ class hierarchies and exception handling constructs. An empirical study of the decompiler is provided.

Decompilation is reconstruction of a program in a high-level language from a program in a low-level language. In most cases static decompilation is unable to completely reconstruct high-level data types due to loss of typing information during compilation. We present several profile-based techniques that help to recover high-level types. The techniques include pointer/integer determination by value profiling and composite type identification by heap profiling.

To produce a program guaranteed to satisfy a given specification one can synthesize it from a formal constructive proof that a computation satisfying that specification exists. This process is particularly effective if the specifications are written in a high-level language that makes it easy for designers to specify their goals. We consider a high-level specification language that results from adding knowledge to a fragment of Nuprl specifically tailored for specifying distributed protocols, called event theory. We then show how high-level knowledge-based programs can be synthesized from the knowledge-based specifications using a proof development system such as Nuprl. Methods of Halpern and Zuck [15] then apply to convert these knowledge-based protocols to ordinary protocols. These methods can be expressed as heuristic transformation tactics in Nuprl.KeywordsEvent StructureStandard ProgramFrame ConditionConstructive ProofValuation VersusThese 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.

AProVE is a system for automatic termination and complexity proofs of Java, C, Haskell, Prolog, and term rewrite systems (TRSs). To analyze programs in high-level languages, AProVE automatically converts them to TRSs. Then, a wide range of techniques is employed to prove termination and to infer complexity bounds for the resulting TRSs. The generated proofs can be exported to check their correctness using automatic certifiers. For use in software construction, we present an AProVE plug-in for the popular Eclipse software development environment.

We propose an environment for evolutionary prototyping technique, which is a theoretical framework based on abstract interpretation for Java programs. In general, it is difficult to execute a prototype in the intermediate stage of top-down development. This disadvantage prevents us to find bugs in the early stage of the development. The technique we propose here allows programmers to execute the prototype as a whole, even though it is partially implemented. In the technique, an object is repeatedly changed with interface changes. Our idea is to use an earlier runnable object instead of an unimplemented later object in runtime. The changes of objects are based on abstract interpretation. However, it is necessary to realize the mechanism for using the alternative object including the interface changes in Java. To solve this problem, we introduce proxy object, which is a mediator containing all interface and transform objects dynamically and automatically to keep execution going. Moreover, proxy objects can be automatically generated by the dynamic proxy class API, which is one of Java reflection mechanism. As a result, our environment would reduce the cost that programmers describe code for adjusting current objects.