A Complex Java Code Generator for ACL2 Based on a Shallow Embedding of ACL2 in Java

UML-based approaches provide abstraction to deal with the high complexity of embedded applications and when combined with Model-driven Engineering can also provide automation trough automatic code generation. This paper presents an approach to automatically generate structural and behavioral code from UML class and sequence diagrams.This approach is demonstrated through a case study and was validated by the implementation of a code generator.

Enterprise JavaBeans is a successful component model for the development of distributed business applications. Enterprise Java-Beans have to adhere to a set of rules and guidelines which, amongst others, require that a significant amount of glue code between the components is written. By using Declarative Meta Programming (DMP) we can codify these rules and guidelines as a logic program which operates on the Java code. Our DMP development tool can not only generate Java code, but can also verify compliance of developer code.

One of the main objectives of model-driven software engineering is to produce code automatically from high-level design models. This goal can be achieved by providing suitable models and model-to-code transformations that ensure the conformance of the produced code to its high-level specification. In this context we have developed PADL2Java, a software tool that translates PADL models into Java code. PADL is a process algebraic architectural description language equipped with a rigorous semantics and transformation rules into multithreaded object-oriented software, which is employed in the verification tool TwoTowers. This paper discusses the code generation approach underlying PADL2Java, the structure of the synthesized code, and the integration of the translator in TwoTowers. The effectiveness of PADL2Java is illustrated through the generation of a Java implementation of a cruise control system.

It is state of the art to provide UML modeling by means of class diagrams and code generation from there. But whereas drawing diagrams is most often well supported, code generation is limited in scope. Association classes, multiplicities, aggregation and composition are not correctly or not at all processed by most code generators. One reason may be that the UML semantics is not formally defined in the UML specification. As a result of that, associations are usually transformed into code by using properties of the same type as the associated classes or corresponding typed sets. This approach must fail although the UML2 Superstructure Specification considers association ends owned by a class to be equal to a property of the owning class. In this paper, we describe why associations should be implemented as classes when generating code from class diagrams.KeywordsUMLAssociationsCode GenerationJava

Cloud computing is now an omnipresent paradigm in modern programming. Cloud applications usually consist of several software components deployed on remote virtual machines. Managing such applications is a challenging problem because manual administration is no longer realistic for these complex distributed systems. Thus, autonomic computing is a promising solution for monitoring and updating these applications automatically. This is achieved through the automation of administration functions and the use of control loops called autonomic managers. An autonomic manager observes the environment, detects changes, and reconfigures dynamically the application. Multiple autonomic managers can be deployed in the same system and must make consistent decisions. Using them without coordination may lead to inconsistencies and error-prone situations. In this paper, we present our approach for coordinating stateful autonomic managers, which relies on a simple coordination language, new techniques for asynchronous controller synthesis and Java code generation. We used our approach for coordinating real-world cloud applications.

This paper introduces a new model, based on so-called object-composition filters, that uniformly integrates database-like features into an object-oriented language. The focus is on providing persistent dynamic data structures, data sharing, transactions, multiple views and associative access, integrated with the object-oriented paradigm. The main contribution is that the database-like features are part of this new object-oriented model, and therefore, are uniformly integrated with object-oriented features such as data abstraction, encapsulation, message passing and inheritance. This approach eliminates the problems associated with existing systems such as lack of reusability and extensibility for database operations, the violation of encapsulation, the need to define specific types such as sets, and the incapability to support multiple views. The model is illustrated through the object-oriented language Sina.

UML is an industry standard abstraction language, which encompasses a wide range of structural and behavioural diagrams. It reduces the gap between the functional requirements and system design phase of the software development process. Automated code generation from UML reduces development time and enables effective communication between managers and developers. Our tool exploits the one to one mapping between structural diagrams and object oriented code. Behavioural diagrams like activity, sequence and state diagrams are merged into a single structural diagram for code generation. The UML design diagrams are converted to platform independent textual representation, XML Metadata Interchange (XMI). The XMI parser generates an abstract syntax tree (AST). A template matching algorithm is used to convert the AST to the Java code. The tool also enables code generation in a phased manner to implement and verify the features of each diagram. The evaluation of the tool is shown using a case study and the results are compared with existing open source code generation tools. The generated OO code is functional and executable.

