Joseph L. Zachary

NaturalJava: a natural language interface for programming in Java

NaturalJava is a prototype for an intelligent natural-language-based user interface for creating, modifying, and examining Java programs. The interface exploits three subsystems. The Sundance natural language processing system accepts English sentences as input and uses information extraction techniques to generate case frames representing program construction and editing directives. A knowledge-based case frame interpreter, PRISM, uses a decision tree to infer program modification operations from the case frames. A Java abstract syntax tree manager, TreeFace, provides the interface that PRISM uses to build and navigate the tree representation of an evolving Java program. In this paper, we describe the technical details of each component, explain the capabilities of the user interface, and present examples of NaturalJava in use.

Automated feedback on programs means students need less help from teachers

Many educators believe that the most effective means of teaching is through one-on-one interactions with students. It is not surprising, then, that an effective way to teach programming is to give students immediate feedback on programs that they have just written. Unfortunately, such one-on-one teaching scenarios are becoming increasingly difficult to arrange. We built InSTEP, an online tutoring system for beginning C programmers, to see whether an automated system could provide effective immediate feedback to beginning programming students. In an introductory programming course, we compared two groups of students. One group solved six programming problems with feedback from InSTEP; the second group solved the same six problems without feedback from InSTEP; both groups had access to feedback from teaching assistants. While both groups of students took about the same amount of time to complete the problems and performed about the same on a subsequent test, the students who received feedback from InSTEP spent less than a third of the time asking the teaching assistants questions than did the others.

Using course-long programming projects in CS2

A typical CS2 course has two goals that often work at cross-purposes. One goal is to teach students how to apply a variety of software engineering skills to create solutions to real-world problems. A second goal is to teach students the theory and practice behind classical algorithms and data structures. The use of small, short-term programming assignments, however, tends to sacrifice the first goal in favor of the second. We successfully experimented with solving this problem by organizing a CS2 course around a programming project that spanned an entire term. This paper describes the project, our experiences in using it, and the reactions of the students.

Exploiting value-added content in an online course: introducing programming concepts via HTML and JavaScript

Online courses have proliferated across all disciplines in recent years. One commonly-used approach for creating an online course is to build a web site containing as much course information---assignments, solutions, lecture notes, streaming videos, and the like---as possible. The goal of this type of course is to replicate online, to the maximum extent possible, the classroom experience. Online courses built this way exploit the communications capabilities of networked computers. We believe, however, that online courses should also strive to exploit the computational capabilities of computers. That is, online courses should provide value-added components that make possible learning experiences beyond what is feasible in the traditional classroom. We describe such an online course, called Creating Interactive Web Content, that we created and have taught successfully for the last three years. It is a general enrollment course that uses HTML and JavaScript as a vehicle for teaching elementary programming concepts.

Reflections on metaprogramming

By encapsulating aspects of language semantics within a set of default classes and allowing the programmer to derive new versions, object-oriented languages whose semantics can be tailored to the needs of individual programmers have been provided. The degree to which such languages are simultaneously flexible and efficient is an open question. We describe our experience with using this technique to incorporate transparent support for persistence into the Common Lisp Object System via its metaobject protocol, an open implementation based on reflection. For many aspects of our implementation the metaobject protocol was perfectly suitable. In other cases we had to choose between extending the protocol, requiring the application programmer to employ special idioms, and tolerating a large performance penalty. Based on our experience we evaluate the metaobject protocol, propose some improvements and extensions, and present performance measurements that reveal the need for improved language implementation techniques. >

Reactive behavior design tools

The reactive behavior of an autonomous agent can be described as collections of logical behaviors, each member of the collection controlling some aspect of the agent and working in conjunction with all the other behaviors. Such collections of reactive behaviors can be defined as combined, synchronous finite-state automata, using real-time programming languages which have strong formal components. These language tools, such as COSPAN and ESTEREL, require sophisticated users who have deep knowledge of both the syntax and semantics of the language. The authors use the simplicity of graphical finite-state automata editing to specify concurrent synchronous finite-state automata, and from those they produce COSPAN descriptions of these behaviors for analysis, and C language programs to implement the designed behaviors. The usefulness and validity of this approach was confirmed by the design, verification and implementation of several examples, including a controller demon for a robot arm.<<ETX>>

