Steven P. Reiss Home Page (original) (raw)

What's the Latest

• My current status (displayed outside my office and updated automatically)

• The Code Bubbles programming environment is now available in both source and binary forms. See the web page at http://www.cs.brown.edu/people/spr/codebubbles for more information.

• S6 code search tool is now available. Try the S6 web interface.

• DYMEM memory visualization tool is available as part of DYPER.

• DYPER dynamic performance analysis tools are available.

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,DYPER,DYMEM,DYVISE). 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. DYPER is visual performance monitoring designed for long running servers. It provides statistically accurate performance information within whatever overhead the user allows (e.g. 10%, 1% or even 0.1%). DYMEM is a low-overhead memory visualizer that shows object ownership in a compact visualization for running programs. It can be used to detect memory problems. DYVISE is a general purpose dynamic visualizer that takes minimal programmer input and uses dynamic and static analysis to determine what to visualize, how to instrument the code, and how to provide an appropriate visualization.
• Programming Environments (PECAN,GARDEN,FIELD,DESERT,CLIME,WADI,BUBBLES)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. Bubbles attempts to provide a new user interface for programming based on code fragments.
• 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.
• Semantic-Based Code Search (S6).Our goal here is to provide a means for the programmer to access the huge repository of open source code that is available on the web without having to read and then modify the code that is returned from traditional search engines such as Google Codesearch. In S6 the programmer specifies keywords, test cases, contracts, signatures, security constraints, and a user context. The tool finds relevant code and then uses a set of transformations to make that code meet the programmer specifications.

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.
• BUBBLES: Code Bubbles is a front end to Eclipse that provides a new user interface for programming based on code fragments displayed in bubbles. Following up on the concepts of Desert, but with a usable user interface and a back end based on Ecipse, this provides a new user experience for managing and interacting with large code bases.

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.
• Dyvise. This is a performance analysis and dynamic visualization framework encompassing a number of tools including DYPER for performance analysis, DYMEM for memory visualization, and DYVIEW for dynamic visualization.
• S6. This is the code for our semantics-based code search engine.
• Code Bubbles. This is our new IDE for Java based on working sets.

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 (2012-2013):

• CSCI1320: Creating Modern Web Applications. This is a new course that teaches students the concepts needed for creating interactive web applications using modern technology. It covers topics including user interface and web design, basic HTML, Javascript, and Php, frameworks such as Django and Ruby, Java-based coding using servlets and GWT, security, testing, scaling to handle large numbers of users, internationaliation and accessibility. Students in the course work in teams to build a working web application for an outside client. Clients this year included campus organizations, non-profits, local companies, and Brown enterprenurial students.
• CSCI1600: Embedded and Real-Time Programming. This course teaches the concepts needed to create software-controlled embedded and real time systems. Topics include basic hardware and low-level software concepts, real time scheduling, modeling real time and embedded systems, and proving properties of the systems.
• CSCI2310: 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 (2011-2012):

• CSCI0931: Introduction to Computation for the Humanities and Social Sciences. This course that looks at problems in the humanities and social sciences that can be solved using appropriate data analysis and computation. It concentrates on application problems and not on programming or mathematics. This course is the result of a NSF CPATH project we have been working on.
• CSCI1320: Creating Modern Web Applications. This is a new course that teaches students the concepts needed for creating interactive web applications using modern technology. It covers topics including user interface and web design, basic HTML, Javascript, and Php, frameworks such as Django and Ruby, Java-based coding using servlets and GWT, security, testing, scaling to handle large numbers of users, internationaliation and accessibility. Students in the course work in teams to build a working web application for an outside client. Clients this year included campus organizations, non-profits, local companies, and Brown enterprenurial students.
• CSCI 2340: Topics in Software Engineering. This is a seminar course on topics related to software engineering.

Courses (2010-2011):

• CSCI0931: Introduction to Computation for the Humanities and Social Sciences. This course that looks at problems in the humanities and social sciences that can be solved using appropriate data analysis and computation. It concentrates on application problems and not on programming or mathematics. This course is the result of a NSF CPATH project we have been working on.
• CSCI1320: Creating Modern Web Applications. This is a new course that teaches students the concepts needed for creating interactive web applications using modern technology. It covers topics including user interface and web design, basic HTML, Javascript, and Php, frameworks such as Django and Ruby, Java-based coding using servlets and GWT, security, testing, scaling to handle large numbers of users, internationaliation and accessibility. Students in the course work in teams to build a working web application for an outside client. Clients this year included campus organizations, non-profits, local companies, and Brown enterprenurial students.
• CSCI1600: Embedded and Real-Time Programming. This course teaches the concepts needed to create software-controlled embedded and real time systems. Topics include basic hardware and low-level software concepts, real time scheduling, modeling real time and embedded systems, and proving properties of the systems.
• CSCI 2330: Programming Environments. This is a seminar course on topics related to programming environments. This year we worked on new programming tools to address mutlicore, threaded and distributed programming.

Courses (2009-2010):

• CSCI0931: Introduction to Computation for the Humanities and Social Sciences. This is a new course that looks at problems in the humanities and social sciences that can be solved using appropriate data analysis and computation. It concentrates on application problems and not on programming or mathematics. This course is the result of a NSF CPATH project we have been working on.

Courses (2008-2009):

• CSCI0190 (CS019): Accelerated introduction to programming and data structures. This coursecombines 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.
• CSCI2340 (CS234): Topics in Software Engineering. This is a graduate seminar on software engineering. The topics studied vary from year to year depending on the interests of the students.

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.

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:

3 Machines (2 Linux, 1 Windows)

14 cpus (8,4,2)

2 Tb disk

40G memory

7 monitors

Equipment in the machine room (non-departmental):

41 machines (40 mac xserves, 1 Sun Ultra 80)

84 CPUs

Hobbies:

Gardening (vegetables)

Squash (the game, not the vegetable)

Softball

Family:

Loretta

Frederick (@ IBM Almaden)

Charles ( @ UC Berkeley)

Valerie (@ GA Tech)

Last Updated:09-Jun-2011 10:43 AM