GPCE Technical Program

You can now find the proceedings online. 

Tuesday, September 23

9:00 - 10:00	GPCE Mini-tutorial: Scheme-Style Macros: Patterns and Lexical Scope. Matthew Flatt (University of Utah)   Parallel presentation (same time, different location): NetObjectDays Keynote Address. Complete Concurrent Specification Using UML. Stephen J. Mellor (Project Technology, Inc.)
10:00 - 10:15	Coffee break
10:15 - 11:45	Session 1: DSLs. Chair: Julia Lawall
11:45 - 12:00	Coffee break
12:00 - 13:30	Session 2: Staged Programming. Chair: Peter Thiemann
13:30 - 14:30	Lunch
14:30 - 15:15	GPCE Invited Talk. A Journey from Interpreters to Compilers and Virtual Machines Olivier Danvy (BRICS, University of Aarhus) Chair: Peter Thiemann
15:15 - 15:30	Coffee break
15:30 - 17:15	Session 3: Modeling to Code / Practitioner's Report. Chair: Ulrich Eisenecker
17:15 - 17:20	Coffee break
17:20 - 18:50	Demonstrations 1&2: Metamodeling

 

Wednesday, September 24

9:00 - 10:00	GPCE Mini-tutorial: Attribute Grammars. Doaitse Swierstra (Universiteit Utrecht) Parallel presentation (same time, different location): NetObjectDays Keynote Address. Keynote: Agent UML: What is it, and why do I care? James J. Odell (James Odell Associates)
10:00 - 10:15	Coffee break
10:15 - 11:45	Session 4: Aspect-Orientation. Chair: tbd
11:45 - 12:00	Coffee break
12:00 - 13:30	Session 5: Meta-Programming and Language Extension. Chair: Ulrich Eisenecker
13:30 - 14:30	Lunch
14:30 - 15:15	GPCE Invited Talk. Towards a More Piece-ful World Peri Tarr (IBM Thomas J. Watson Research Center) Chair: tbd
15:15 - 15:30	Coffee break
15:30 - 17:00	Session 6: Automating Design-To-Code Transitions. Chair: tbd
17:00 - 17:15	Coffee break
17:20 - 18:45	Demonstrations 3&4: Model-Driven Architecture

 

Thursday, September 25

9:00 - 10:00	NetObjectDays Keynote Address. Software Product-Line Engineering David Weiss - Avaya Labs Research
10:00 - 10:15	Coffee break
10:15 - 11:45	Session 7: Principled Domain-Specific Approaches. Chair: Eugenio Moggi
11:45 - 12:00	Coffee break
12:00 - 13:30	Session 8: Generation and Translation / Closing Discussion. Chair: tbd
13:30 - 14:30	Lunch
14:30 - 15:15	SOAP and all the REST Stefan Mintert
15:15 - 15:30	Coffee break
15:30 - 17:00	Demonstrations 5&6: Generative Development

 

Session Details

Session 1: DSLs

• Spidle: A DSL Approach to Specifying Streaming Applications 
Charles Consel (INRIA / LaBRI),
Hedi Hamdi (INRIA / LaBRI),
Laurent Réveillère (INRIA / LaBRI),
Henry Yu (INRIA / LaBRI),
Calton Pu (Georgia Tech),
Lenin Singaravelu (Georgia Institure of Technology)

Multimedia stream processing is a rapidly evolving domain which requires much software development and expects high performance. Developing a streaming application often involves low-level programming, critical memory management, and finely tuned scheduling of processing steps. To address these problems, we present a domain-specific language (DSL) named Spidle, for specifying streaming applications. Spidle offers high-level and declarative constructs; compared to general-purpose languages (GPL), it improves robustness by enabling a variety of verifications to be performed. To assess the expressiveness of Spidle in practice, we have used it to specify a number of standardized and special-purpose streaming applications. These specifications are up to 2 times smaller than equivalent programs written in a GPL such as C. We have implemented a compiler for Spidle. Preliminary results show that compiled Spidle programs are roughly as efficient as the compiled, equivalent C programs.


