Paul Klint

Static, lightweight includes resolution for PHP

Dynamic languages include a number of features that are challenging to model properly in static analysis tools. In PHP, one of these features is the include expression, where an arbitrary expression provides the path of the file to include at runtime. In this paper we present two complementary analyses for statically resolving PHP includes, one that works at the level of individual PHP files, and one targeting PHP programs possibly consisting of multiple scripts. To evaluate the effectiveness of these analyses we have applied the first to a corpus of 20 open-source systems, totaling more than 4.5 million lines of PHP, and the second to a number of programs from a subset of these systems. Our results show that, in many cases, includes can be resolved to a specific file or a small subset of possible files, enabling better IDE features and more advanced program analysis tools for PHP.

Modular language implementation in Rascal - experience report

All software evolves, and programming languages and programming language tools are no exception. And just like in ordinary software construction, modular implementations can help ease the process of changing a language implementation and its dependent tools. However, the syntactic and semantic dependencies between language features make this a challenging problem. In this paper we detail how programming languages can be implemented in a modular fashion using the Rascal meta-programming language. Rascal supports extensible definition of concrete syntax, abstract syntax and operations on concrete and abstract syntax trees like matching, traversal and transformation. As a result, new language features can be added without having to change existing code. As a case study, we detail our solution of the LDTA11 Tool Challenge: a modular implementation of Oberon-0, a relatively simple imperative programming language. The approach we sketch can be applied equally well to the implementation of domain-specific languages. We present an extended language engineering case-study in the meta programming language Rascal.The case-study is the implementation of Oberon-0 (from the LDTA11 tool challenge).The case-study illustrates the OO-like modularity features of Rascal, to support extensible syntax definition and extensible language operations.

Exploring the Limits of Domain Model Recovery

We are interested in re-engineering families of legacy applications towards using Domain-Specific Languages (DSLs). Is it worth to invest in harvesting domain knowledge from the source code of legacy applications? Reverse engineering domain knowledge from source code is sometimes considered very hard or even impossible. Is it also difficult for modern legacy systems? In this paper we select two open-source applications and answer the following research questions: which parts of the domain are implemented by the application, and how much can we manually recover from the source code? To explore these questions, we compare manually recovered domain models to a reference model extracted from domain literature, and measured precision and recall. The recovered models are accurate: they cover a significant part of the reference model and they do not contain much junk. We conclude that domain knowledge is recoverable from modern legacy code and therefore domain model recovery can be a valuable component of a domain re-engineering process.

Model Transformation with Immutable Data

Mainstream model transformation tools operate on graph structured models which are described by class-based meta-models. In the traditional grammarware space, transformation tools consume and produce tree structured terms, which are described by some kind of algebraic datatype or grammar. In this paper we explore a functional style of model transformation using Rascal, a meta-programming language, that seamlessly integrates functional programming, flexible static typing, and syntax-based analysis and transformation. We represent meta-models as algebraic data types ADTs, and models as immutable values conforming to those data types. Our main contributions are a REFS a simple encoding and API, to deal with cross references among model elements that are represented as ADTs; b a mapping from models to ADTs augmented with REFS; c evaluation of our encoding by implementing various well-known model transformations on state machines, meta-models, and activity diagrams. Our approach can be seen as a first step towards making existing techniques and tools from the modelware domain available for reuse within Rascal, and opening up Rascals transformation capabilities for use in model driven engineering scenarios.

A Library for Declarative Resolution-Independent 2D Graphics

The design of most 2D graphics frameworks has been guided by what the computer can draw efficiently, instead of by how graphics can best be expressed and composed. As a result, such frameworks restrict expressivity by providing a limited set of shape primitives, a limited set of textures and only affine transformations. For example, non-affine transformations can only be added by invasive modification or complex tricks rather than by simple composition. More general frameworks exist, but they make it harder to describe and analyze shapes. We present a new declarative approach to resolution-independent 2D graphics that generalizes and simplifies the functionality of traditional frameworks, while preserving their efficiency. As a real-world example, we show the implementation of a form of focus+context lenses that gives better image quality and better performance than the state-of-the-art solution at a fraction of the code. Our approach can serve as a versatile foundation for the creation of advanced graphics and higher level frameworks.

Game developers need lua air: static analysis of lua using interface models

Game development businesses often choose Lua for separating scripted game logic from reusable engine code. Lua can easily be embedded, has simple interfaces, and offers a powerful and extensible scripting language. Using Lua, developers can create prototypes and scripts at early development stages. However, when larger quantities of engine code and script are available, developers encounter maintainability and quality problems. First, the available automated solutions for interoperability do not take domain-specific optimizations into account. Maintaining a coupling by hand between the Lua interpreter and the engine code, usually in C++, is labour intensive and error-prone. Second, assessing the quality of Lua scripts is hard due to a lack of tools that support static analysis. Lua scripts for dynamic analysis only report warnings and errors at run-time and are limited to code coverage. A common solution to the first problem is developing an Interface Definition Language (IDL) from which glue code, interoperability code between interfaces, is generated automatically. We address quality problems by proposing a method to complement techniques for Lua analysis. We introduce Lua AiR (Lua Analysis in Rascal), a framework for static analysis of Lua script in its embedded context, using IDL models and Rascal.