Brown CS News

With Someone, Please Knock, says the digital sign outside CIT 403, but not for much longer. 

Brown CS faculty member Steven P. Reiss, one of the Department’s seven co-founders, will be retiring at the end of the semester after almost five decades in the classroom.

Steve arrived at Brown in 1977. His account of the early days, of being a computer scientist without a CS department, is typically nonchalant: “I didn’t care where I went and they didn’t have a department yet, so they put me in Engineering. Computer Science was small at first, and everyone was reasonably friendly, so the faculty always got together and we were all involved with running things. The theme of the department was a combination of theory and practice, so the theoreticians had to understand practical aspects of their work, and vice-versa.” 

There was also an emphasis on teaching: at the start of Steve’s career, he and his co-founders were responsible for four courses annually. It was a long time ago, but those early years are still vivid in Steve’s memory when we ask about people who have inspired him, whether in our field or not. 

“I don’t really think that way,” he says, “but [An Wang Professor Emeritus of Computer Science] John Savage and [Thomas J. Watson, Jr. University Professor of Technology and Education and Professor of Computer Science] Andy van Dam, they were great mentors to me. I’m grateful to them.”

Perhaps unsurprisingly, Steve recollects the past half-century as a series of research projects (“it’s how I measure my time”), saying that he doesn’t have a favorite, that he’s prone to be attached to whichever one he completed most recently. When talking about them, his satisfaction is obvious, but he never brags. Steve is deep into a discussion of b and bb, the text editors used on the first Brown CS mainframe, the VAX-11/780, when I ask if he was involved with creating them. 

“I built them,” he says simply, with the emphasis on the second word. “And bb is the editor I still use today. I’ve always done these systems. They’re research – what I think will come out on the market in five to ten years.”

Even Steve’s short list of significant projects from his time at Brown CS boggles the mind:

• PECAN, used on the VAX, was a multiview environment that provided graphical views of program syntax and semantics. It was a precursor to IBM’s ECLIPSE open-source Java Integrated Development Environment (IDE). PECAN showed the power of workstations and multiple views, but Steve says that it wasn’t practical at the time: “You always ran out of memory, and it wasn’t all that fast.” Twenty-five years later, it won the ACM SIGSOFT Impact Paper Award.

• GARDEN, which followed, provided dynamic visualization of program execution based on visual languages. “We really had some nice results, considering the time,” Steve remembers.

• FIELD offered interactive visualizations of data structures, call graphs, the class hierarchy, build dependencies, performance data, I/O behavior, and memory utilization. It  pioneered the concept of message-based (control) integration and illustrated a variety of program visualizations. “We used it here for ten years,” Steve says, “and Brown licensed it to DEC. It was highly successful and it formed the basis, either conceptually or literally, for most UNIX programming environments in the 1990s.”

• DESERT combined control integration, an inexpensive data-integration mechanism, and a common editor to produce a comprehensive programming and design environment. “It used FrameMaker as the editor,” Steve says, “and was a front-end for programming and breaking code into fragments.” DESERT’s tools let the user quickly specify what data should be visualized and how it should be displayed, allowing new 3D visualizations to be created in a matter of minutes.

• The BLOOM visualization system combined extensive trace collection facilities, a variety of data analyses including statistical and inferential approaches, a simplified visual query language for defining what to visualize, and a variety of 3D visualization tools.

• JIVE provided views of thread and class behavior and JOVE offered views of where execution occurred at the statement level. Their joint goal was to develop a system that let the user quickly define problem-specific and program-specific dynamic visualizations.

• TAIGA provided visualization at the internet-scale programming level. It was “a fun little project” that got nowhere, Steve says, but did lead to the next project, S6. 

• S6 created code by searching repositories such as GitHub.  “The code search,” explains Steve, “allowed you to generate code by inputting classes and test cases and keywords and then find code that matches your signature, which you could then run against your test cases. It was sort of magic!” 

• Code Bubbles is a full-featured integrated development environment designed to simplify programming by making it easy for the programmer to define and use working sets. It provides fully editable “bubbles” that offer a compact, function-based view of code that the user can move around and manipulate on their screen. It also includes experimental features for visualization, collaboration, live programming, and security checking.  

• Some projects related to Code Bubbles include SEEDE, which offers live programming with continuous execution for Java; DYVISE, a Java low-overhead dynamic performance analysis package for visualizing detailed performance; FAIT, which provides Java data flow analysis that updates as the user types; and ROSE, a facility for doing automatic program repair while debugging.   

Even in brief, even an incomplete list of Steve’s projects seems like enough to fill multiple lifetimes. And yet before the COVID-19 pandemic, he was still teaching three classes annually. 

“And I launched a lot of undergraduate courses over the years,” he says. “They kind of spawned alongside my research projects.”

Those courses include CSCI 0320 Introduction to Software Engineering; CSCI 0190 Accelerated Introduction to Computer Science; and the Department’s first undergraduate user interface course, CSCI 1950-I Designing, Creating, and Developing User Interfaces, co-taught with Brown CS faculty member Jeff Huang. Others include CSCI 1270 Database Management Systems; CSCI 1320 Creating Modern and Mobile Web Applications; CSCI 1600 Embedded and Real Time Programming, which he co-taught with former Brown CS faculty member John Jannotti; CSCI 1780 Programming Parallel and Distributed Systems, a scientific computing course that covered the basics of distributed systems, web computing, and parallel computing; and CSCI 1900 Software Systems Design.

All in all, Steve taught or co-taught more than a dozen different courses, but his last lecture, fittingly, was for CSCI 2340 Software Engineering. To his surprise, dozens of faculty, staff, and students filed into the Sunlab on November 21, 2024, for a tribute from Brown CS faculty member Shriram Krishnamurthi and a triumphant rendition of a newly-written song in Steve’s honor (video available here).

Steve says that he was truly touched.

“I want to thank everyone who made the last forty-eight years possible,” he says. “My current students, our faculty, AStaff and TStaff and our alums. You’ve all made my time at Brown productive and enjoyable.”

Has Brown CS changed over those forty-eight years?

“The entire field has changed,” says Steve. “And my feelings on the subject are controversial. I like to do my own systems research, and that’s not the thing these days.”

Fortunately, that research will continue: “There’s no pressure to publish, so my wife and I will travel a bit, visit family. Mostly, I’ll continue programming. I’ll keep busy.”

One ongoing project is SHERPA, a new Internet of Things user interface designed for security. “I’m interested in using large language models for programming,” Steve says, “and I hope my students keep working on it and give me a framework for future research. I’d love to see a paper with their names on it.”

On the more whimsical side, Steve wants to extend a combined hardware and software system he created to control his model train set that uses Wi-Fi and eighty sensors embedded on the track to manipulate switches and signals and automatically prevent collision. Part of the fun, he says, was working alongside his grandchildren, wiring circuit boards and debugging together. 

Then he lights up: “And Code Bubbles is up and running! Fully stable, open source, and anyone can contribute to the source code. If they keep using it, I’ll keep supporting it.”

Steve pauses for a moment, maybe thinking about all the research projects past, present, and future. 

“I still want to learn, even in retirement,” he says. “I always learned something while I was doing research projects, and that’s why I did them.”

For more information, click the link that follows to contact Brown CS Communications Manager Jesse C. Polhemus.