• TDL: A Hardware Description Language for Retargetable Postpass Optimizations and Analyses 
  Daniel Kaestner (Saarland University & AbsInt GmbH) 
  
  The hardware description language TDL has been designed with the goal to generate machine-dependent postpass optimizers and analyzers from a concise specification of the target processor. TDL is assembly-oriented and provides a generic modeling of irregular hardware constraints that are typical for many embedded processors. The generic modeling supports graph-based and search-based optimization algorithms. An important design goal of TDL was to achieve extendibility, so that TDL can be easily integrated in different target applications. TDL is at the base of the PROPAN system that has been developed as a retargetable framework for high-quality code optimizations at assembly level. For two contemporary microprocessors, the Analog Devices SHARC 2106x, and the Philips TriMedia TM1000, significant improvements of the code produced by production-quality compilers could be achieved with short retargeting time. TDL has also been used for implementing postpass optimizations for the Infineon C16x/ST10 processor that are part of a commercial postpass optimizer. TDL specifications are concise and can be produced in short time.
  
  
• Hume: a Domain-Specific Language for Real-Time Embedded Systems
  Kevin Hammond (University of St Andrews),
  Greg Michaelson (Heriot-Watt University) 
  
  This paper describes Hume: a novel domain-specific language whose purpose is to explore the expressibility/costability spectrum in resource-constrained systems, such as real-time embedded or control systems. Hume provides a number of high level features including higher-order functions, polymorphic types, arbitrary but sized user-defined data structures, asynchronous processes, lightweight exception handling, automatic memory management and domain-specific metaprogramming features, whilst seeking to guarantee strong space/time behaviour and maintaining overall determinacy.
  

Session 2: Staged Programming

• Implementing Multi-stage Languages Using ASTs, Gensym, and Reflection 
Cristiano Calcagno (Imperial College London),
Walid Taha (Rice University),
Liwen Huang (Yale University),
Xavier Leroy (INRIA Rocquencourt) 

The paper addresses theoretical and practical aspects of implementing multi-stage languages using abstract syntax trees (ASTs), gensym, and reflection. We present an operational account of the correctness of this approach, and report on our experience with a bytecode compiler (called MetaOCaml) based on this strategy. Current performance measurements reveal interesting characteristics of the underlying (OCaml) compiler, and illustrate why this strategy can be particularly useful for implementing domain-specific languages (DSL) in a typed, functional setting.


• On Stage Ordering in Staged Computation
  Zhenghao Wang (University of California Los Angeles),
  Richard Muntz (University of California at Los Angeles) 
  
  A staged computation is a computation organized in a cascade of stages: each stage produces code for its successive stage; the final stage produces the desired output. An off-line procedure called binding time analysis (BTA) is often used to pre-convert unstaged code into staged code, i.e., code annotated with stage labels, which can guide online staged computation. For dynamic re-optimization purposes, it is advantageous forthe order of stages in the cascade for a staged code to change during runtime; however, the staged code may not support all permutations of stage sequences. Thus, it is both a fundamental and practical question to efficiently decide whether a specific stage sequence is valid for a staged code. Our approach is to encode the set of valid stage sequences for a staged code off-line in a \emph{stage ordering encoding language} (SOEL) to facilitate fast online decision. Contrary to the intuition that we only need a single generic SOEL (such as the language of partially ordered sets of stage labels) to sufficiently and efficiently encode the set of valid stage sequences for any staged code in any staged language, we may need different SOELs for different staged languages. We analyze several staged languages and then present a metatheory on validating a SOEL for a given staged language. Our result reveals the relationship between SOELs and semantic properties of staged languages, and can influence the design of staged languages and BTA.
  
  
• Staged Notational Definitions
  Walid Taha (Rice University),
  Patricia Johann (Rutgers University) 
  
  Recent work proposed defining type-safe macros via interpretation into a multi-stage language. The utility of this approach is illustrated with a language called MacroML, in which all type checking is carried out before macro expansion. Building on the this work, the goal of this paper is to develop a macro language that makes it easy for programmers to reason about terms locally (i.e., without reference to context information). This paper argues that viewing ``macros as multi-stage computations'' helps in developing and verifying not only type systems for macro languages but also equational reasoning principles. However, such results are not easily established with the MacroML calculus. We therefore present calculus of staged notational definitions (SND) that eliminates ad hoc features of MacroML but retains its phase distinction, and incorporates the generality of Griffin's account of notational definitions. We exhibit a formal equational theory for such a calculus and prove its soundness.
  
  

Session 3: Modeling to Code / Practitioner's Report

• DAOP-ADL: An Architecture Description Language for Dynamic Component and Aspect-Based Development 
Monica Pinto (University of Malaga),
Lidia Fuentes (University of Malaga),
Jose Maria Troya (University of Malaga) 

