'); document.write('

Tutorial Lecture: Agile and Efficient Domain-Specific Languages using Multi-stage Programming in Java Mint
'); document.write('August 15, 2010 07:29:52 pm
'); document.write('
Agile and Efficient Domain-Specific Languages using Multi-stage Programming in Java Mint (PDF, view embedded)

Mathias Ricken and Edwin Westbrook

A tutorial lecture to be presented at the

Ninth International Conference on Generative Programming and Component Engineering (GPCE’10)

October 10-13, 2010
Eindhoven, The Netherlands

Abstract

Domain-specific languages (DSLs) are a powerful productivity tool because they allow domain experts, who are not necessarily programming experts, to quickly develop programs. DSL implementations have unique constraints for programming languages because they must be efficient, in order to ensure high productivity, but they must also be agile, in order to meet the rapidly changing demands of their domains. In this tutorial we show how multi-stage programming (MSP) can be used to build staged interpreters, which combine the agility of interpreters with the efficiency of compilers. The tutorial is conducted in Java Mint, an multi-stage Java based on recent work incorporating MSP into imperative object-oriented languages. In the first half of the tutorial, we introduce MSP by demonstrating how to write a staged interpreter for a number of basic language constructs, such as recursive functions, conditionals, and let expressions. In the second half, we extend our staged interpreter to take advantage of several well-known compiler optimizations, including type inference, constant folding, and static parallel loop scheduling. We highlight the opportunities afforded by using MSP with object-oriented design to quickly create efficient DSL implementations.

Author Biographies

Mathias Ricken is a doctoral candidate in the Programming Languages Team at Rice University and one of the principal developers of the DrJava integrated development environment. His research interests include concurrent programming, extending the Java language, and computer science education. He is the developer of the Concutest concurrent unit testing framework and has created various experimental extensions of Java to address, for instance, programming with meta-data. Currently, Mathias is contributing to Java Mint, a multi-stage extension of Java that allows safe and expressive statically typed program generation and specialization in an imperative language setting.

Edwin Westbrook is a post-doctoral researcher at Rice University. His primary interests are in developing techniques for implementing and verifying properties of domain-specific languages (DSLs). He has worked on a number of projects in this area, including: Cinic, a type theory for building machine-checked proofs of properties of DSLs using a new approach to higher-order abstract syntax; Java Mint, a multi-stage version of Java used for efficient implementations of DSLs; and Acumen, a DSL for designing cyber-physical systems.
'); document.write('
Presentation: Purdue University Computer Science Colloquia-Mint: A Multi-stage Extension of Java
'); document.write('March 15, 2010 04:40:00 pm
'); document.write('
Purdue University
Computer Science Colloquia
Mint: A Multi-stage Extension of Java
(PowerPoint, PDF, view embedded)
Mr. Mathias Ricken
Rice University
LWSN 3102 A/B
Monday, March 15, 2010
3:30 p.m. – 4:30 p.m.

Complete Description:
Abstract:
Multi-stage programming (MSP) provides a safe way of generating code at run-time. In mostly-functional languages like MetaOCaml, this has been used to reduce the performance penalties of abstractions such as loops, recursion or interpretation. The main advantage of MSP compared to other techniques, such as string or LISP quotations, is that MSP guarantees type safety for the generated code statically, at the time the program is compiled.

Unfortunately, MSP is difficult to combine with imperative features found in most mainstream languages like Java. The central problem is “scope extrusion”, which may accidentally move variables outside the scopes in which they are bound, leading to run-time errors in the generated code. This problem can be prevented if code in escapes (or “anti-quotes”) is “weakly separable”, i.e. the computational effects occurring inside an escape that are visible from the outside do not involve code.

We have formalized a type system, based on Lightweight Java, that uses weak separability to prevent scope extrusion, and we have proved that the type system is sound. We have also developed an implementation called Mint to demonstrate the expressivity of the type system and the performance benefits MSP can provide in an imperative setting. Since our implementation extends the Java language, our work is accessible to mainstream programmers.

This talk is based on work will be presented at the Conference on Programming Language Design and Implementation (PLDI 2010). More information is available at http://mint.concutest.org/

