Pi: a Pattern Language

@inproceedings{Knll2009PiAP,
  title={Pi: a Pattern Language},
  author={Roman Kn{\"o}ll and Mira Mezini},
  booktitle={OOPSLA},
  year={2009}
}
Current programming languages and techniques realize many features which allow their users to extend these languages on a semantic basis: classes, functions, interfaces, aspects and other entities can be defined. However, there is a lack of modern programming languages which are both semantically and syntactically extensible from within the language itself, i.e., with no additional tool or meta-language. In this paper we present π as an approach that aims to overcome this lack. π provides an… 
A General Framework for Embedding Domain Specific Languages into Object-Oriented Programming Languages
TLDR
This paper introduces a general framework of language embedding in OO host languages, which can be fully implemented in Java without ACPs, and shows how it can encode the parser, AST builder, type checker, and interpreter for the simply typed lambda calculus in a concrete syntax without redundant brackets or commas.
Modular , Statically Typed , Flexibly Extensible Programming Language
TLDR
MOSTflexiPL follows this approach by allowing users to define new operators, control structures, type constructors, and ev en declaration forms almost as easily as functions without sacrificing static type safety.
MOST-flexiPL: modular, statically typed, flexibly extensible programming language
TLDR
MOSTflexiPL follows this approach by allowing users to define new operators, control structures, type constructors, and even declaration forms almost as easily as functions without sacrificing static type safety.
Pattern languages: addressing the challenges
TLDR
The concept of pattern languages has spilled over into the software engineering field to describe prior experiences and those processes that stem from them, in a very simple and easy to understand language, where patterns are tactfully woven as a whole.
Eria : Meta Programming with Programmable Inference
TLDR
The Eria programming language is introduced, several examples of application of Eria are shown, and FE, a core calculus of Erias based on the FGJ is formally presented.
A Multiparadigmatic Study of the Object-Oriented Design Patterns
TLDR
Considering the classic object-oriented programming (OOP) design patterns as described in the GoF book, this paper systematically looks at them from the viewpoint of other paradigms, in particular the generic modular and the functional paradigm.
Incremental concrete syntax for embedded languages with support for separate compilation
A Short Catalogue of Abstraction Patterns for Model-Based Software Engineering
  • B. Selic
  • Computer Science
    Int. J. Softw. Informatics
  • 2011
TLDR
This work identifies and describes some of the most common abstraction patterns used by software architects to render a complex system into a more comprehensible form and opens the possibility of providing automation support for documenting and validating the steps involved in transitioning between system representations at different levels of abstraction.
Automating Middleware Configuration and Specializations via Model-based Aspect-Oriented Software Development
TLDR
This work demonstrates an approach to middleware specialization using aspects oriented programming, and describes how aspect-oriented technique is applied to address crosscutting concerns in metadata management for a high performance distributed storage framework.
Incremental concrete syntax for embedded languages
TLDR
This paper presents an approach that significantly reduces the necessary effort to implement embedded DSLs with concrete syntax by using island grammars to specify the EDSL's concrete syntax.
...
...

References

SHOWING 1-10 OF 52 REFERENCES
The Java syntactic extender (JSE)
TLDR
This paper introduces a macro facility, called the Java Syntactic Extender (JSE), with the superior power and ease of use of Lisp macro sytems, but for Java, a language with a more conventional algebraic syntax.
Growing languages with metamorphic syntax macros
TLDR
A syntax macro language which is designed to guarantee type safety and termination, and a concept of metamorphisms allows the arguments of a macro to be inductively defined in a meta level grammar and morphed into the host language.
OMeta: an object-oriented language for pattern matching
TLDR
OMeta's general-purpose pattern matching provides a natural and convenient way for programmers to implement tokenizers, parsers, visitors, and tree transformers, all of which can be extended in interesting ways using familiar object-oriented mechanisms.
Abstraction mechanisms in the BETA programming language
TLDR
In this paper the sequential part of BETA will be presented to demonstrate the use of the pattern/subpatternmechanism with virtual patterns as a powerful abstraction mechanism.
Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions
TLDR
MetaBorg is described, a method for providing concrete syntax for domain abstractions to application programmers by embedding domain-specific languages in a general purpose host language and assimilating the embedded domain code into the surrounding host code.
Programmable syntax macros
TLDR
This research solves the problems of having the macro language be a minimal extension of the programming language, by introducing explicit code template operators into the macros language, and by using a type system to guarantee, at macro definition time, that all macros and macro functions only produce syntactically valid program fragments.
The introduction of definitional facilities into higher level programming languages
TLDR
The purpose of this paper is to present a scheme for employing definitional or "macro" features in a higher level programming language and to indicate the kinds of extensions one might propose to current programming languages in order to usefully employ these kinds of facilities.
Language-Oriented Programming
TLDR
The concept of language oriented programming is described, which is a novel way of organising the development of a large software system, leading to a different structure for the finished product.
Some remarks on the syntax of symbolic programming languages
TLDR
The main aim is to point out certain peculiar features of SPL's which yield a deeper insight into their linguistic nature from a formal point of view, in order to take further steps in the direction of finding a proper way to define them.
A survey of adaptable grammars
TLDR
It is shown that this distinction between syntax and semantics can be made clearer using grammars which adapt themselves to the current program contexts, and the advantages and disadvantages of describing programming language syntax this way are described.
...
...