A Revised Semantics for Rule Inheritance and Module Superimposition in ATL (original) (raw)

A new approach to modularity in rule-based programming

Proceedings Sixth International Conference on Tools with Artificial Intelligence. TAI 94

In this paper we describe a purely declarative method for introducing modularity into forwardchaining, rule-based languages and its embodiment in the Venus rule language. The method is enforced by the syntax of the language and includes the ability to parameterize the rule groups. Drawing from two of three Venus applications developed to date, we illustrate how this form of modularity contributes directly to the resolution of certain software engineering problems associated with rule languages.

Towards fully controlled overloading across module boundaries

16th International Workshop on the Implementation and Application of Functional Languages (IFL’04), Lübeck, Germany, University of Kiel, 2004

Abstract. This paper proposes a set of modularisation constructs as well as a new implementation technique for overloading functions across module boundaries. In contrast to existing approaches, it allows to fully preserve separation of namespaces without restricting the potential for later overloadings, including mutual recursion across module boundaries. This gives the programmer control over the visibility of individual function definitions within each namespace and, thus, allows several different sets of instances for ...

Module superimposition: a composition technique for rule-based model transformation languages

Software & Systems Modeling, 2010

As the application of model transformation becomes increasingly commonplace, the focus is shifting from model transformation languages to the model transformations themselves. The properties of model transformations, such as scalability, maintainability and reusability, have become important. Composition of model transformations allows for the creation of smaller, maintainable and reusable transformation definitions that together perform a larger transformation. This paper focuses

A Comparison of Rule Inheritance in Model-to-Model Transformation Languages

Lecture Notes in Computer Science, 2011

Although model transformations presumably play a major role in Model-Driven Engineering, reuse mechanisms such as inheritance have received little attention so far. In this paper, we propose a comparison framework for rule inheritance in declarative model-to-model transformation languages, and provide an in-depth evaluation of three prominent representatives thereof, namely ATL, ETL (declarative subsets thereof), and TGGs. The framework provides criteria for comparison along orthogonal dimensions, covering static aspects, which indicate whether a set of inheriting transformation rules is well-formed at compiletime, and dynamic aspects, which describe how inheriting rules behave at run-time. The application of this framework to dedicated transformation languages shows that, while providing similar syntactical inheritance concepts, they exhibit different dynamic inheritance semantics and offer basic support for checking static inheritance constraints, only.

Language-neutral support of dynamic inheritance

2008

Virtual machines have been successfully applied in diverse scenarios to obtain several benefits. Application interoperability and distribution, code portability, and improving the runtime performance of programs are examples of these benefits. Techniques like JIT compilation have improved virtual machine runtime performance, becoming an adequate alternative to develop different types of software products. We have extended a production JIT-based virtual machine so they offer low-level support for structural reflection, in order to obtain the aforementioned advantages in dynamic languages implementation. As various dynamic languages offer support for dynamic inheritance, the next step in our research work is to enable this support in the aforementioned JIT-based virtual machine. Our approach enables dynamic inheritance in a language-neutral way, supporting both static and dynamic languages, so no language specification have to be modified to enable these features. It also enables static and dynamic languages to interoperate, since both types are now low-level supported by our machine.

MCI-Java: A Modified JVM Approach to Multiple Code Inheritance

2004

Java has multiple inheritance of interfaces, but only single inheritance of code via classes. This situation results in duplicated code in Java library classes and application code. We describe a generalization to the Java language syntax and the Java Virtual Machine (JVM) to support multiple inheritance of code, called MCI-Java. Our approach places multiply-inherited code in a new language construct called an implementation, which lies between an interface and a class in the inheritance hierarchy. MCI-Java does not support multiply-inherited data, which can cause modeling and performance problems. The MCI-Java extension is implemented by making minimal changes to the Java syntax, small changes to a compiler (IBM Jikes), and modest localized changes to a JVM (SUN JDK 1.2.2). The JVM changes result in no measurable performance overhead in real applications.

Representation Inheritance: A Safe Form of ``White Box'' Code Inheritance

IEEE Transactions on Software Engineering, 1997

There are two approaches to using code inheritance for defining new component implementations in terms of existing implementations. Black box code inheritance allows subclasses to reuse superclass implementations as-is, without direct access to their internals. Alternatively, white box code inheritance allows subclasses to have direct access to superclass implementation details, which may be necessary for the efficiency of some subclass operations and to prevent unnecessary duplication of code.

J&: nested intersection for scalable software composition

2006

This paper introduces a programming language that makes it convenient to compose large software systems, combining their features in a modular way. J& supports nested intersection, building on earlier work on nested inheritance in the language Jx. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection enables composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code.

A Tool Support for Reusing ELAN Rule-Based Components

Electronic Notes in Theoretical Computer Science, 2003

The adaptation of software components developed for a specific application in order to generate reusable components often includes some kind of generalization. This generalization may be carried out, for instance, by the renaming of some identifiers or by its parameterization. In our work, we are specially interested in the generalization by parameterization of algebraic specification components. Generalization and some other transformations on algebraic specifications are being integrated in the FERUS tool. This tool was initially developed for the Common Algebraic Specification Language, called CASL, and we show in the paper its adaptation to the new version of the rule-based programming language ELAN.