Bio:
Mathias Ricken is a doctoral candidate in the Programming Languages Team at Rice University and one of the principal developers of the DrJava integrated development environment. His research interests include concurrent programming, extending the Java language, and computer science education. He is the developer of the Concutest concurrent unit testing framework and has created various experimental extensions of Java to address, for instance, programming with meta-data. Currently, Mathias is contributing to Mint, a multi-stage extension of Java that allows safe and expressive statically typed program generation and specialization in an imperative language setting.

Faculty and students wishing to speak privately with Mr. Ricken should contact Jan Vitek at jv@cs.purdue.edu.
'); document.write('
Presentation: Test-First Java Concurrency for the Classroom
'); document.write('March 12, 2010 02:12:13 pm
'); document.write('
Test-First Java Concurrency for the Classroom
(PowerPoint, view embedded)

Where: 41st Technical Symposium on Computer Science Education (SIGCSE 2010)
When: March 2, 2010

Concurrent programming is becoming more important due to the growing dominance of multi-core processors and the prevalence of graphical user interfaces (GUIs). To prepare students for the concurrent future, instructors have begun to address concurrency earlier in their curricula. Unfortunately, test-driven development, which enables students and practitioners to quickly develop reliable single-threaded programs, is not as effective in the domain of concurrent programming. This paper describes how ConcJUnit can simplify the task of writing unit tests for multi-threaded programs, and provides examples that can be used to introduce students to concurrent programming.
'); document.write('
Presentation: Testing Concurrent Programs, A 7-Minute Jargon-Free Introduction
'); document.write('February 25, 2010 06:25:57 pm
'); document.write('
Testing Concurrent Programs, A 7-Minute Jargon-Free Introduction
(PowerPoint, view embedded)

Where: Rice University School of Engineering, Thesis Writing Seminar
When: February 25, 2010

A 7-minute jargon-free introduction to the problems of testing concurrent programs, and a proposal for a solution, with non-computer science engineering graduate students as intended audience.
'); document.write('
Presentation: Mint: A Multi-stage Extension of Java
'); document.write('February 08, 2010 02:27:21 pm
'); document.write('
Mint: A Multi-stage Extension of Java
(PowerPoint, PDF, view embedded)
Video recording available on vimeo.

Where: Rice University Computer Science Department, COMP 600 Graduate Seminar
When: February 8, 2010

Multi-stage programming (MSP) provides a safe way of generating code at run-time. In mostly-functional languages like MetaOCaml, this has been used to reduce the performance penalties of abstractions such as loops, recursion or interpretation. The main advantage of MSP compared to other techniques, such as string or LISP quotations, is that MSP guarantees type safety for the generated code statically, at the time the program is compiled.

Unfortunately, MSP is difficult to combine with imperative features found in most mainstream languages like Java. The central problem is “scope extrusion”, which may accidentally move variables outside the scopes in which they are bound, leading to run-time errors in the generated code. This problem can be prevented if code in escapes (or “anti-quotes”) is “weakly separable”, i.e. the computational effects occurring inside an escape that are visible from the outside do not involve code.

We have formalized a type system, based on Lightweight Java, that uses weak separability to prevent scope extrusion, and we have proved that the type system is sound. We have also developed an implementation called Mint to demonstrate the expressivity of the type system and the performance benefits MSP can provide in an imperative setting. Since our implementation extends the Java language, our work is accessible to mainstream programmers.

This talk is based on work done in collaboration with Edwin Westbrook, Jun Inoue, Yilong Yao, Tamer Abdelatif, and Walid Taha. A paper titled “Mint: Java Multi-stage Programming Using Weak Separability” has been accepted for publication in the Proceedings of the 2010 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2010).
'); document.write('
Paper: Mint: Java Multi-stage Programming Using Weak Separability
'); document.write('January 31, 2010 07:21:58 pm
'); document.write('
Mint: Java Multi-stage Programming Using Weak Separability

2010 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2010)

