Albert Shaqiri

Neverlang 2: a framework for modular language implementation

Neverlang 2 is a JVM-based framework for language development that emphasizes code reuse through composition of language features. This paper is aimed at showing how to develop extensible, custom languages using Neverlangs component-based model of implementation. Using this model, each feature of the language can be implemented as a separate, conceptually isolated unit that can be compiled and distributed separately from the others. A live tutorial of the framework can be found at http://youtu.be/Szxvg7XLbXc

Open Programming Language Interpreters

Context: This paper presents the concept of open programming language interpreters and the implementation of a framework-level metaobject protocol (MOP) to support them. Inquiry: We address the problem of dynamic interpreter adaptation to tailor the interpreters behavior on the task to be solved and to introduce new features to fulfill unforeseen requirements. Many languages provide a MOP that to some degree supports reflection. However, MOPs are typically language-specific, their reflective functionality is often restricted, and the adaptation and application logic are often mixed which hardens the understanding and maintenance of the source code. Our system overcomes these limitations. Approach: We designed and implemented a system to support open programming language interpreters. The prototype implementation is integrated in the Neverlang framework. The system exposes the structure, behavior and the runtime state of any Neverlang-based interpreter with the ability to modify it. Knowledge: Our system provides a complete control over interpreters structure, behavior and its runtime state. The approach is applicable to every Neverlang-based interpreter. Adaptation code can potentially be reused across different language implementations. Grounding: Having a prototype implementation we focused on feasibility evaluation. The paper shows that our approach well addresses problems commonly found in the research literature. We have a demonstrative video and examples that illustrate our approach on dynamic software adaptation, aspect-oriented programming, debugging and context-aware interpreters. Importance: To our knowledge, our paper presents the first reflective approach targeting a general framework for language development. Our system provides full reflective support for free to any Neverlang-based interpreter. We are not aware of any prior application of open implementations to programming language interpreters in the sense defined in this paper. Rather than substituting other approaches, we believe our system can be used as a complementary technique in situations where other approaches present serious limitations.

Modularity and optimization in synergy

As with traditional software, the complexity of a programming language implementation is faced with modularization which favors the separation of concerns, independent development, maintainability and reuse. However, modularity interferes with language optimization as the latter requires context information that crosses over the single module boundaries and involves other modules. This renders hard to provide the optimization for a single language concept to be reusable with the concept itself. Therefore, the optimization is in general postponed to when all language concepts are available. We defined a model for modular language development with a multiple semantic actions dispatcher based on condition guards that are evaluated at runtime. The optimization can be implemented as context-dependent extensions applied a posteriori to the composed language interpreter without modifying a single component implementation. This renders effective the defined optimization within the language concept boundaries according to the context provided by other language concepts when available and eases its reuse with the language concepts implementation independently of its usage context. The presented model is integrated into the Neverlang development framework and is demonstrated on the optimization of a Javascript interpreter written in Neverlang. We also discuss the applicability of our model to other frameworks for modular language development.

μ-DSU : A Micro-Language Based Approach to Dynamic Software Updating

Abstract Today software systems play a critical role in society’s infrastructures and many are required to provide uninterrupted services in their constantly changing environments. As the problem domain and the operational context of such software changes, the software itself must be updated accordingly. In this paper we propose to support dynamic software updating through language semantic adaptation; this is done through use of micro-languages that confine the effect of the introduced change to specific application features. Micro-languages provide a logical layer over a programming language and associate an application feature with the portion of the programming language used to implement it. Thus, they permit to update the application feature by updating the underlying programming constructs without affecting the behaviour of the other application features. Such a linguistic approach provides the benefit of easy addition/removal of application features (with a special focus on non-functional features) to/from a running application by separating the implementation of the new feature from the original application, allowing for the application to remain unaware of any extensions. The feasibility of this approach is demonstrated with two studies; its benefits and drawbacks are also analysed.

Dynamic software evolution through interpreter adaptation

Significant research has been dedicated to dynamic software evolution and adaptation that lead to different approaches which can mainly be categorized as either architecture-based or language-based. But there was little or no focus on dynamic evolution achieved through language interpreter adaptation. In this paper we present a model for such adaptations and illustrate their applicability and usefulness on practical examples developed in Neverlang, a framework for modular language development with features for dynamic adaptation of language interpreters.

Compiling Functional to Scripting Languages

In this paper we consider the problem of translating a core typed functional language, F#(including mutable variables), into scripting languages such as JavaScript or Python. We abstract the most significant characteristics of such scripting languages in an intermediate language (IL for short), which is an imperative language, with constructs for handling safely pieces of code containing free variables. We define an operational semantics for IL and highlight the proof of correctness of the translation.

A Provably Correct Compilation of Functional Languages into Scripting Languages

In this paper we consider the problem of translating core F#, a typed functional language including mutable variables, into scripting languages such as JavaScript or Python. In previous work, we abstracted the most significant characteristics of scripting languages in an intermediate language (IL for short), which is an imperative language with definition of names (variables and functions) done in blocks and where a definition of a name does not have to statically precede its use. We define a big-step operational semantics for core F# and for IL and formalise the translation of F# expressions into IL. The main contribution of the paper is the proof of correctness of the given translation, which is done by showing that the evaluation of a well-typed F# program converges to a primitive value if and only if the evaluation of its translation into IL converges to the same value. For this proof is crucial the type soundness of core F# which is proved by giving a coinductive formalization of the divergence predicate and proving that well-typed expressions either converge to a value or diverge and so they are never stuck.

Context-Aware Software Variability through Adaptable Interpreters

Dynamic adaptation to the execution context is desirable in software that operates in an evolving environment. Context-oriented programming (COP) languages address behavioral variability from the programming-language perspective. COP has proven to be a valid approach when software is developed from scratch. However, it might require invasive, error-prone modifications when contextual variability is introduced to existing software written in non-COP languages, especially when variability is implicit in language constructs. A proposed approach moves variability support from the language to the language implementation level. This enables contextual variability in any application independently of whether the underlying language supports COP. A Neverlang-based prototype implementation illustrates this approach.