Steven P. Reiss Department of Computer Science, Box 1910 Brown University, Providence, RI 02912-1910 Tel: 401-863-7641, Fax: 401-863-7657 Email: spr@cs.brown.edu Office: CIT 403

What's the Latest

• The NewsView tool developed for TAIGA is now available as an Applet or a Apple Dashboard Widget. (Look here for all options.)

• Take part in a research project involving visualizing what people are browsing on the web. See WEBVIEW.

Research Projects

The overall theme of our research is making programming easier. We are undertaking a number of projects directed at this goal. These include:

• Software Visualization (VALLEY,CACTI,BLOOM,JIVE,JOVE,VELD). We have been doing software visualization for nearly 25 years at this point. We started with attempting to incorporate visualization into a programming environment, first in PECAN, then in GARDEN (with visual programming), and finally in FIELD. After this we started to develop independent visualization systems. The first, CACTI, provided 3D visualizations in various formats of information about a software system, mostly structural data, but including some performance and trace data. The followon system, BLOOM, concentrated on attempting to make it easier for programmers to specify what they wanted to visualize and then providing a variety of appropriate visualizations. More recently we have been looking into visualizing the dynamics of a large software system as it executes with minimal perturbation and maximal information. JIVE shows basic execution and thread information. JOVE shows basic block counts broken down by thread. VELD is again an attempt to let the programmer define application-specific visualizations, this time of the dynamics of their system.
• Programming Environments (PECAN,GARDEN,FIELD,DESERT,CLIME,WADI)We have a long history of developing programming environments and the accompanying tools and techniques. Our recent efforts, CLIME, concentrate on techniques to allow the design, code and other software artifacts (test cases, documentation, history, ...) to evolve in a consistent manner. The latter involves viewing each software artifact as a set of constraints on other software artifacts, checking that all the constraints are met, and reporting violations to the programmer. The tool gathers information about the various artifacts using a variety of techniques, stores this information in a relational database, and then checks relationships between the artifacts by doing queries on that database. Any inconsistencies are displayed through the user interface. The system is designed to be incremental so that it can be used continually throughout the development process. Our newest work, WADI, is a suite of programming tools that attempt to provide automated and intelligent feedback to the programmer as they code.
• Checking Dynamic Specifications (CHET). We have developed a system that takes a set of behavioral specifications related to the use of software components such as classes or libraries, finds all instances of each such specification in a software system through a complete interprocedural flow analysis, and then checks each such instance using model-checking techniques. The system is able to handle a wide range of specifications and check them against moderate to large systems in a reasonable amount of time. It checks about 600 instances of specifications in over 60,000 lines of java source (not including libraries) in under 10 minutes. The result is displayed using a graphical user interface that lets the programmer see what specifications passed and which failed and, for each case, how the specification maps to the the original code.
• Internet-Scale Programming (TAIGA). Our research here addresses the logical confluence of web services, peer-to-peer computing, grid computing, open source, autonomic computing, and software components. When all of these take off together, all programs share data, computation, and code, and one is left with a world where there is effectively only one program and it is running everywhere and all the time. Our research here is focused on the many issues that will arise as we move to such a world: how to define components, how to integrate privacy and security, dealing with failure as an integral part of all programs, economic and social issues, and frameworks for programming at the appropriate scale and level. As a demonstration program here, we have implemented a suite of tools that provide visualization of what is currently being viewed on the web by category.

Previous projects (in various states of usability):

• PECAN: A programming environment generator for workstations. This was one of the earliest multiple-view programming environments, running on Apollo and Sun workstations in the early 80's. It featured textual and graphical editors, automatically generated semantic views, dynamic views of the stack, and forward and reverse execution.
• GARDEN: An environment for combining multiple visual languages in order to do what we called conceptual programming. The idea was to let the programmer develop a system using the most appropriate combination of languages. The system allowed the easy definition of new visual (and textual) languages that could be easily combined and integrated with each other. GARDEN was built on top of a distributed object store, featured multiple threads of control, a complete object programming system where objects were directly executable, facilities for defining the visual syntax and semantics of new languages, visual editors for these languages, browsers, dynamic feedback of programs as they execute, and the start of a compiler to make the whole thing efficient. While the code still compiles, we need to port a few libraries before it can be run again.
• FIELD: A comprehensive UNIX programming environment. This was the environment that pioneered what was later to be called control integration, the use of interprocedural messages (and a central message server) as a means of integrating the various tools in a programming environment. Copied by several companies, the code was widely used and served as an educational programming environment here at Brown for several years as well as a development environment for C and early versions of C++. The environment integrated most UNIX programming tools (editors, debuggers, rcs/sccs, make, prof/gprof), provide graphical interfaces to each of these tools, and offered a variety of static program visualizers (call graph, file structure, class hierarchy) and dynamic visualizations (data structure displays, a view of the heap in action, a view of file I/O, performance visualizations). Many portions of the environment still run on Solaris and Linux -- at least enough to demonstrate its capabilities.
• DESERT: Desert was an attempt to go a step beyond FIELD in terms of integration. It initiated the concept of "fragment integration", i.e. breaking a program up into logical units or fragments (methods, classes, declarations, etc.) that are tracked separately and can be dynamically combined to show the programmer a view that is relevant to a particular aspect or feature of the system. Desert provided high-quality source views based on the studies of Baecker-Marcus, utilizing FrameMaker as the program editor and dynamically reformatting as the user typed. It featured syntax and semantic-based coloring (i.e. did variable lookup over the whole system on a keystroke basis, coloring types differently from variables from methods from undefined symbols). It also served as the basis for our first attempts at high-quality and high-density software visualizations using 3D techniques (CACTI and VALLEY). Much of this code still runs, at least here at Brown, although it requires Solaris because of the FrameMaker integration.