Multi-stage programming (MSP) provides a disciplined approach to run-time code generation. In the purely functional setting, it has been shown how MSP can be used to reduce the overhead of abstractions, allowing clean, maintainable code without paying performance penalties. Unfortunately, MSP is difficult to combine with imperative features, which are prevalent in mainstream languages. The central difficulty is scope extrusion, wherein free variables can inadvertently be moved outside the scopes of their binders. This paper proposes a new approach to combining MSP with imperative features that occupies a ?sweet spot? in the design space in terms of how well useful MSP applications can be expressed and how easy it is for programmers to understand. The key insight is that escapes (or “anti quotes”) must be weakly separable from the rest of the code, i.e. the computational effects occurring inside an escape that are visible outside the escape are guaranteed to not contain code. To demonstrate the feasibility of this approach, we formalize a type system based on Lightweight Java which we prove sound, and we also provide an implementation, called Mint, to validate both the expressivity of the type system and the effect of staging on the performance of Java programs.
'); document.write('
Paper: Test-First Java Concurrency for the Classroom
'); document.write('October 24, 2009 03:47:27 pm
'); document.write('
Test-First Java Concurrency for the Classroom

41st Technical Symposium on Computer Science Education (SIGCSE 2010)

Concurrent programming is becoming more important due to the growing dominance of multi-core processors and the prevalence of graphical user interfaces (GUIs). To prepare students for the concurrent future, instructors have begun to address concurrency earlier in their curricula. Unfortunately, test-driven development, which enables students and practitioners to quickly develop reliable single-threaded programs, is not as effective in the domain of concurrent programming. This paper describes how ConcJUnit can simplify the task of writing unit tests for multi-threaded programs, and provides examples that can be used to introduce students to concurrent programming.
'); document.write('
Presentation: ConcJUnit: Unit Testing for Concurrent Programs
'); document.write('August 29, 2009 01:06:07 am
'); document.write('
ConcJUnit: Unit Testing for Concurrent Programs

Where: The 7th International Conference on the Principles and Practice of Programming in Java (PPPJ 2009)
When: August 28, 2009

In test-driven development, tests are written for each program unit before the code is written, ensuring that the code has a comprehensive unit testing harness. Unfortunately, unit testing is much less effective for concurrent programs than for conventional sequential programs, partly because extant unit testing frameworks provide little help in addressing the challenges of testing concurrent code. In this paper, we present ConcJUnit, an extension of the popular unit testing framework JUnit that simplifies the task of writing tests for concurrent programs by handling uncaught exceptions and failed assertions in all threads, and by detecting child threads that were not forced to terminate before the main thread ends.
'); document.write('
Presentation: ConcJUnit: Unit Testing for Concurrent Programs
'); document.write('August 24, 2009 01:41:38 pm
'); document.write('
ConcJUnit: Unit Testing for Concurrent Programs

Where: Rice University Computer Science Department, COMP 600 Graduate Seminar
When: August 24, 2009

In test-driven development, tests are written for each program unit before the code is written, ensuring that the code has a comprehensive unit testing harness. Unfortunately, unit testing is much less effective for concurrent programs than for conventional sequential programs, partly because extant unit testing frameworks provide little help in addressing the challenges of testing concurrent code. In this paper, we present ConcJUnit, an extension of the popular unit testing framework JUnit that simplifies the task of writing tests for concurrent programs by handling uncaught exceptions and failed assertions in all threads, and by detecting child threads that were not forced to terminate before the main thread ends.
'); document.write('
Tech Report: Multi-stage Programming for Mainstream Languages (TR09-02)
'); document.write('July 14, 2009 03:39:51 pm
'); document.write('
Multi-stage Programming for Mainstream Languages (TR09-02) (local mirror)

Technical Report TR09-02, Department of Computer Science, Rice University

Multi-stage programming (MSP) provides a disciplined approach to run-time code generation. In the purely functional setting, it has been shown how MSP can be used to reduce the overhead of abstractions, allowing clean, maintainable code without paying performance penalties. Unfortunately, MSP is difficult to combine with imperative features, which are prevalent in mainstream languages. The central difficulty is scope extrusion, wherein free variables can inadvertently be moved outside the scopes of their binders. This paper proposes a new approach to combining MSP with imperative features that occupies a ?sweet spot? in the design space in terms of how well useful MSP applications can be expressed and how easy it is for programmers to understand. The key insight is that escapes (or “anti quotes”) must be weakly separable from the rest of the code, i.e. the computational effects occurring inside an escape that are visible outside the escape are guaranteed to not contain code. To demonstrate the feasibility of this approach, we formalize a type system based on Lightweight Java which we prove sound, and we also provide an implementation, called Mint, to validate both the expressivity of the type system and the effect of staging on the performance of Java programs.
'); document.write('
Paper: ConcJUnit: Unit Testing for Concurrent Programs
'); document.write('June 05, 2009 03:33:08 pm
'); document.write('
ConcJUnit: Unit Testing for Concurrent Programs

