Robert R. Kessler

Experiments with Industry's ''Pair-Programming'' Model in the Computer Science Classroom

Anecdotal evidence from several sources, primarily in industry, indicates that two programmers working collaboratively on the same design, algorithm, code, or test perform substantially better than the two working alone. Two courses taught at the University of Utah studied the use of this technique, often called pair-programming or collaborative programming, in the undergraduate computer science classroom. The students applied a positive form of “pair-pressure” on each other, which proved beneficial to the quality of their work products. The students also benefit from “pair-learning,” which allowed them to learn new languages faster and better than with solitary learning. The workload of the teaching staff is reduced because the students more often look to each other for technical support and advice.

Peep: an architectural description driven peephole optimizer

Peep is an architectural description driven peephole optimizer, that is being adapted for use in the Portable Standard Lisp compiler. Tables of optimizable instructions are generated prior to the creation of the compiler from the architectural description of the target machine. Peep then performs global flow analysis on the target machine code and optimizes instructions as defined in the table. This global flow analysis allows optimization across basic blocks of instructions, and the use of tables created at compiler-generation time minimizes the overhead of discovering optimizable instructions.

Entertainment arts and engineering(or how to fast track a new interdisciplinary program)

The Entertainment Arts and Engineering (EAE) program is a unique, new undergraduate interdisciplinary program at the University of Utah bringing together the School of Computing and the Division of Film Studies in an effort to teach both video game development and computer animation. Students pursuing a film or computer science degree may enroll in the program as a means of focusing their education on digital arts and entertainment. The key characteristic of the program is the shared classes where students from both Computer Science and Fine Arts study together and cooperate on game and animation projects. The program is highlighted by a yearlong capstone course in which the students work together to make a video game or animated short from scratch. This paper chronicles our efforts starting the EAE program and demonstrates how to create an interdisciplinary program that not only attracts students to CS, but also equips them for careers or research in video games and animation.

Using UML state machine models for more precise and flexible JADE agent behaviors

In order to effectively develop multi-agent systems (MAS) software, a set of models, technologies and tools are needed to support flexible and precise specification and implementation of agent-to-agent conversations, standardized conversation protocols, and corresponding agent behaviors. Experience trying to build complex protocols with the ZEUS and JADE agent toolkits motivated a substantial extension to the JADE agent behavior model. This extension (called SmartAgent) enables more flexible, reusable and precise modeling and implementation of agent behavior. We augment JADE behaviors with uniform message, timing and system events, a multi-level tree of dispatchers that match and route events, and a hierarchical state machine (HSM.) HSM is represented using UML statechart diagrams, and implements a significant subset of UML state machine semantics. Adherence to the UML standard helps bridge object-oriented to agent-oriented programming, and allows us to use industry familiar modeling language and tools such as Rose or Visio. These extensions were tested in a meeting scheduler prototype.

An implementation of portable standard LISP on the BBN butterfly

An implementation of the Portable Standard Lisp (PSL) on the BBN Butterfly is described. Butterfly PSL is identical, syntactically and semantically, to implementations of PSL currently available on the VAX, Gould, and many 68000-based machines, except for the differences discussed in this paper. The differences include the addition of the future and touch constructs for explicit parallelism and an extension of the fluid binding mechanism to support the multiple environments required by concurrent tasks. As with all other PSL implementations, full compilation to machine code of the basic system and application source code is the normal mode, in contrast to the previous byte-code interpreter efforts. Also discussed are other required changes to the PSL system not visible in the syntax or semantics, e.g., compiler support for the future construct. Finally, the underlying hardware is described, and timings for basic operations and speedup results for two examples are given.

EPIC - a retargetable, highly optimizing Lisp compiler

The Experimental Portable Standard Lisp Compiler (EPIC) is a compiler testbed for experimentation with, and development of, Lisp compilation strategies. EPIC uses an architectural description of the target machine to increase portability, and performs extensive optimizations in the form of source-to-source transformations, register allocation, and peephole optimization. It introduces machine-specific instructions early to enable machine-specific optimizations in the initial passes. EPIC produces better code than the original Portable Standard Lisp compiler, has an improved portability model, and is easier to maintain.

Integrating traditional and agile processes in the classroom

Teaching software engineering is difficult because the true benefits of a disciplined software process and the production of significant artifacts are most meaningful when programming-in-the-large, with varying levels of team experience in the context of a professional organization. Using the same techniques when programming-in-the-small can often lead to the students feeling that it is better to not use any process because the effort and tedium of producing artifacts is so great compared with the relatively simple task of writing the code for the target solution. This paper describes our solution, a curriculum that exposes the students to both lightweight traditional and lightweight agile processes. We describe two offerings of the class and conclude from the positive student feedback that we have found the correct balance.

TICL—a type inference system for common Lisp

Most current Common Lisp compilers generate more efficient code when supplied with data type information. However, in keeping with standard Lisp programming style, most programmers are reluctant to provide type information; they simply allow the run‐time type system to manage the data types accordingly. To fill this gap, we have designed and implemented a type inference system for Common Lisp (TICL). TICL takes a Lisp program that has been annotated with a few type declarations, adds as many declarations as possible, and produces a type declared program. The compiler can then use this information to generate more efficient code. Measurements indicate that a 20 per cent speed improvement can generally be achieved.

Achieving the promise of reuse with agent components

Using software agents as next generation flexible components and applying reuse technologies to rapidly construct agents and agent systems have great promise to improve application and system construction. Whether built on conventional distributed computing and application management platforms, on a specialized agent platform, on web service technology or within a P2P infrastructure, agents are a good match for independent development, for scalable and robust systems and dynamic evolution of features, and for autonomic self-managing systems. In this paper we describe the vision and progress we have made towards developing a robust infrastructure, methods, and tools for this goal.

Nine suggestions for improving UML extensibility

In this paper we suggest nine improvements that address issues in UML extensibility and UML based tools. These improvements were suggested by work on SAGE, an extension to Rational Rose that automates the component generation process in a large scale CORBA financial enterprise framework called Sea-Bank. SAGE makes extensive use of UML extensibility features and it was noted that these features were underspecified in the UML standard and undersupported in current CASE tools. This paper proposes some ideas that would greatly improve UML extensibility, which we believe is critical for wider adoption of UML and for next generation domain-specific and UML-based component development and tools