Towards More Data-Aware Application Integration (extended version)

Although most business application data is stored in relational databases, programming languages and wire formats in integration middleware systems are not table-centric. Due to costly format conversions, data-shipments and faster computation, the trend is to "push-down" the integration operations closer to the storage representation. We address the alternative case of defining declarative, table-centric integration semantics within standard integration systems. For that, we replace the current operator implementations for the well-known Enterprise Integration Patterns by equivalent "in-memory" table processing, and show a practical realization in a conventional integration system for a non-reliable, "data-intensive" messaging example. The results of the runtime analysis show that table-centric processing is promising already in standard, "single-record" message routing and transformations, and can potentially excel the message throughput for "multi-record" table messages.Comment: 18 Pages, extended version of the contribution to British International Conference on Databases (BICOD), 2015, Edinburgh, Scotlan

VADA: A transformation-based system for variable dependence analysis

Variable dependence is an analysis problem in which the aim is to determine the set of input variables that can affect the values stored in a chosen set of intermediate program variables. This paper shows the relationship between the variable dependence analysis problem and slicing and describes VADA, a system that implements variable dependence analysis. In order to cover the full range of C constructs and features, a transformation to a core language is employed Thus, the full analysis is required only for the core language, which is relatively simple. This reduces the overall effort required for dependency analysis. The transformations used need preserve only the variable dependence relation, and therefore need not be meaning preserving in the traditional sense. The paper describes how this relaxed meaning further simplifies the transformation phase of the approach. Finally, the results of an empirical study into the performance of the system are presented

Constraints in Non-Boolean Contexts

In high-level constraint modelling languages, constraints can occur in non-Boolean contexts: implicitly, in the form of partial functions, or more explicitly, in the form of constraints on local variables in non-Boolean expressions. Specifications using these facilities are often more succinct. However, these specifications are typically executed on solvers that only support questions of the form of existentially quantified conjunctions of constraints. We show how we can translate expressions with constraints appearing in non-Boolean contexts into conjunctions of ordinary constraints. The translation is clearly structured into constrained type elimination, local variable lifting and partial function elimination. We explain our approach in the context of the modelling language Zinc. An implementation of it is an integral part of our Zinc compiler

EOLANG and φ\varphi-calculus

Object-oriented programming (OOP) is one of the most popular paradigms used for building software systems. However, despite its industrial and academic popularity, OOP is still missing a formal apparatus similar to $\lambda$-calculus, which functional programming is based on. There were a number of attempts to formalize OOP, but none of them managed to cover all the features available in modern OO programming languages, such as C++ or Java. We have made yet another attempt and created $\varphi$-calculus. We also created EOLANG (also called EO), an experimental programming language based on $\varphi$-calculus

Learning Top-Down Tree Transducers with Regular Domain Inspection

International audienceWe study the problem of how to learn tree transformations on a given regular tree domain from a finite sample of input-output examples. We assume that the target tree transformation can be defined by a deterministic top-down tree transducer with regular domain inspection (DTOPi:reg). An RPNI style learning algorithm that solves this problem in polynomial time and with polynomially many examples was presented at Pods'2010, but restricted to the case of path-closed regular domains. In this paper, we show that this restriction can be removed. For this, we present a new normal form for DTOPi:reg by extending the Myhill-Nerode theorem for DTOP to regular domain inspections in a nontrivial manner. The RPNI style learning algorithm can also be lifted but becomes more involved too

Synthesis of Model Transformations from Metamodels and Examples

Model transformations are central elements of model-driven engineering (MDE). However, model transformation development requires a high level of expertise in particular model transformation languages, and model transformation specifications are often difficult to manually construct, due to the lack of tool support, and the dependencies involved in transformation rules.In this thesis, we describe techniques for automatically or semi-automatically synthesising transformations from metamodels and examples, in order to reduce model transformation development costs and time, and improve model transformation quality.We proposed two approaches for synthesising transformations from metamodels. The first approach is the Data Structure Similarity Approach, an exhaustive metamodel matching approach, which extracts correspondences between metamodels by only focusing on the type of features. The other approach is the Search-based Optimisation Approach, which uses an optimisation algorithm to extract correspondences from metamodels by data structure similarity, name syntax similarity, and name semantic similarity. The correspondence patterns between the classes and features of two metamodels are extracted by either of these two methods. To enable the production of specifications in multiple model transformation languages from correspondences, we introduced an intermediate language which uses a simplified transformation notation to express transformation specifications in a language-independent manner, and defined the mapping rules from this intermediate language to different transformation languages.We also investigated Model Transformation by Examples Approach. We used machine learning techniques to learn model transformation rules from datasets of examples, so that the trained model could generate target model from source model directly.We evaluated our approaches on a range of cases of different kinds of transformation, and compared the model transformation accuracy and quality of our versions to the previously-developed manual versions of these cases.Key words: model transformation, model-driven engineering, transformation syn-thesis, metamodel matching, model transformation by example

An Architecture for Provenance Systems

This document covers the logical and process architectures of provenance systems. The logical architecture identifies key roles and their interactions, whereas the process architecture discusses distribution and security. A fundamental aspect of our presentation is its technology-independent nature, which makes it reusable: the principles that are exposed in this document may be applied to different technologies

Cascading Tree Sheets and recombinant HTML: Better encapsulation and retargeting of web content

Cascading Style Sheets (CSS) took a valuable step towards separating web content from presentation. But HTML pages still contain large amounts of "design scaffolding" needed to hierarchically layer content for proper presentation. This paper presents Cascading Tree Sheets (CTS), a CSS-like language for separating this presentational HTML from real content. With CTS, authors can use standard CSS selectors to describe how to graft presentational scaffolding onto their pure-content HTML. This improved separation of content from presentation enables even naive authors to incorporate rich layouts (including interactive Javascript) into their own pages simply by linking to a tree sheet and adding some class names to their HTML