Since the advent of RPC Stub Generator, software tools that translate a high level specification into executable programs have been instrumental in facilitating the development of distributed software systems. Developers write programs at a high level abstraction with high readability and reduced initial development cost. However, existing approaches to building code generation tools for such systems have difficulties evolving these tools to meet challenges of new standards, new platforms and languages, or changing product scopes, resulting in generator tools with limited lifespan. The difficulties in evolving generator tools can be characterized as a combination of three challenges that appear inherently difficult to solve simultaneously: the abstraction mapping challenge translating a high-level abstraction into a low-level implementation), the interoperable heterogeneity challenge stemming from multiple input and output formats, and the flexible customization challenge to extend base functionality for evolution or new applications. The Clearwater approach to code generation uses XML-based technologies and software tools to resolve these three challenges with three important code generation features: specification extensibility, whereby an existing specification format can accommodate extensions or variations at low cost; generator pliability, which allows the generator to operator on an extensible specification and/or support multiple and new platforms; and flexible customization, which allows an application developer to make controlled changes to the output of a code generator to support application-specific goals. The presentation will outline the Clearwater approach and apply it to meet the above three challenges in two domain areas. The first area is information flow applications (e.g., multimedia streaming and event processing), a horizontal domain in which the ISG code generator creates QoS-customized communication code using the Infopipe abstraction and specification language. The second area is enterprise application staging (e.g., complex N-tier distributed applications), a vertical domain in which the Mulini code generator creates multiple types of source code supporting automatic staging of distributed heterogeneous applications in a data center environment. The success of applying Clearwater to these domains shows the effectiveness of our approach.

We tackle the problem of automated code generation for a High Level Architecture (HLA)- compliant federate application, given a model of the federation architecture including the federate&rsquo / s behavior model. The behavior model is based on Live Sequence Charts (LSCs), adopted as the behavioral specification formalism in the Federation Architecture Metamodel (FAMM). The FAMM is constructed conforming to metaGME, the meta-metamodel offered by Generic Modeling Environment (GME). FAMM serves as a formal language for describing federation architectures. We present a code generator that generates Java/AspectJ code directly from a federation architecture model. An objective is to help verify a federation architecture by testing it early in the development lifecycle. Another objective is to help developers construct complete federate applications. Our approach to achieve these objectives is aspect-oriented in that the code generated from the LSC in conjunction with the Federation Object Model (FOM) serves as the base code on which the computation logic is weaved as an aspect.

This thesis presents a two step automatic transformation of Field Artillery Mission Space Conceptual Models (ACMs) into High Level Architecture (HLA) Federation Architecture Models (FAMs) into executable distributed simulation code. The approach followed in the course of this thesis adheres to the Model-Driven Engineering (MDE) philosophy. Both ACMs and FAMs are formally defined conforming to their metamodels, ACMM and FAMM, respectively. ACMM is comprised of a behavioral component, based on Live Sequence Charts (LSCs), and a data component based on UML class diagrams. Using ACMM, the Adjustment Followed by Fire For Effect (AdjFFE) mission, which serves as the source model for the model transformation case study, is constructed. The ACM to FAM transformation, which is defined over metamodel-level graph patterns, is carried out with the Graph Rewriting and Transformation (GReAT) tool. Code generation from a FAM is accomplished by employing a model interpreter that produces Java/AspectJ code. The resulting code can then be executed on an HLA Run-Time Infrastructure (RTI). Bringing a fully fledged transformation approach to conceptual modeling is a distinguishing feature of this thesis. This thesis also aims to bring the chart notations to the attention of the mission space modeling community regarding the description of military tasks, particularly their communication aspect. With the experience gained, a set of guidelines for a domainindependent transformer from any metamodel-based conceptual model to FAM is offered.

Der Große Beleg dokumentiert die Entwicklung eines Java Code-Generators für Dresden OCL2 for Eclipse. Schwerpunkt der Arbeit liegt dabei auf der Abbildung der Object Constraint Language auf die Programmiersprache Java mit Hilfe von AspectJ.

Daugeliui įmonių ar organizacijų reikalingos informacinės sistemos, skirtos valdytį jų procesus duomenis. Darbe analizuojamos verslo procesų, transakcijų modeliavimo galimybės, technologijos, standartai: RUP, UML, XML (XMI), MERODE, R. Gusto, WAE, BPMN, MDA, Agile. Deliau analizuojamas verslo procesų modelis ir jo plėtinys BPMN. Pateikti pasiųlymai notacijos išplėtimui duomenų objektais, modelių ir elementų interpretacija modeliuojant o modelius panaudojant kodo generavime. Sudarytas ir ištestuotas pilnai funkcionuojančio ir dalykinę sritį atitinkančio kodo generavimo algoritmas. / In nowadays a lot of business companies and organizations are using information systems. This paper analyses business transactions, tools and technologies for transactions and process modelling of information and enterprise systems. Analyzed popular technologies like UML and its extensions, RUP, XMI, MDA. Familiarized with MERODE and Agile methods. More closely analyzed BPMN notation and its possibilities for code generation. BPMN notation augment with data objects for better code generation solutions. It also gives better understanding of data flows and influence of business process and transactions. Defined process and transactions modelling strategy which allows better code generations solution too. Made-up, practically materialized ant tested code generation algorithm.