Parallel path consistency

Filtering algorithms are well accepted as a means of speeding up the solution of the consistent labeling problem (CLP). Despite the fact that path consistency does a better job of filtering than arc consistency, AC is still the preferred technique because it has a much lower time complexity. We are implementing parallel path consistency algorithms on multiprocessors and comparing their performance to the best sequential and parallel arc consistency algorithms.(1,2) (See also work by Kerethoet al.(3) and Kasif(4)) Preliminary work has shown linear performance increases for parallelized path consistency and also shown that in many cases performance is significantly better than the theoretical worst case. These two results lead us to believe that parallel path consistency may be a superior filtering technique. Finally, we have implemented path consistency as an outer product computation and have obtained good results (e.g., linear speedup on a 64K-node Connection Machine 2).

Moded type systems for logic programming

Most of the theoretical work on the semantics of logic programs assumes an interpreter that provides a complete resolution procedure. In contrast, for reasons of efficiency, most logic programming languages are built around incomplete procedures. This difference is rooted in Prolog, which evaluates resolvent trees in a depth-first rather than a breadth-first order. The gap is widened by some equational logic languages, which combine the incompleteness of depth-first evaluation with incomplete approximations to equational unification. Because of this gap, it is unsound to reason about logic programs using their declarative semantics. This in turn makes it difficult to develop abstraction mechanisms that can be used to partition a logic program into independently specifiable modules. In this paper we consider the role type systems can play in closing the gap between the operational and declarative semantics of logic programs. We develop the notion of an equational mode system for use in constraining the domains of both predicates and unification procedures. The mode system is used to guide the resolution-based interpreter, and as a result, we can show that two predicate implementations with the same declarative meaning will be operationally equivalent.

An entry-level course in computational engineering and science

In conventional science and engineering degree programs, computation is commonly treated-as a narrow technical tool to be studied and applied in isolation from the traditional topics of the discipline. Students are typically required to take a programming course (usually in Fortran, C, or Pascal) to learn how to program, and perhaps a numerical analysis course (covering numerical integration, root finding, and the like) to learn ways to apply their programming skills. However, many students then go through the rest of their degree programs without ever using computation in any significant way. This approach ignores the fact that computation has evolved into an essential way of illuminating scientific and engineering principles. Researchers now choose among the theoretical, experimental, and computational approaches to studying scientific phenomena, It is becoming increasingly clear that computation should be exploited in science and engineering education for its descriptive and analytical powers [1–3]. We believe that it is as unreasonable to teach science and engineering without computing as it would be to do so without calculus and differential equations. To encourage the integration of computation into the science and engineering curricula, we have designed and taught an introductory course in computing expressly for science and engineering students. Our goal wss to create a course to satisfy the standard programming requirement while preparing students to immediately exploit the broad power of modern computing in their science and engineering courses. Our course has at least four distinguishing features:

Off to see the Wizard: using a "Wizard of Oz" study to learn how to design a spoken language interface for programming

We are in the early stages of developing a spoken language interface that will help beginners write programs. Our goal is a system in which a student will talk to a computer using English sentences, in response to which the computer will generate syntactically correct Java source code. We believe that such a system would help beginning students by allowing them to focus on concepts instead of syntactic details, and that it would also be a boon to students with visual or mobility impairments. As a prelude to designing and implementing such a system, we evaluated the concept via a Wizard of Oz study. Volunteer subjects were told that they were helping us evaluate a working system. In reality, an accomplished programmer was playing the role of the purported system, and we were studying how the subjects interacted with it. We describe the system that we envision, discuss the process of running a Wizard of Oz study in the context of our own recently completed study, and summarize our preliminary results.