Source Code Generation Research Articles

The Proteins API: accessing key integrated protein and genome information.

The Proteins API provides searching and programmatic access to protein and associated genomics data such as curated protein sequence positional annotations from UniProtKB, as well as mapped variation and proteomics data from large scale data sources (LSS). Using the coordinates service, researchers are able to retrieve the genomic sequence coordinates for proteins in UniProtKB. This, the LSS genomics and proteomics data for UniProt proteins is programmatically only available through this service. A Swagger UI has been implemented to provide documentation, an interface for users, with little or no programming experience, to ‘talk’ to the services to quickly and easily formulate queries with the services and obtain dynamically generated source code for popular programming languages, such as Java, Perl, Python and Ruby. Search results are returned as standard JSON, XML or GFF data objects. The Proteins API is a scalable, reliable, fast, easy to use RESTful services that provides a broad protein information resource for users to ask questions based upon their field of expertise and allowing them to gain an integrated overview of protein annotations available to aid their knowledge gain on proteins in biological processes. The Proteins API is available at (http://www.ebi.ac.uk/proteins/api/doc).

PyJac: Analytical Jacobian generator for chemical kinetics

Accurate simulations of combustion phenomena require the use of detailed chemical kinetics in order to capture limit phenomena such as ignition and extinction as well as predict pollutant formation. However, the chemical kinetic models for hydrocarbon fuels of practical interest typically have large numbers of species and reactions and exhibit high levels of mathematical stiffness in the governing differential equations, particularly for larger fuel molecules. In order to integrate the stiff equations governing chemical kinetics, generally reactive-flow simulations rely on implicit algorithms that require frequent Jacobian matrix evaluations. Some in situ and a posteriori computational diagnostics methods also require accurate Jacobian matrices, including computational singular perturbation and chemical explosive mode analysis. Typically, finite differences numerically approximate these, but for larger chemical kinetic models this poses significant computational demands since the number of chemical source term evaluations scales with the square of species count. Furthermore, existing analytical Jacobian tools do not optimize evaluations or support emerging SIMD processors such as GPUs. Here we introduce pyJac, a Python-based open-source program that generates analytical Jacobian matrices for use in chemical kinetics modeling and analysis. In addition to producing the necessary customized source code for evaluating reaction rates (including all modern reaction rate formulations), the chemical source terms, and the Jacobian matrix, pyJac uses an optimized evaluation order to minimize computational and memory operations. As a demonstration, we first establish the correctness of the Jacobian matrices for kinetic models of hydrogen, methane, ethylene, and isopentanol oxidation (number of species ranging 13–360) by showing agreement within 0.001% of matrices obtained via automatic differentiation. We then demonstrate the performance achievable on CPUs and GPUs using pyJac via matrix evaluation timing comparisons; the routines produced by pyJac outperformed first-order finite differences by 3–7.5 times and the existing analytical Jacobian software TChem by 1.1–2.2 times on a single-threaded basis. It is noted that TChem is not thread-safe, while pyJac is easily parallelized, and hence can greatly outperform TChem on multicore CPUs. The Jacobian matrix generator we describe here will be useful for reducing the cost of integrating chemical source terms with implicit algorithms in particular and algorithms that require an accurate Jacobian matrix in general. Furthermore, the open-source release of the program and Python-based implementation will enable wide adoption. Program summaryProgram Title: pyJacProgram Files doi:http://dx.doi.org/10.17632/mmr3z8j2m5.1Licensing provisions: MIT LicenseProgramming language: PythonExternal routines/libraries: required: NumPy; optional: Cython, Cantera, PyYAML, AdeptNature of problem: Automatic generation of source code to evaluate Jacobian matrices for chemical kinetic modelsSolution method: Chemical kinetic model interpreted from input file(s), and partial derivatives and necessary supporting functions are written to file based on a theoretical derivation.Additional comments: This paper describes pyJac v1.0.2, available at http://dx.doi.org/10.5281/zenodo.251144. Current version and support available at https://github.com/SLACKHA/pyjac/

Transforming Model Oriented Program into Android Source Code Based on Drools Rule Engine

Model transformation is one of the prominent features and the rising research area of Model Driven Engineering (MDE). MDE promotes models to primary artifacts that drive the whole development process. This paper presents the model transformation approach for textual model oriented programs Umple (UML Programming Language) to generate android applications (apps). The proposed approach improved the generation of android source code by using Drools transformation rules and introducing new concern in model driven mobile engineering. The major objective of proposed transformation approach intends to address consistency between source and target model and also intends to handle productivity issues in model driven software development. The main results of model transformation approach are Java class for model layer, XML file for view layer and android activity class for controller layer. Results show that proposed approach achieves high consistency between source and target model and also improves model transformation productivity.

An Attribute-Based Development Framework of Node Software for Various Operating Systems in Sensor Network Environment

This paper proposes a framework for the development of sensor node software for various operating systems in a sensor network environment. The proposed development framework consists of attributes, code templates and development support tool. Sensor node software is developed, based on the framework through four steps —sensor network modeling, PIM design, PSM design and code generation. Accordingly, this paper presents the methods for attributes design, code templates design, PIM-to-PSM mapping, and source code generation. Through the proposed technique, reusability of sensor network software will be increased since models, attributes and code templates can be reused for various operating systems through the framework. Productivity of software development will be increased, because software design is easily performed using attributes and software codes for all nodes in the sensor network can be generated at once from a model. Also, expandability of sensor network software will be increased, since new functions of existing operating systems or new operating systems can be added through the framework and sensor network software can be rebuilt by applying the added functions or operating systems.

Efficient in-memory processing for huge amounts of heterogeneous geo-sensor data

A geo-sensor is a sensor that monitors the properties of dynamic environments in certain geographical regions. Through the geo-sensors, the environmental properties can be continuously tracked and made available for querying. Recently, as the IoT service area is rapidly increased, a number of various kinds of geo-sensor devices have been widely used. However, most geo-sensor devices do not provide a standard interface interoperable with other devices. They provide their own proprietary interface. So, lots of IoT applications have been consuming much time and cost in integrating the heterogeneous geo-sensor devices. Also the rapid increase of geo-sensor devices has been causing a sensor data explosion. It requires real-time processing for huge amounts of sensor data. Therefore, we propose a new interoperable IoT platform which can efficiently support huge amounts of heterogeneous geo-sensor data. The proposed platform provides an easy-to-use integration method for any kinds of heterogeneous geo-sensor devices. It also provides an efficient in-memory method for fast insertion and searching of huge amounts of data. From a real-world test bed, the proposed platform shows that it can easily integrate heterogeneous geo-sensor devices using the automatically generated source code. Also from several simulated experiments, the proposed platform shows that it is more efficient than the existing method in the insertion time, the searching time and the memory usage for huge amounts of data.

Automatic CPU/GPU Generation of Multi-versioned OpenCL Kernels for C++ Scientific Applications

Parallelism has become one of the most extended paradigms used to improve performance. However, it forces software developers to adapt applications and coding mechanisms to exploit the available computing devices. Legacy source code needs to be re-written to take advantage of multi- core and many-core computing devices. Writing parallel applications in a traditional way is hard, expensive, and time consuming. Furthermore, there is often more than one possible transformation or optimization that can be applied to a single piece of legacy code. Therefore many parallel versions of the same original sequential code need to be considered. In this paper, we describe an automatic parallel source code generation workflow (REWORK) for parallel heterogeneous platforms. REWORK automatically identifies promising kernels on legacy C++ source code and generates multiple specific versions of kernels for improving C++ applications, selecting the most adequate version based on both static source code and target platform characteristics.

Hard real-time multibody simulations using ARM-based embedded systems

The real-time simulation of multibody models on embedded systems is of particular interest for controllers and observers such as model predictive controllers and state observers, which rely on a dynamic model of the process and are customarily executed in electronic control units. This work first identifies the software techniques and tools required to easily write efficient code for multibody models to be simulated on ARM-based embedded systems. Automatic Programming and Source Code Translation are the two techniques that were chosen to generate source code for multibody models in different programming languages. Automatic Programming is used to generate procedural code in an intermediate representation from an object-oriented library and Source Code Translation is used to translate the intermediate representation automatically to an interpreted language or to a compiled language for efficiency purposes. An implementation of these techniques is proposed. It is based on a Python template engine and AST tree walkers for Source Code Generation and on a model-driven translator for the Source Code Translation. The code is translated from a metalanguage to any of the following four programming languages: Python-Numpy, Matlab, C++-Armadillo, C++-Eigen. Two examples of multibody models were simulated: a four-bar linkage with multiple loops and a 3D vehicle steering system. The code for these examples has been generated and executed on two ARM-based single-board computers. Using compiled languages, both models could be simulated faster than real-time despite the low resources and performance of these embedded systems. Finally, the real-time performance of both models was evaluated when executed in hard real-time on Xenomai for both embedded systems. This work shows through measurements that Automatic Programming and Source Code Translation are valuable techniques to develop real-time multibody models to be used in embedded observers and controllers.

Flight Control Software Failure Mitigation: Design Optimization for Software-implemented Fault Detectors

Failures of avionic and aerospace control hardware, caused by negative environmental impacts like increasing heat or cosmic radiation, can lead to silent data corruption and undetected incorrect system outputs. Traditionally, redundant and specifically protected hardware is used, which is expensive and available only on restricted markets. The application of software-implemented fault detectors like SWIFT, SWIFT ECF, or Software Encoded Processing is a promising alternative solution that offers the opportunity to use cost effective, but less reliable hardware. However, this entails generation of extra source code, resulting in a considerable computational overhead and, as a consequence, leads to performance degradations. This article introduces an approach that aims minimizing the negative performance impact while maintain ing the required system reliability level. It is shown that selective and balanced application of the software-implemented fault detectors solely to the most critical parts of the control software is an efficient system design solution. The presented approach uses a combination of two methods for reliability and performance analysis. Both methods are used for the quantitative exploration of different strategies of selective protection and allow finding a balance between system performance and reliability. The article demonstrates the application of the introduced approach using embedded flight control software of an UAV.

Detection of Common Problems in Real-Time and Multicore Systems Using Model-Based Constraints

Multicore systems are complex in that multiple processes are running concurrently and can interfere with each other. Real-time systems add on top of that time constraints, making results invalid as soon as a deadline has been missed. Tracing is often the most reliable and accurate tool available to study and understand those systems. However, tracing requires that users understand the kernel events and their meaning. It is therefore not very accessible. Using modeling to generate source code or represent applications’ workflow is handy for developers and has emerged as part of the model-driven development methodology. In this paper, we propose a new approach to system analysis using model-based constraints, on top of userspace and kernel traces. We introduce the constraints representation and how traces can be used to follow the application’s workflow and check the constraints we set on the model. We then present a number of common problems that we encountered in real-time and multicore systems and describe how our model-based constraints could have helped to save time by automatically identifying the unwanted behavior.

Development of the Multicomponent Coupled-Cluster Theory for Investigation of Multiexcitonic Interactions.

Multicomponent systems are defined as chemical systems that require a quantum mechanical description of two or more different types of particles. Non-Born-Oppenheimer electron-nuclear interactions in molecules, electron-hole interactions in electronically excited nanoparticles, and electron-positron interactions are examples of physical systems that require a multicomponent quantum mechanical formalism. The central challenge in the theoretical treatment of multicomponent systems is capturing the many-body correlation effects that exist not only between particles of identical types (electron-electron) but also between particles of different types (electron-nuclear and electron-hole). In this work, the development and implementation of multicomponent coupled-cluster (mcCC) theory for treating particle-particle correlation in multicomponent systems are presented. This method provides a balanced treatment of many-particle correlation effects in a general multicomponent system while maintaining a size-consistent and size-extensive formalism. The coupled-cluster ansatz presented here is an extension of the electronic structure CCSD formulation for multicomponent systems and is defined as |ΨmcCC⟩ = eT1I+T2I+T1II+T2II+T11I,II+T12I,II+T21I,II+T22I,II|0I0II⟩. The cluster amplitudes in the mcCC wave function were obtained by projecting the mcCC Schrödinger equation onto a direct product space of singly and doubly excited states of type I and II particles and then solving the resulting mcCC equations iteratively. These equations were derived using an automated application of the generalized Wick’s theorem and were implemented using a computer-assisted source code generation approach. The applicability of the mcCC method was demonstrated by calculating ground state energies of multicomponent Hooke's atom and positronium hydride systems as well as by calculating exciton and biexciton binding energies in multiexcitonic systems. For each case, the mcCC results were benchmarked against full configuration interaction (FCI) calculations and were found to be in excellent agreement with the FCI results. The effect of neglecting certain classes of multicomponent connected excitation terms from the mcCC wave function was also investigated. The results from this study demonstrate that connected cluster operators that generate simultaneous excitation in type I and type II space are critical for capturing electron-hole correlation in multiexcitonic systems.

An analysis of tools for automatic software development and automatic code generation

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.

New virtual laboratories presenting advanced motion control concepts

The paper deals with development of software framework for rapid generation of remote virtual laboratories. Client-server architecture is chosen in order to employ real-time simulation core which is running on a dedicated server. Ordinary web browser is used as a final renderer to achieve hardware independent solution which can be run on different target platforms including laptops, tablets or mobile phones. The provided toolchain allows automatic generation of the virtual laboratory source code from the configuration file created in the open- source Inkscape graphic editor. Three virtual laboratories presenting advanced motion control algorithms have been developed showing the applicability of the proposed approach.

MULTILANGUAGE SOURCE CODE GENERATOR FOR DATABASE ORIENTED APPLICATION USING JSP

The goal of automated software engineering is to increase by order of magnitude both the quality and productivity factor. To date most successful approach is producing a special-purpose code generator, such as screen generator, report generator, swing builder, Meta programming etc., these software tools is produce source code for specific language. This study provides mechanism to make a generalized system of Multi-Language Source Code Generation (MLSCG). It takes database structure of metadata as input and produce source code in Java, Java script, JSP, PHP and ASP. We utilize the target output code for both web and pc-based application.

Experimental Analysis of SPF Based Secure Web Application

In this paper we will propose model driven software development and Security Performance Framework (SPF) Model to maintain the balance between security and performance for web applications. We propose that all security in a Trusted Operating System is not necessary. Some non-essential security checks can be skipped to increase system performance. These non essential security checks can be identified in any web application. For implementation of this Security Performance framework based trusted operating system, we propose object oriented based Code generation through forward engineering. This involves generating source code of web application from one or more Object oriented Rational Rose model. The novel integration of security engineering with model-driven software expansion approach has varied advantages. To maintain security in various applications like Ecommerce, Banking, Marketplace services, Advertising, Auctions, Comparison shopping, Mobile commerce Payment, Ticketing, Online insurance policy management, we have to use high secured operating systems. In this regard a number of trusted operating systems like Argus, Trusted Solaris, and Virtual Vault have been developed by various companies to handle the increasing need of security. Due to high security reason these operating systems are being used in defense. But still these secure operating systems have limited scope in commercial sector due to lower performance; actually this security will come at a cost. This paper analyzes UML-based software development solutions for SPF to manage the security, performance and modeling for web applications.

Towards designing of SPF based secure web application using UML 2.0

This paper describes UML-based foundations for model driven architecture and forward engineering of UML static models. In this paper, we propose an integrated environment for designing object-oriented enterprise models. In this projected process for Fast Prototyping, we design object models like use case diagram, sequence diagram, class diagram, etc. We use object-oriented conceptual modeling techniques to design and develop various applications like E-commerce, Banking, Comparison shopping, Ticketing, Online insurance policy management, product purchase system, etc. This paper suggests forward engineering to generate source code from object models through IBM Rational Rose software. This object oriented source code help software development team from analysis to maintenance phase as well as for round trip engineering. Due to high security concern, we have to use highly secure operating systems as a platform to run these web applications. In this regard, a number of trusted operating systems like Argus, Trusted Solaris, and Virtual Vault have been developed by various companies to handle the increasing need of security. The novel integration of security engineering with model-driven software expansion approach has various advantages. As we observe that all security checks in a Trusted Operating System is not necessary. Some non-essential security checks can be skipped by administrator to increase system performance. These non essential security checks can be easily identified at the time of requirement analysis. For example, the majority of web servers deal with pure public information. The majority of data on a web server is publicly readable and available to all users, but these users should not be capable to change the data on the web server. In this application, the need for security checks during reads from disk seems like a waste of CPU cycles. The real security need for web servers seems to be the security of write accesses, not read accesses. In this paper, we propose code generation, Class identification and Modeling for web applications through UML 2.0. Further we propose Security Performance flexibility model for the same to maintain the balance between security and performance for web applications.

High performance computing of oligopeptides complete backtranslation applied to DNA microarray probe design

SummaryComplete backtranslation is the step of generating all possible nucleic acid sequences from a protein sequence. This is a time‐consuming task that can provide unreasonable quantities of data. Complete backtranslation was recently used to initiate probe design for functional DNA microarrays from conserved peptidic regions, in order to assess the full microbial gene diversity present in complex environments. In this article, we present an efficient parallelization method to compute a complete backtranslation of short peptides to select probes for functional microarrays. We implemented a software that uses meta‐programming and a model‐driven engineering approach to automatically generate source codes to perform complete backtranslation on different architectures: PCs, Symmetric Multiprocessors servers, computing clusters, or a computing grid. Our software is filtering the generated oligonucleotides with usual selection criteria for the design of microarray probes. It uses load balancing and can be easily integrated in probe design software for functional microarrays. We present its performance on both simulated and real biological datasets. The obtained results show a significant computing speedup on different platforms and an important gain of about 40% of disk space when filtering oligonucleotides. Copyright © 2014 John Wiley & Sons, Ltd.

Python Implementation of Source Code Generator Based on Dynamic Frames

This paper presents the implementation in Python of the source code generator that is based on the SCT dynamic frames model. The SCT model consists of three basic components: Specification (S), which describes the application characteristics, Configuration (C), which describes the rules for building applications, and Templates (T), which refer to application building blocks. Python is chosen as implementation language because of its flexibility as a scripting language with object-oriented features. The main advantages of the presented implementation are fully configurable generator, reduced overhead of the generated source code and portability. The presented implementation is shown on development of web application example in order to justify our design choices.

Towards the Software Autogeneration

Program generators are usually aimed for generation of program source code. This paper introduces the idea of software source code generation and its execution on demand that we named as Autogeneration. Autogeneration avoids generation of program files by using the possibility of scripting languages to evaluate program code from variables. There are several features that could be achieved by autogeneration. Some of them are program update during its execution, optimized code without temporarily unnecessary instructions and introspection of generation process for development purposes. An example of web application for database content management that is implemented as an autogeneration process is presented and discussed.

Computer Aided Instrument to be Used as an Automatic Design Component

The paper presents an original method to enhance the productivity of the design activity based on a dimensioning stage which integrates information from various sources: tabular data, diagrams, experimental data and others. The integration of such data in an analytic way is based on an original data processor which interpolates data and outputs diagrams, and outputs information regarding the laws of variation expressed as comma separated values data files, as well as automatically generated source code libraries in C++, Java and MATHLAB/GNU Octave. This automatically generated code is optimized in terms of execution time and it was verified in several applications. The data processor allows the user to visually verify the output data accuracy. The paper also presents some of the applications of the data processor: automatic design, method to enhance the accuracy of computer based calculus for both analytic and numerical methods, conversion of the discontinuous experimental data into laws of variation and experimental data processing in applied elasticity. There are several directions of future research, such as: a more general mathematical approach, development of a more general computer based instrument with increased flexibility and accuracy. Also, a complex software for applied elasticity calculi based on the results of the data processor is under development. Implementation of these applications in commercial CAD/CAE applications is another direction of research.

Forward Engineering based Implementation of TOS in Social Networking

present generation of youth begins the day with the Facebook or other social website. Hundreds of millions of people all over the world make use of social websites, Internet portals, blogs, Wikis, etc. These sites such as MySpace, Facebook and YouTube have the essential features and equipped with the necessary computing facilities to keep gigantic online communities get going with secure manner. Due to rapid growth of networking, use of social networking sites in day to day life, data sharing, computer security has made a vital part of computer research & development. For maintaining the security in various applications like E- commerce Online goods and services, Banking, Marketplace services Advertising, Auctions, Comparison shopping, Mobile commerce Payment, Ticketing, An electronic payment system (EPS),Online insurance policy management, we have to use high secured operating systems. In this regard a number of extremely secure operating systems i.e. Trusted Operating Systems like SELinux, Argus, Trusted Solaris, Virtual Vault have been developed by companies such as Argus-Systems Group, Hewlett-Packard, and Sun Microsystems to handle the increasing need of security. Normally, due to high security reason these operating systems are being used in defense. But still these secure operating systems have limited scope in commercial sector and are not popular in corporate due to lower performance; actually this security will come at a cost. In this paper we will propose SPF Model to maintain the balance between security and performance for these operating systems. This SPF model of TOS can be implement for various applications. For implementation of these SPF based trusted operating system we propose object oriented based Code generation i.e. forward engineering i.e. process of generating source code from one or more OO Rational Rose model for web application like social networking. In this research paper we will discuss the issues and UML-based software development solutions for SPF to manage the security, performance and modeling for Social networking sites.