Architecture description languages deal with the description, analysis and reuse of software architectures. This paper describes DAOP-ADL, a component- and aspect-based language to specify the architecture of an application in terms of components, aspects and a set of plug-compatibility rules between them. With the aim of connecting the specification of the application architecture to the implementation, we describe our language using XML and XML Schemas. The DAOP-ADL language was designed to be interpreted by DAOP, our own dynamic component- and aspect-oriented platform. DAOP provides a composition mechanism that plugs aspects into components dynamically at runtime. The software architect will use the DAOP-ADL language at design time to describe the architecture of the application. Later this architectural information is loaded into the DAOP platform, which needs it to establish the dynamic connections between autonomous components and aspects. Therefore, the use of DAOP-ADL closes the gap between design and implementation of component- and aspect-based applications.


• ANEMIC: Automatic Interface Enabler for Model Integrated Computing 
  Steven Nordstrom (Vanderbilt University),
  Shweta Shetty (Vanderbilt University),
  Kumar Chhokra (Vanderbilt University),
  Jonathan Sprinkle (Vanderbilt University),
  Brandon Eames (Vanderbilt University),
  Akos Ledeczi (Vanderbilt University)
   
  A domain-specific programming language provides domain experts with a familiar abstraction for creating computer programs. As more and more domains embrace the power of computers, programmers are tapping into the power of the domain-specific language by creating their own languages for the manipulation and storage of data. Visual programming, or graphical model-ing further takes advantage of the domain-specific language by allowing mod-eling experts to create domain-specific visual languages through metamodeling. At modeling time, domain-specific modeling language constructs are trans-formed into a domain artifact through a special compiler called an interpreter. The Generic Modeling Environment (GME) at Vanderbilt University is a meta-programmable modeling environment. Interpreters written to interface with GME models can manually extend a provided domain-independent API such that it is domain-specific. This paper presents a tool called ANEMIC that gen-erates a customized API for a GME interpreter using the same metamodel that generates the language.
  
  
• Practitioner's Report: Practical Experience with Frame-Based Generators
  Cord Giese (Delta Software Technology GmbH)
  
  More and more generator techniques and products become available. Some of them, such as frame-based generator systems, are appropriate for performing ambitious generation tasks. However, most commercial projects use generators for rather low-level, non-critical purposes and are skeptical about their wider use. In particular, there is a popular argument that the effort needed to use a generator technique outweighs its advantages. In several projects, Delta Software Technology Group has gained experience disproving this argument.
  The report starts with a short introduction to frame technologies. As a first reference concerning the practical usage of frame-based generators, we discuss our experience in a project at an insurance company located in Switzerland. As it turned out, the solutions implemented in this project were sufficient for the project, but could not be generalized. With this experience and the mentioned anti-generator argument in mind, a second commercial project was undertaken; this time using improved generation tools and an improved solution architecture. We present the lessons of this second project: among others, a special kind of meta-programming, which played an important role. The report concludes with a discussion of the pros and cons of the practical usage of generators.
  
  

Session 4: Aspect-Orientation

• An Approach for Supporting Aspect-Oriented Domain Modeling 
Jeff Gray (University of Alabama at Birmingham),
Ted Bapty (Vanderbilt University),
Sandeep Neema (Vanderbilt University),
Doug Schmidt (Vanderbilt University),
Aniruddha Gokhale (Vanderbitl University),
Bala Natarajan (Vanderbilt University) 

This paper describes a technique for improving separation of concerns at the level of domain modeling. A contribution of this new approach is the construction of support tools that facilitate the elevation of crosscutting modeling concerns to first-class constructs in a type-system. The key idea is the application of a variant of the OMG Object Constraint Language to models that are stored persistently in XML. With this approach, weavers are generated from domain-specific descriptions to assist a modeler in exploring various alternative modeling scenarios. The paper examines several facets of Aspect-Oriented Domain Modeling (AODM), including: domain-specific model weavers, a language to support the concern separation, an overview of code generation issues within a meta-weaver framework, and a comparison between AODM and AOP. An example of the approach is provided, as well as a description of several future concepts for extending the flexibility within AODM.