7th International Conference on the Principles and Practice of Programming in Java (PPPJ 2009)

In test-driven development, tests are written for each program unit before the code is written, ensuring that the code has a comprehensive unit testing harness. Unfortunately, unit testing is much less effective for concurrent programs than for conventional sequential programs, partly because extant unit testing frameworks provide little help in addressing the challenges of testing concurrent code. In this paper, we present ConcJUnit, an extension of the popular unit testing framework JUnit that simplifies the task of writing tests for concurrent programs by handling uncaught exceptions and failed assertions in all threads, and by detecting child threads that were not forced to terminate before the main thread ends.
'); document.write('
Book: A Framework for Concurrent Unit Testing: Concutest
'); document.write('May 24, 2009 05:43:13 pm
'); document.write('
A Framework for Testing Concurrent Programs: Concutest (Paperback)

Republished MS thesis. VDM Verlag

Incremental, test-driven development is sweeping the software industry, elevating testing from an ancillary activity to an integral part of the programming process. Unfortunately, in our recent experience developing production programs in Java, unit testing has only proven effective in assuring the reliability of code with a single thread of control; it is much less effective in concurrent programs. To facilitate the development of concurrent programs, we have developed: 1. An extension of the JUnit framework that actively supports the developer by treating tests that could silently ignore failures in auxiliary threads as test errors; 2. A lightweight Java annotation language that can be used to specify and check the threading invariants of both existing and new code; 3. A testing framework that can record and analyze the schedules of unit tests, detect deadlocks, and run the tests using modified schedules, increasing the likelihood that concurrency problems are discovered.
'); document.write('
Presentation: Java Annotations for Types and Expressions
'); document.write('October 24, 2008 11:00:54 am
'); document.write('
Java Annotations for Types and Expressions

Where: Rice University Computer Science Department, RAP Seminar
When: October 24, 2008

As defined in Java 1.5, Java annotations can only be attached to very few targets: Classes, methods, method parameters, fields, and other annotations. The Java community intends to extend the list of targets and has issued Java Specification Request (JSR) 308, “Annotations on Types”. The current proposal for JSR 308 is considering allowing annotations on statements, but not on expressions.

In this talk, I discuss how the changes proposed by JSR 308 and its Checker Framework allow programmers to enhance Java’s type system and provide additional static guarantees. Additionally, I demonstrate that the same mechanism proposed for annotations on statements can be used to describe multi-stage programs in Java.
'); document.write('
Poster: Invariant Specification and Multi-Staging using Java Annotations
'); document.write('October 16, 2008 01:00:20 pm
'); document.write('
Invariant Specification and Multi-Staging using Java Annotations

Where: Rice University Computer Science Department, Corporate Affiliates Meeting 2008
When: October 16, 2008

Java annotations allow programmers to attach metadata to programs. During normal execution, the annotations are ignored, but in contrast to comments in the source code, annotations can be manipulated programmatically at compile- or run-time. We propose two extensions — subtyping and expression annotations — for consideration in the Java specification request for annotations, and show how annotations can be used to express program invariants and multi-stage programs.
'); document.write('
Presentation: Java Annotations for Invariant Specification
'); document.write('September 22, 2008 11:00:13 am
'); document.write('
Java Annotations for Invariant Specification

Where: Rice University Computer Science Department, RAP Seminar
When: September 22, 2008

Java annotations allow programmers to attach metadata to programs. During normal execution, the annotations are ignored, but in contrast to comments in the source code, annotations can be manipulated programmatically at compile- or run-time.

In this talk, I provide a brief introduction to Java annotations and show how limited their use currently is. I then describe a framework for specifying program invariants using Java annotations, and how extending Java to support subtyping for annotations allows programmers to write the invariants in a succinct manner.
'); document.write('
Thesis: A Framework for Testing Concurrent Programs
'); document.write('October 30, 2007 01:00:04 pm
'); document.write('
A Framework for Testing Concurrent Programs

Rice University

A Framework for Testing Concurrent Programs
by
Mathias Guenter Ricken

A thesis submitted
in partial fulfillment of the
requirements for the degree

Master of Science