Research Laboratories

We are responsible for the Brown University Internet Laboratory. This facility is designed to let students and researchers experiment with large-scale Internet applications. It provides the hardware and software for running and testing web applications that can handle thousands of users. The laboratory features a 20-seat classroom/lab with a variety of front-end machines, and a backroom with both SMP machines and clusters of various types.

Software Systems

Systems currently under development. For recent status and the latest versions of these systems please send email to spr@cs.brown.edu.

• Bloom. This is our software visualization system. It consists of a program instrumentation package for C/C++, a JVMPI package for Java, various analysis frameworks for dynamic program data, a visual query interface, a visualization framework, several visualization methods, and a number of related items.
• Jive and Jove. These are our dynamic Java visualization tools. It is available separately in binary form or in source form as part of Bloom.
• Clime. This package represents our constraint-based programming environment. It includes a user interface that shows the programmer current inconsistencies between software artifacts and current style/language problems with the source both textually and graphically. It also includes a variety of tools for analyzing and storing information about different software artifacts including Java source, UML class and interaction diagrams (ROSE and ArgoUml), CVS histories, javadoc documentation, and Junit-based test cases.
• Chet. This is our tool for checking dynamic specifications in software systems. It is able to handle large numbers of specifications in relatively large and realistic Java systems in a practical way. Currently it is only availabe as part of the Clime environment.
• Taiga. This is our experimental framework for Internet-scale computing. It is built on top of a peer-to-peer backbone (based on JXTA) and includes facilities for defining the syntax and semantics of components and for defining web services, libraries, and other servers as implementations of these components. In includes facilities for sharing files and data across the Internet.
• Veld. This is another visualization framework. It is aimed at dynamic visualization of Java programs where the programmer can quickly define what should be visualized and the system automatically does the instrumentation and runs the program with an appropriate visualization.

Previous systems. These system are not under active development. Some, such as FIELD and Desert work either in full or in part.

• bb. This is the text editor that was first implemented circa 1980 and has been maintained and updated since. A cheap and viable alternative to vi or emacs.
• BWE. This is our old userinterface toolkit. It predates Motif, but works nicely (and quicly) with X11. Although not widget-based, it is quite flexible and simple from a programmer's perspective. It is required for FIELD.
• CCEL. This ia an old C++ lint-like constraint checker with user-definable rules. I doubt if it still runs, but who knows.
• CPPP. A C++ front end for the language in 1986 with only partial support for templates.
• Desert. This is a C++/C programming environment (with some support for Java) that uses FrameMaker for program editing. It requires FOREST.
• dl. This is a very old incremental loader for COFF format files. Probably not very usable any more.
• FIELD. The Friendly Integerated Environment for Learning and Development, FIELD is an integration of various UNIX tools combined with a number of our own tools for software visualization. It is probably no longer fully functional, but parts of it do run and could be interesting. It served as the basis for DEC Fuse way back when.
• Forest. A package of C++ utilities including a nice object-oriented interface to Motif, a database query engine, and a Java parser. Required for Desert.
• Garden. Our circa 1985 visual programming environment, Garden provided support for user-defined visual languages and the ability to combine them in arbitrary ways in a single system. The package no longer will compile/run (the threads library used by Garden is long out of date).
• Idyl. This is an old incremental loader for COFF format files. It is a cleaned-up and much better implementation of dl. However, it was never ported to ELF and is no longer used. However, it was much more efficient than later incremental loaders such as Sun's ild.
• OOPas. An object Pascal preprocessor that accepts most Turbo Pascal extensions and produces Sun Pascal.

Teaching

Courses (2007-2008):