• The Convergence of AOP and Active Databases: Towards Reactive Middleware Mariano
  Mariano Cilia (Darmstadt University of Technology),
  Michael Haupt (Darmstadt University of Technology),
  Mira Mezini (Darmstadt University of Technology),
  Alejandro Buchmann (Darmstadt University of Technology)
   
  Reactive behavior is rapidly becoming a key feature of modern software systems in such diverse areas as ubiquitous computing, autonomic systems, and event-based supply chain management. In this paper we analyze the convergence of techniques from aspect oriented programming, active databases and asynchronous notification systems to form reactive middleware. We identify the common core of abstractions and explain both commonalities and differences to start a dialogue across community boundaries. We present existing options for implementation of reactive software and analyze their run-time semantics. We do not advocate a particular approach but concentrate on identifying how the various disciplines can benefit from each other. We believe that AOP can solve the impedance mismatch found in reactive systems that are implemented through inherently static languages, while AOP can benefit from the active database community's experience with event detection/composition and fault tolerance in large scale systems. The result could be a solid foundation for the realization of reactive middleware services.
  
  
• A Selective, Just-In-Time Aspect Weaver 
  Yoshiki Sato (Tokyo Institute of Technology),
  Shigeru Chiba (Tokyo Institute of Technology),
  Michiaki Tatsubori (IBM Tokyo Research Laboratory) 
  
  Dynamic aspect-oriented programming (AOP) is getting growing interests in both the academia and the industry. Since it allows weaving aspects with a program at runtime, it is useful for rapid prototyping and adaptive software. However, the previous implementations of dynamic AOP systems involved serious performance penalties. This paper presents our new implementation technique in Java for addressing this problem. This technique called just-in-time hook insertion hybrides two approaches. When a new aspect is woven, the programmers can select to reload into the JVM a modified class file in which hooks for executing advice are statically embedded. Otherwise, they can select to insert hooks as breakpoints in the JVM. Since the two approaches have di®erent performance characteristics, the programmers can select the best one for each join point. We developed a dynamic AOP system based on this idea. This paper also shows this system named Wool and the performance results of our experiments on this system.
  
  

Session 5: Meta-Programming and Language Extension

• An extension to the subtype relationship in C++ implemented with template metaprogramming 
Istvan Zolyomi (Eotvos Lorand University),
Zoltan Porkolab (Eotvos Lorand University),
Tamas Kozsik (Eotvos Lorand University) 

Families of independent classes, where each class represents a separate, orthogonal concern are highly attractive for implementing collaboration-based design. However, required subtype relationship between such families cannot be expressed in many programming languages. This paper presents a framework to handle collaborating groups of classes using template metaprogramming based on standard C++ features in the style of Loki::Typelist. Our solution provides tailor-made implicit conversion rules between appropriate groups, inclusion polymorphism and a tool for dynamic binding.


• Concept-Controlled Polymorphism 
  Jaakko Järvi (Indiana University),
  Jeremiah Willcock (Indiana University),
  Andrew Lumsdaine (Indiana University) 
  
  Concepts--sets of abstractions related by common requirements--have a central role in generic programming. This paper proposes a general framework for using concepts to control polymorphism in different ways. First, concepts can be used to constrain parametric polymorphism, as exemplified by type classes in Haskell. Second, concepts can be used to provide fine-grained control of function and operator overloading. Finally, generic functions can be overloaded (specialized) based on concepts, rather than simply on types. We describe a C++ implementation of a new mechanism, which we call enable_if, and its role in concept-controlled polymorphism.
  
  
• Component Based DSL Development 
  Thomas Cleenewerck (Vrije Universiteit Brussel) 
  
  Domain specific languages (DSLs) have proven to be a very adequate mechanism to encapsulate and hide the complex implementation details of component-based software development. Since evolution lies at the heart of any software system the DSLs that were built around them must evolve as well. In this paper we identify important issues that cause a DSL implementation to be very rigid in which all phases are tightly coupled and highly dependent upon one another. To increase the poor evolvability of current day DSL development environments a new development environment Keyword based programming (KBP) is proposed where DSLs are built by using a language specification to compose and glue loosely coupled and independent language components (called keywords).
  
  

Session 6: Automating Design-To-Code Transitions

• A Generative Approach to Framework Instantiation 
Alessandro Pasetti (ETH-Zurich),
Vaclav Cechticky (ETH-Zürich),
Philippe Chevalley (ESA-Estec),
Walter Schaufelberger (ETH-Zurich) 

This paper describes the OBS Instantiation Environment, which demonstrates a generative approach to automating the instantiation process of a component-based framework. The process is automated in the sense that designers configure and assemble the framework components using intuitive visual operations in a GUI-based environment. Their configuration actions are then used to automatically generate the framework instantiation code. Generative techniques for framework instantiation are not new but tend to rely on domain-specific languages or on bespoke specification encoding and compilation techniques. Though effective and powerful, they are comparatively complex and present a high barrier to entry for general users. The distinctive feature of the approach proposed here is instead its simplicity and its reliance on mainstream technology and tools.


