Markus Lepper

Testable use cases in the Abstract State Machine Language

Use cases are a method for describing interactions between humans and/or systems. However, despite their popularity there is no agreed formal syntax and semantics of use cases. The Abstract State Machine Language (ASML) is an executable specification language developed at Microsoft Research. We define an encoding of use cases in ASML and demonstrate the advantages by describing techniques to generate test cases and test oracles from the encoding.

Using use cases in Executable Z

Use cases are a widespread informal method for specifying the requirements of a technical system in the early development phase. Z is a formal notation which aims to support, beside others, the specification of early requirements. We develop a representation of use cases in Z and apply it to several examples. Our focus is on instrumenting the formalization for black-box test evaluation in Executable Z, a computation model and implementation for Z based on concurrent constraint resolution.

Optimization of visitor performance by reflection-based analysis

Visitors are a well-known and powerful design pattern for processing regular data structures and for combining declarative and imperative coding styles. The authors umod model generator creates Java data models from a concise and algebraic notation. It is primarily used to model intermediate representations of computer languages. The user defines visitor code by extending skeleton classes, which are generated according to traversal annotations in the model. Since the generated code on its own executes the pure traversal and no semantic side-effects, traversals are redundant unless some user-overridden method is eventually invoked. We present a reflection-based control flow analysis to detect this situation and prune the traversal transparently. With a well-stratified model, this may lead to substantial increase in performance.

Automatic Construction of XML-Based Tools Seen as Meta-Programming

This article presents XML-based tools for parser generation and data binding generation. The underlying concept is that of transformation between formal languages, which is a form of meta-programming. We discuss the benefits of such a declarative approach with well-defined semantics: productivity, maintainability, verifiability, performance and safety.

Paisley: pattern matching à la carte

Professional development of software dealing with structured models requires more systematic approach and semantic foundations than standard practice in general-purpose programming languages affords. One remedy is to move to domain-specific environments. Here, instead, we present a tool for the implementation of pattern matching as fundamental means of automated data extraction from complex models in a general-purpose programming language. The interface is simple but, thanks to elaborate and rigorous design, is also light-weight, portable, non-invasive, type-safe, modular and extensible. It is compatible with object-oriented data abstraction and has full support for nondeterminism by backtracking. The tool comes as a library consisting of two levels: elementary pattern constructs (generic, highly reusable) and pattern bindings for particular data models (specific, fairly reusable, user-definable). Applications use the library code in a small number of idiomatic ways, making pattern-matching code declarative in style (yet retaining richer host-language semantics), easily writable, readable and maintainable. Library and idiom together form a tightly embedded domain-specific language; no extension of the host language is required. The current implementation is in Java, but assumes only standard object-oriented features, and can hence be ported to other mainstream languages.

The shepard tone and higher-order multi-rate synchronous data-flow programming in Sig

The total functional real-time data-flow programming language Sig features a core layer with elegant denotational semantics, in terms of Mealy stream transducers and coiterative causal stream functions, that is convenient for domain experts in the primary application domains, such as scientific modeling and digital music and event arts. The core suffices for the implementation of many basic signal processing components. For the expression of more sophisticated computations, a second layer of Sig provides additional features, namely higher-order functional programming and multi-rate synchronicity, reducible by transformational semantics to the core layer. Here we describe the design of the upper layer of Sig and demonstrate its usage with the Shepard Tone, a well-known sound synthesis problem and model of psycho-acoustically paradoxical perception of relative musical pitch.

Foundations of Total Functional Data-Flow Programming

The field of declarative stream programming (discrete time, clocked synchronous, modular, data-centric) is divided between the data-flow graph paradigm favored by domain experts, and the functional reactive paradigm favored by academics. In this paper, we describe the foundations of a framework for unifying functional and data-flow styles that differs from FRP proper in significant ways: It is based on set theory to match the expectations of domain experts, and the two paradigms are reduced symmetrically to a low-level middle ground, with strongly compositional semantics. The design of the framework is derived from mathematical first principles, in particular coalgebraic coinduction and a standard relational model of stateful computation. The abstract syntax and semantics introduced here constitute the full core of a novel stream programming language.

On-Line Synchronous Total Purely Functional Data-Flow Programming on the Java Virtual Machine with Sig

Sig is the prototype of a purely declarative programming language and system for the processing of discrete, clocked synchronous, potentially real-time data streams. It aspires to combine good static safety, scalability and platform independence, with semantics that are precise, concise and suitable for domain experts. Its semantical and operational core has been formalized. Here we discuss the general strategy for making Sig programs executable, and describe the current state of a prototype compiler. The compiler is implemented in Java and targets the JVM. By careful cooperation with the JVM just-in-time compiler, it provides immediate executability in a simple and quickly extensible runtime environment, with code performance suitable for moderate real-time applications such as interactive audio synthesis.

Solving the TTC 2011 Compiler Optimization Task with meta tools

The authors metatools are a collection of tools for generic programming. This includes generating Java sources from mathematically well-founded specifications, as well as the creation of strictly typed document object models for XML encoded texts. In this context, almost every computer-internal structure is treated as a model, and every computation is a kind of model transformation. nThis concept differs significantly from classical model transformation executed by specialized tools and languages. Therefore it seemed promising to the organizers of the TTC 2011, as well as to the authors, to apply metatools to one of the challenges, namely to the compiler optimization task. This is a report on the resulting experiences.

Laminar Data Flow: On the Role of Slicing in Functional Data-Flow Programming

We use the concept of laminar flow, as opposed to turbulent flow, as a metaphor for the decomposition of well-behaved purely functional data-flow programs into largely independent parts, necessitated by aspects with different execution constraints. In the context of the total functional data-flow language Sig, we identify three distinct but methodologically related implementation challenges, namely multi-rate scheduling, declarative initialization, and conditional execution, and demonstrate how they can be solved orthogonally, by decomposition using the standard program transformation technique, slicing.