Designing efficient code in practice for a given computation is a hard task. In this thesis, we tackle this issue in two different situations. The first part of the thesis introduces some algorithmic improvements in structured linear algebra. We first show how to extend an algorithm by Cardinal for inverting Cauchy-like matrices to the other common structures. This approach, which mainly relies on products of the type "structured matrix × matrix", leads to a theoretical speed-up of a factor up to 7 that we also observe in practice. Then, we extend some works on Toeplitz-like matrices and prove that, for any of the common structures, the product of an n×n structured matrix of displacement rank α by an n×α matrix can be computed in Õ(α^(ω-1)n). This leads to direct inversion algorithms in Õ(α^(ω-1)n) , that do not rely on a reduction to the Toeplitz-like case. The second part of the thesis deals with the implementation of arithmetic expressions. This topic raises several issues like finding the minimum number of operations, and maximizing the speed or the accuracy when using some finite-precision arithmetic. Making use of the inductive nature of arithmetic expressions enables the design of algorithms that help to answer such questions. We thus present a set of algorithms for generating evaluation schemes, counting them, and optimizing them according to one or several criteria. These algorithms are part of a library that we have developed and used, among other things, in order to decrease the running time of a code generator for a mathematical library, and to study optimality issues about the evaluation of a small degree polynomial with scalar coefficients at a matrix point.

Programinio kodo generavimo iš veiklos taisyklių modelių sritis iki šiol yra menkai ištirta ir tai neigiamai veikia veiklos taisyklių koncepcijos plėtrą. Nagrinėjama kodo generavimo iš grafinių IS (informacinių sistemų) reikalavimus atspindinčių modelių problema. Pristatomas modifikuotu Roso metodu grindžiamo veiklos taisyklių modeliavimo IS projektavimo stadijoje metodo tyrimas, siekiant sukurti adekvačią programinio kodo generavimo iš taisyklių diagramų metodiką. / One of the reasons for a relatively slow growth of the business rules approach could be the lack of developments in the field of program code generation from the business rules models. During this work methods for code generation from IS requirements models are analysed. The focus is placed on a modified Ross method based rules modelling method aiming to create an adequate code generation methodology.

The performance of a program can sometimes greatly improve if it was known in advance the features of the input the program is supposed to process, the actual operating parameters it is supposed to work with, or the specific environment it is to run on. However, this information is typically not available until too late in the program’s operation to take advantage of it. This is especially true for simulation algorithms, which are sensitive to this late-arriving information, and whose role in the solution of decision-making, inference and valuation problems is crucial. To overcome this limitation we need to provide the flexibility for a program to adapt its behaviour to late-arriving information once it becomes available. In this thesis, I study three adaptation mechanisms: run-time code generation, model-specific (quasi) Monte Carlo sampling and dynamic computation offloading, and evaluate their benefits on Monte Carlo algorithms. First, run-time code generation is studied in the context of Monte Carlo algorithms for time-series filtering in the form of the Input-Adaptive Kalman filter, a dynamically generated state estimator for non-linear, non-Gaussian dynamic systems. The second adaptation mechanism consists of the application of the functional-ANOVA decomposition to generate model-specific QMC-samplers which can then be used to improve Monte Carlo-based integration. The third adaptive mechanism treated here, dynamic computation offloading, is applied to wireless communication management, where network conditions are assessed via option valuation techniques to determine whether a program should offload computations or carry them out locally in order to achieve higher run-time (and correspondingly battery-usage) efficiency. This ability makes the program well suited for operation in mobile environments. At their core, all these applications carry out or make use of (quasi) Monte Carlo simulations on dynamic Bayesian networks (DBNs). The DBN formalism and its associated simulation-based algorithms are of great value in the solution to problems with a large uncertainty component. This characteristic makes adaptation techniques like those studied here likely to gain relevance in a world where computers are endowed with perception capabilities and are expected to deal with an ever-increasing stream of sensor and time-series data.

In order to use components that are developed for a domain, domain knowledge is required. If the default relations in a domain are offered by a framework, this can be a starting point for the application engineer as an important kind of domain knowledge. A generic design for creating and saving a domain is implemented in this thesis. This approach starts with creating a domain from components and relations among these components. The relations and components are saved once and used several times. In addition, this generic design helps for code generation by using components. A framework for this design is implemented and applied for GIS domain. A basic code generation approach is also implemented in this framework for demonstration purposes. This framework can be used by domain engineers in order to create a domain and by application engineers to develop custom applications. It has the ability to offer default relations and helps creating new relations between components. Parameters and sequence of function calls can be defined by using a GUI. All the relations including default and userdefined ones can be used for code generation. COSECASE, which offers a tool for component-oriented design is extended with domain operations such as creating domain, saving domain, loading domain, and generating domain code. As the starting point, domain analysis for GIS domain is completed to define the domain. Then the components that have been implemented for GIS domain and relations between these components are saved within the framework. Moreover, some basic applications are generated by using this framework in the GIS domain. Also a sample domain is created to prove that our approach can be applied to any domain. The relations in this sample domain are saved in the framework and same basic applications are generated.

Multi-stage programming is a valuable technique for improving the performance of computer programs through run-time optimization. Current implementations of multi-stage programming do not support run-time type introspection, which is a significant feature of modern object-oriented platforms such as Java and C#. This is unfortunate because many programs that use type introspection in these languages could be improved with multi-staging programming. The aim of this research is to investigate the interaction between multi-stage programming and object-oriented type introspection. This is done by the invention of a new programming language that is a multi-stage extension to C#. The language is capable of expressing traditional multi-stage programs as well as a new style of multi-stage programs that incorporate type introspection, most notably polytypic algorithms such as object serialization. A compiler for the language is implemented and freely available. The language is significant because it is the first object-oriented, multi-stage language; the first attempt to combine type introspection with multi-stage programming; and the first exploration of polytypic programming in a multi-stage context.