• Making Patterns Explicit with Metaprogramming 
  Daniel Dincklage (University of Colorado, Boulder) 
  
  Design patterns have been a useful tool for a better understanding of the collaboration between several classes and objects in a program. One drawback of this approach is the lack of an explicit representation of the patterns used in a program, as the collaboration between classes normally is expressed in the code of the class itself. In this paper, we present a method for explicitly representing patterns in a program with the help of metaprogramming techniques. The method presented has benefits compared to traditional approaches with respect to documentation and reusability of the program, as well as providing a better separation of the protocol contained in the pattern.
  
  
• Discussion
  
  

Session 7: Principled Domain-Specific Approaches

• Generating Spreadsheet-like Tools from Strong Attribute Grammars 
  Joao Saraiva (University of Minho),
  Doaitse Swierstra (Universiteit Utrecht)
   
  This paper presents techniques for the formal specification and efficient incremental implementation of spreadsheet-like tools. The spreadsheets are specified by strong attribute grammars. In this style of attribute grammar programming every single inductive computation is expressed within the attribute grammar formalism. Well-known attribute grammar techniques are used to reason about such grammars. For example, ordered scheduling algorithms can be used to statically guarantee termination of the attribute grammars and to derive efficient implementations. A strong attribute grammar for a spreadsheet is defined and the first incremental results are presented.
  
  
• SynchNet: A Petri Net based coordination language for distributed objects 
  Reza Ziaei (University of Illinois at Urbana-Chamaign),
  Gul Agha (University of Illinois at Urbana-Chamaign)
   
  We present a compositional meta-level language for coordination of distributed objects. The design of the language is based on the principle of separation of concerns, namely separation of the coordination from computational aspects. The language can be used in combination with any object language capable of expressing sequential behaviors of objects. The language, which is inspired by Petri nets, has a simple syntax and semantics, but is expressive enough to express many of the commonly used coordination patterns. The level of abstraction provided by this language allows tools and techniques developed for Petri nets to be readily applied for analysis and verification of the specified coordination patterns.
  
  
• Partial Evaluation of MATLAB 
  Daniel Elphick (University of Southampton),
  Michael Leuschel (University of Southampton),
  Simon Cox (University of Southampton)
   
  We describe the problems associated with the creation of high performance code for mathematical computations. We discuss the advantages and disadvantages of using a high level language like MATLAB and then propose partial evaluation as a way of lessening the disadvantages at little cost. We then go on to describe the design of a partial evaluator for MATLAB and present results showing what performance increases can be achieved and the circumstances in which partial evaluation can provide these.
  
  

Session 8: Generation and Translation / Closing Discussion

• An Easy-to-Use Toolkit for Efficient Java Bytecode Translators 
  Shigeru Chiba (Tokyo Institute of Technology),
  Muga Nishizawa (Tokyo Institute of Technology) 
  
  This paper presents our toolkit for developing a Java-bytecode translator. We adopted the reflective architecture for our toolkit but the previous implementation technique of this architecture involves serious runtime penalties whereas this arcihtecture makes it easy to develop a translator. To address this problem, our toolkit uses a custom compiler so that the runtime penalties are minimized. Since a previous version of our toolkit called Javassist has been presented in another paper, this paper focuses on this new feature for performance improvement by compiler support. This feature was not included in the previous version.
  
  
• A Case for Test-Code Generation in Model-Driven Systems 
  Matthew Rutherford (University of Colorado),
  Alexander Wolf (University of Colorado) 
  
  A primary goal of generative programming and model-driven development is to raise the level of abstraction at which designers and developers interact with the software systems they are building. During initial development, the benefits of abstraction are clear. However, during testing and maintenance, increased distance from the implementation can be a disadvantage. We view test cases and test harnesses as an essential bridge between the high-level specifications and the implementation. As such, the generation of test cases for fully generated components and test harnesses for partially generated components is of fundamental importance to model-driven systems. In this paper we present our experience with test-case and test-harness generation in a model-driven, component-based distributed system. We describe our development tool, MODEST, and motivate our decision to invest the extra effort needed to generate test code. Additionally, we describe our approach to test-case and test-harness generation and provide a quantification of the relative effort of generating test artifacts versus application artifacts.
  
  
• Closing Discussion