• CSCI0190 (CS019): Accelerated introduction to programming and data structures. This is a new course that combines the first two traditional courses (csci0150 and csci0160, object-oriented programming and algorithms and data structures respectively) into a single course for students with a prior programming background.
• CSCI0320 (CS032): Introduction to Software Engineering. This is a sophomore level software engineering course covering both advanced programming topics such as threads, user interfaces, web applications and software architecture, as well as project engineering and agile programming. Students design and write a team project. Homework assignments other than the project have been chosen to demonstrate different applications including computational biology, physics and natural language processing.
• CSCI2310 (CS231): User Interface Design. This is a graduate seminar on user interface and human factors. The topics studied vary from year to year depending on the interests of the students.

Courses (2006-2007):

• CS233: Programming Environments. This is a seminar course on topics related to programming environments. This year we studied a collection of 30 papers relating to future directions for programming environments and concentrating on program analysis and verification.
• CS160: Embedded and Real-Time Programming. Otherwise known as the pinball course. This is a hands-on course in real time and embedded computing. For the project this year we took a 1979 Pinball machine (LaserBall) and replaced its CPU board with a connection to a linux box using a NI DIO card. The students had to write all the real time software to control the lights, switches, solenoids, and displays as well as provide a fun and workable pinball game. Lectures covered the underlying theory and practice of real time and embedded programming.
• CS032: Introduction to Software Engineering. This is a sophomore level software engineering course covering both advanced programming topics such as threads, user interfaces, web applications, and software architecture, as well as project engineering and agile programming. Students design and write a team project.

Courses (2005-2006):

• CS126: Introductory Compiler Construction. This is a traditional compiler course updated to emphasize modern compiler techniques. While lexical analysis, parsing, semantic analysis and code generation are all covered, we also spend 1/4 of the course covering compiler optimization theory and techniques. Students write a compiler for a simple object-oriented language, Decaf, for x86.
• CS032: Introduction to Software Engineering. This is a sophomore level software engineering course taught in Java covering both advanced programming topics such as threads, user interfaces, and software architecture, as well as project engineering and agile programming. Students design and write a team project.

Courses (2004-2005):

• CS009-03: Building a Web Application. This is a freshman seminar where the students will work as a team to build, test, and deploy a web application.
• CS231: Human Factors and User Interface Design. This is a graduate seminar in covering various topics in user interfaces. The course is taught alternate years and tends to cover different topics each time it is taught. Possible topics this year include device-independent user interfaces and 3D desktops.
• CS234: Topics in Software Engineering. This is a graduate seminar that will cover some set of relevant topics related to software engineering. (With Shriram Krishnamurthi.)
• CS32: Introduction to Software Engineering. This is the course I have developed over the past 10 years and is the model for the text book "A Practial Introduction to Software Design with C++".

Courses (2003-2004):

• CS233: Programming Environments. Here we studied modern programming tools and the class project involved implementing a scriptable debugger for C/C++ under Linux.
• CS126: Introductory Compiler Construction. This is an undergraduate course in compiler construction. The course will be a hands-on course where the students will develop an optimizing compiler for a subset of Java generating SPARC assembly code. The course will be evenly split between parsing (including lexical analysis), semantic analysis, and optimization.
• CS32: Introduction to Software Engineering. This is the course I have developed over the past 10 years and is the model for the text book "A Practial Introduction to Software Design with C++".

Previous courses

Other courses I have taught in the last few years. Some of them I still teach, while others are now taught by other faculty members.

• CS190: Software Systems Design. This ia a senior-level project course where students work in teams of ten to learn software engineering and to build a useful system.
• CS178: Programming Parallel and Distributed Systems. This course covered the basics of distributed systems, web computing, and parallel computing using MPI.

Books

• A Practial Introduction to Software Design with C++. This is a text book for an advanced programming or introductory software engineering course. It covers a wide range of material including how to use (rather than abuse C++), program design at all levels (code, class, module, and system), user interface design and development, networking, software engineering, design patterns, debugging and testing, and advanced programming techniques.
• FIELD: A Friendly Interactive Environment for Learning and Development. This is a monograph that describes the FIELD programming environment in detail.

Conferences

General Chair for SoftVIS '05, to be held in conjuction with ICSE in St. Louis.

Personal

How to reach me:

Email: spr@cs.brown.edu

Snail Mail:

Box 1910, Computer Science Department

Brown University

Providence, RI 02912

Phone:

401-863-7641 (voice)

401-863-7657 (fax)

Equipment in my office:

4 Machines (1 Sun, 2 Linux, 1 Windows)

12 cpus (4,4,2,2)

3 Tb disk (actually 1Tb in an adjacent closet)

24G memory

8 monitors

Hobbies:

Gardening (vegetables)

Squash (the game, not the vegetable)

Softball

Family:

Loretta

Frederick (@ IBM Almaden)

Charles ( @ Ga Tech)

Valerie (Lincoln School in Providence, RI)

Last Updated: 11-May-2007 3:30 PM