A frequent dilemma in programming language design is the choice between a language with a rich set of notations and a small, simple core language. We address this dilemma by proposing extensible grammars, a syntax-definition formalism for incremental language extensions and restrictions.

The translation of programs written in rich object languages into a small core language is defined via syntax-directed patterns. In contrast to macro-expansion and program-rewriting tools, our extensible grammars respect scoping rules. Therefore, we can introduce binding constructs while avoiding problems with unwanted name clashes.

We develop extensible grammars and illustrate their use by extending the lambda calculus with let-bindings, conditionals, and constructs from database programming languages, such as SQL query expressions. We then give a formal description of the underlying rules for parsing, transformation, and substitution. Finally, we sketch how these rules are exploited in the implementation of a generic, extensible parser package.

This text is a revised and expanded version of [CMA94]

This document provides a brief overview of the Tycoon Machine Language TML which is used as a persistent intermediate program representation within the Tycoon system. TML representations of Tycoon programs provide the basis for extensive tree analysis and rewriting aiming at various optimizations which are independent of source languages and target machines.

TML representations are used for both static (compile-time) and dynamic (runtime) optimizations. Dynamic optimizations are of particular importance for performance improvement of large and modular programs.

TML is based on Continuation Passing Style (CPS), a powerful yet simple program representation technique developed as a framework for optimizing compilers. The advantage of CPS lies in the significant reduction in number of program constructs to be handled by the Tycoon static and dynamic (reflective) optimizer.

We propose that in modern persistent data-intensive applications traditional database query optimization be integrated into a more generalized framework for extensive program analysis and transformation.

Persistent threads are a database programming concept particularly well-suited for applications that manage long-term, distributed or cooperative activities. We introduce persistent threads as a novel form of bindings from data in persistent object stores to activated code and relate them to existing binding concepts found in database programming. We also describe the integration of persistent threads into a polymorphically-typed database language and its supporting layered system architecture with particular emphasis on abstractly-defined thread representations which support thread analysis, optimization and portability.

This text provides an introduction to Tycoon (Typed Communicating Objects in Open Environments), an open persistent polymorphic programming environment. The Tycoon language TL is based on expressive and orthogonal naming, typing and binding concepts as they are required, for example, in advanced data-intensive applications. The characteristic language mechanisms of TL are first-class functions and modules, parametric and subtype polymorphism extended to a fully higher-order type system. Tycoon programs are statically typed but may include explicit dynamic type variables which can be inspected at run-time.

Scoping, naming and binding are central concepts in the definition and understanding of programming languages. With the introduction of sophisticated data models, these issues become important for query languages as well. Additionally, the goal of integrating query and programming languages requires a common basis for their operational semantics. We offer here an approach to the definition of the operational semantics of query languages based on an abstract machine, in which names, their bindings, and scopes defined by query and data structure are central. The machine has own simple data model for its store, and has a stack for dealing with scopes. We argue for the generality of the approach and illustrate it by defining the semantics of many query language primitives. Finally, we briefly consider how assignment and procedures can be neatly added.