We present a formal calculus for operational QVT. The calculus is implemented in the interactive theorem prover KIV and allows to prove properties of QVT transformations for arbitrary meta models. Additionally, we present a framework for provably correct Java code generation. The framework uses a meta model for a Java abstract syntax tree as the target of QVT transformations. This meta model is mapped to a formal Java semantics in KIV. This makes it possible to formally prove (interactively) with the QVT calculus that a transformation always generates a Java model (i.e. a program) that is type correct and has certain semantical properties. The Java model can be used to generate source code by a model-to-text transformation or byte code directly.

To promote the newly emerging OSLC (Open Services for Lifecycle Collaboration) tool interoperability standard, an open source code generator is developed that allows for the specification of OSLC-compliant tool interfaces, and from which almost complete Java code of the interface can be generated. The software takes a model-based development approach to tool interoperability, with the aim of providing modeling support for the complete development cycle of a tool interface. The software targets both OSLC developers, as well as the interoperability research community, with proven capabilities to be extended to support their corresponding needs.

The emergence of Unified Modeling Language (UML) as a standard for modeling systems has encouraged the use of automated software tools that facilitate the development process from analysis through coding. The UML state machine diagram is used for modeling the dynamic aspects of systems and includes many concepts that are not present in most popular programming languages, like Java or C++. There exists a gap between high level modeling language and a programming language. This paper proposes an approach to narrow the gap between multiple UML models and an implemented system. The narrowing of gap is achieved by generating compact and efficient Java code directly from UML state machine having sequential and concurrent substates. The code generation is achieved by creating a mapping between UML behavior and the Java programming language. Our model can work as a basis for automatic code generation for object-oriented systems.

In this paper we propose a new environment for allowing students of a first programming undergraduate course to test their Java code. This environment allows the student to learn the basics of the Java language without necessarily knowing the object-oriented features of the language itself, and the teacher to propose new tests by making use of a graphical test editor. Moreover, the client-server architecture of the Web-based version of the environment is designed so that the student does not even need a Java virtual machine on its computing device, but only a Web browser. This latter feature makes our environment a useful tool for ubiquitous testing of Java programming skills.

This paper describes a case study on the use of a formal methods tool for checking security properties of Tokeneer, a U.S. National Security Agency (NSA) project developed by Praxis, and released in 2008. We modelled Tokeneer as a series of abstract mathematical models related refinement steps in Event-B. We used the Rodin toolset for modelling Tokeneer in Event-B and for discharging associated proof obligations, and we used the EventB2Java code generator to generate Java code for the Event-B model of Tokeneer. After that, we wrote a series of JUnit tests to validate if the Java implementation of Tokeneer adhered to the security properties of Tokeneer described in the documentation provided by Praxis. To the best of our knowledge, modelling Tokeneer in Event-B and checking that its implementation adheres to those security properties is something that hasn’t been attempted before.

In this paper we describe a method for the use of the Java object-oriented programming language for simulation. Our approach is to use the Unified Modeling Language, recently proposed for general-purpose modeling and software engineering, as a modeling and simulation language with Java as the implementation platform. Using the Model-View-Controller design pattern, views are added to models for such purposes as statistics collection, animation, and checkpoint recording. Controllers are added to models to handle events, or in the case of a simulation, to synthetically generate events. CASE tools being developed for UML will include Java code generation, making the approach proposed in this paper a practical method for simulation modeling.

We present Modular Choreographies, a new choreographic programming language that features modular functions. Modular Choreographies is aimed at simplicity: its communication abstraction follows the simple tradition from the "Alice and Bob" notation. We develop a compiler toolchain that translates choreographies into modular Java libraries, which developers can use to participate correctly in choreographies. The key novelty is to compile through the Choral language, which was previously proposed to define object-oriented choreographies: our toolchain compiles Modular Choreographies to Choral, and then leverages the existing Choral compiler to generate Java code. Our work is the first to bridge the simplicity of traditional choreographic programming languages with the requirement of generating modular libraries in a mainstream language (Java).

Perl is one of the most important programming languages in many research areas. However, the most relevant Big Data frameworks, Apache Hadoop, Apache Spark and Apache Storm, do not support natively this language. To take advantage of these Big Data engines Perl programmers should port their applications to Java or Scala, which requires a huge effort, or use utilities as Hadoop Streaming with the corresponding degradation in the performance. For this reason we introduce Perldoop2, a Big Data-oriented Perl-Java source-to-source compiler. The compiler is able to generate Java code from Perl applications for sequential execution, but also for running on clusters taking advantage of Hadoop, Spark and Storm engines. Perl programmers only need to tag the source code in order to use the compiler. Experimental results demonstrate the benefits of Perldoop2 in terms of ease of use, performance and scalability.