Separating Concerns in Programming: Data, Control and Actions

A multi-paradigm language provides an opportunity to a user for exploiting more programming methodologies. It simplifies the language syntax, and extends the application areas by the extended semantics. That is why multi-paradigm languages can align a problem in wider application areas and more flexibly than that based on a single paradigm. In this paper, we present the idea of separating three essential concerns of programming currently being implemented in PFL -- a process functional language. We separate data, control, and actions by the definition of a purely control structure. Then, by the structured application of a structure of actions to a purely control structure, we will express the computation of activated actions in a structured way, considering explicitly defined synchronization in computation

From Eager PFL to Lazy Haskell

The state of a system is expressed using PFL, a process functional language, in an easily understandable manner. The paper presents PFL environment variable -- our basic concept for the state manipulation in the process functional language. Then we introduce the style in which stateful systems are described using monads and state transformers in pure lazy functional language Haskell. Finally, we describe our approach to lazy state manipulation in PFL and correspondence between state manipulation in PFL and the one in a pure lazy functional language Haskell. The proposed translation from eager PFL to a lazy Haskell provides an opportunity to exploit laziness for process functional programs and furthermore for imperative programs. The approach described in this paper was used in implemented PFL to Haskell code generator

Automatic generation of language-based tools

Many tools can be automatically derived from formal language definitions, such as compilers/interpreters, editors, analyzers, visualizers/animators, etc. Some examples of language-based tools generated automatically by the LISA system are described in the paper. In addition the specification of an algorithm animator and program visualizer, Alma, generated from an extended LISA input-grammar is discussed; LISA principles and code are reused in Alma implementation.GRICES - MCTE

Semantics-directed implementation of method-call interception

We describe a form of method-call interception (MCI) that allows the programmer to superimpose extra functionality onto method calls at run-time. We provide a reference semantics and a reference implementation for corresponding language constructs. The setup applies to class-based, statically typed, compiled languages such as Java. The semantics of MCI is used to direct a language implementation with a number of valuable properties: simplicity of the implementational model and run-time adaptation capabilities and static type safety and separate compilation and reasonable performance. Our implementational development employs sourcecode instrumentation. We start from a naive implementational model, which is subsequently refined to optimise program execution. The implementation is assessed via benchmarks

Experimental Aspect-Oriented Language - AspectCOOL

Aspect-oriented programming (AOP) is a programming technique for modularizing concerns that crosscut the basic functionality of programs. In AOP, aspect languages are used to describe properties, which crosscut basic functionality, in a clean and a modular way. AOP is currently supported mostly by aspect weavers, which require a source code for both components and aspects in order to create the final program. In this paper we have presented our approach to aspect weaving in order to achieve separate compilation. This approach to aspect weaving is used in the languages COOL and AspectCOOL, which are also presented in the paper. With this approach it is possible to apply aspects on already compiled components