Incremental, test-driven development is sweeping the software industry, elevating testing from an ancillary activity to an integral part of the programming process. Unfortunately, in our recent experience developing production programs in Java, unit testing has only proven effective in assuring the reliability of code with a single thread of control; it is much less effective in concurrent programs.

To facilitate the development of concurrent programs, we are developing:
1. An extension of the JUnit framework that actively supports the developer by treating tests that could silently ignore failures in auxiliary threads as test errors;
2. A lightweight Java annotation language that can be used to specify and check the threading invariants of both existing and new code;
3. A testing framework that can record and analyze the schedules of unit tests, detect deadlocks, and run the tests using modified schedules, increasing the likelihood that concurrency problems are discovered.
'); document.write('
Presentation: Testing Concurrent Programs
'); document.write('October 04, 2007 12:00:00 pm
'); document.write('
Testing Concurrent Programs

Where: Rice University Computer Science Department, Rice Computer Science Club
When: October 4, 2007

A talk directed mostly at undergraduate students.

Programming examples from the presentation.
'); document.write('
Presentation: A Framework for Testing Concurrent Programs
'); document.write('August 27, 2007 12:00:53 pm
'); document.write('
A Framework for Testing Concurrent Programs

Where: Rice University Computer Science Department, PhD Student Lunch Seminar
When: August 27, 2007

Incremental, test-driven development is sweeping the software industry, elevating testing from an ancillary activity to an integral part of the programming process. Unfortunately, in our recent experience developing production programs in Java, unit testing has only proven effective in assuring the reliability of code with a single thread of control; it is much less effective in concurrent programs. To facilitate the development of concurrent programs, we are developing:
1. An extension of the JUnit framework that actively supports the developer by treating tests that could silently ignore failures in auxiliary threads as test errors;
2. A lightweight Java annotation language that can be used to specify and check the threading invariants of both existing and new code;
3. A testing framework that can record and analyze the schedules of unit tests, detect deadlocks, and run the tests using modified schedules, increasing the likelihood that concurrency problems are discovered.
'); document.write('
Defense: A Framework for Testing Concurrent Programs
'); document.write('June 14, 2007 01:00:05 pm
'); document.write('
A Framework for Testing Concurrent Programs

Rice University
The Department of Computer Sciece

presents

Mathias Guenter Ricken
Master of Science Thesis Defense

A Framework for Testing Concurrent Programs

When: July 14, 2007

ABSTRACT

Incremental, test-driven development is sweeping the software industry, elevating testing from an ancillary activity to an integral part of the programming process. Unfortunately, in our recent experience developing production programs in Java, unit testing has only proven effective in assuring the reliability of code with a single thread of control; it is much less effective in concurrent programs.

To facilitate the development of concurrent programs, we are developing:
1. An extension of the JUnit framework that actively supports the developer by treating tests that could silently ignore failures in auxiliary threads as test errors.
2. A lightweight Java annotation language that can be used to specify and check the threading invariants of both existing and new code.
3. A testing framework that can record and analyze the schedules of unit tests, detect deadlocks, and run the tests using modified schedules, increasing the likelihood that concurrency problems are discovered.
'); document.write('
Poster: Practical Tools for Testing Concurrent Programs
'); document.write('October 06, 2006 02:30:52 pm
'); document.write('
Practical Tools for Testing Concurrent Programs

Where: Rice University Computer Science Department, Corporate Affiliates Meeting 2006
When: October 5, 2006

In our experience with developing production programs in Java, unit testing has proven effective in assuring the reliability of code with a single thread of control. Unfortunately, unit testing has proved much less effective in assuring the reliability of code with multiple threads of control, often simply because the JUnit testing framework silently ignores failures in auxiliary threads. Java libraries and user programs frequently make assumptions about the threading context in which they execute, but these assumptions are rarely enforced by the actual code and typically only appear in program documentation. Since thread scheduling is non-deterministic, a unit test can succeed on one run and fail on the next, or repeatedly succeed on one platform and occasionally fail on another.

To improve test-driven development for concurrent programs, we are developing
1. an extension of the JUnit framework, actively supporting the developer by treating tests that could silently ignore failures in auxiliary threads as test errors;
2. a lightweight annotation language, which can be used to specify and check the threading properties of both existing and new code; and
3. a testing framework that can execute unit tests according to a specified set of recorded or generated schedules, elevating the unit testing of concurrent programs to a rigorous, deterministic process.
'); document.write('