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.

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.

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.

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.

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.

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.

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.

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.

OOPSLA 2006 Educators Symposium

The development of any piece of software begins with a set of specifications describing in some detail the problems to be solved. Almost invariably, the specifications change during the development of the software. Trying to anticipate all possible changes and write a program that does everything is a futile undertaking. However, it is not unreasonable to expect that programs be written in such a way that an “epsilon” (read “small”) change in the specifications will only necessitate a “delta” (read “manageable”) change in code.

Programming for change is a continual process in which software is designed over many iterations to capture the problem’s essence and express. At the heart of this process is the effort to identify those elements that can vary (variants) and delineate them from those that do not — the invariants. A properly designed software system should strive to decouple the variants from the invariants in order to facilitate the re-use of the invariants and allow modifications to the variants with minimal perturbation to the existing code.

To illustrate the importance of programming for change to students, we guide them through the development of a program that converts temperature measurements. The assignment consists of a series of small exercises, each of which imposes a small change in the requirements and forces appropriate modifications of the code. To promote code re-use, we apply the Janus Principle and require that the programs must be written in a way that supports multiple distinct user interfaces. For certain specification changes, we ask students to identify the variants and the invariants and make appropriate modifications to the code. In several situations, we require the students to modify their code in more than one way and discuss the pros and cons.

SIGCSE 2006

Object-oriented (OO) programming begins with analysis and design that produce a model describing the objects in the problem domain, their relationships, creation and interactions. The workshop covers fundamentals of OO analysis and design such as abstraction, separation of variants from invariabb nts and decoupling of system components, via appropriate applications of composition, inheritance, polymorphism, and design patterns. The workshop will progress from a small design example illustrating the principles to a larger design problem to be solved by small teams of participants. Their solutions will be discussed in terms of design goals and compared against a solution provided by the presenters.

Where: Rice University Computer Science Department, Corporate Affiliates Meeting 2005
When: September 20, 2005 and December 5, 2005

Where: SIGCSE 2005
When: February 27, 2005

We provide a systematic transformation of an LL(1) grammar to an object model that consists of

• an object structure representing the non-terminal symbols and their corresponding grammar production rules,
• a union of classes representing the terminal symbols (tokens).

We present a variant form of the visitor pattern and apply it to the above union of token classes to model a predictive recursive descent parser on the given grammar. Parsing a non-terminal is represented by a visitor to the tokens. For non-terminals that have more than one production rule, the corresponding visitors are chained together according to the chain of responsibility pattern in order to be processed correctly by a valid token. The abstract factory pattern, where each concrete factory corresponds to a non-terminal symbol, is used to manufacture appropriate parsing visitors.

Our object-oriented formulation for predictive recursive descent parsing eliminates the traditional construction of the predictive parsing table and yields a parser that is declarative and has minimal conditionals. It not only serves to teach standard techniques in parsing but also as a non-trivial exercise of object modeling for objects-first introductory courses.

With: Justin Crites
Where: Rice University, COMP 527 Computer Systems Security
When: December 7, 2004

Advertising on the world wide web is increasingly becoming problematic. In addition to merely being a nuisance, advertisements may also pose a threat to user security. Blocking web advertisements can thus substantially improve the user’s browsing experience.

AdBlock is an open-source plugin for Mozilla browsers that uses regular expressions, an advanced concept unfamiliar to novice users, to block a limited number of HTML elements. This paper describes some of AdBlock’s shortcomings and the remedies we implemented: automatically generating regular expressions, allowing for web updates, and vastly extending the set of blockable elements.

SIGCSE 2005

We provide a systematic transformation of an LL(1) grammar to an object model that consists of

• an object structure representing the non-terminal symbols and their corresponding grammar production rules,
• a union of classes representing the terminal symbols (tokens).

We present a variant form of the visitor pattern and apply it to the above union of token classes to model a predictive recursive descent parser on the given grammar. Parsing a non-terminal is represented by a visitor to the tokens. For non-terminals that have more than one production rule, the corresponding visitors are chained together according to the chain of responsibility pattern in order to be processed correctly by a valid token. The abstract factory pattern, where each concrete factory corresponds to a non-terminal symbol, is used to manufacture appropriate parsing visitors.

Our object-oriented formulation for predictive recursive descent parsing eliminates the traditional construction of the predictive parsing table and yields a parser that is declarative and has minimal conditionals. It not only serves to teach standard techniques in parsing but also as a non-trivial exercise of object modeling for objects-first introductory courses.

Where: OOPSLA 2004 Educators Symposium
When: October 25, 2004

The Marine Biology Simulation is designed as a final project in an objects-first CS2 course. It provides an entertaining setting that serves as compelling example of the powers of object-oriented design and programming.

Where: Rice University Computer Science Department, Corporate Affiliates Meeting 2004
When: October 18, 2004

Designing an effective curriculum to teach programming and software engineering to beginning students is challenging. An objects-first course prepares students in an excellent way for the requirements in industry and academia by focusing on program design, thereby enabling students to write correct, robust, flexible, and extensible software. This paper outlines the effects of an object-oriented approach on software quality and describes five assignments that can be used as teaching tools in an objects-first course to evaluate and reinforce the students’ understanding.

OOPSLA 2004 Educators Symposium

The Shape Calculator is an assignment targeted at CS1 students in an objects-first curriculum. It can serve as a powerful yet entertaining example of the advantages of object-orientation.

OOPSLA 2004 Educators Symposium

The Marine Biology Simulation is designed as a final project in an objects-first CS2 course. It provides an entertaining setting that serves as compelling example of the powers of object-oriented design and programming.

Where: Rice University Computer Science Department, TeachJava
When: June 25, 2004 and July 1, 2005