Research Summary

Prasun Dewan


My current research falls in several areas: software engineering, user-interfaces, collaborative systems, mobile computing, security, and techniques for teaching introductory programming. These apparently diverse areas are in fact related, which I have found in the process of addressing various research problems. I first worked on software engineering issues that arise in the implementation of single-user user interfaces. The next step was to look at multi-user or collaborative user interfaces.  Collaboration raised issues in security easy-to-use mechanisms to specify security requirements. Another related step was to look at collaboration involving both stationary and mobile devices. A student, Fisayo Omojokun, showed me that some of the user-interface techniques I worked on could help make a mobile computer become a universal remote control for arbitrary networked devices. I have recently found that these techniques also help in the teaching of introductory programming.  Described below are some of the projects on which I am working.

Scalable Collaboration Architectures for Mobile and Desktop  Devices

From the point of view of a potential user of collaborative systems, it is perhaps the best of times and the worst of times. Never before has there been as much choice in the number of practical collaborative systems available. The bad news is that choosing one of the various available options is a difficult task. The reason is that these options offer different architectures, which have not been scientifically compared in the research or commercial world. We are evaluating the performance of these various architectures through analytical models and experiments. In addition, we are developing techniques that allow a single system to support all known architectures and enable dynamic transitions between them. The goal is to use our evaluation work to automatically choose the architecture of the system based on dynamic conditions. In particular, we wish to adapt the architecture in response to mobile users dynamically joining and leaving a collaborative session. We also wish to build scalable architectures that allow large numbers of users to participate in a collaborative session and leave and join the conference with no impact on the performance of other users.

Integrating application sharing and collaborative applications

Collaborative systems typically have two components: an “application sharing” system that allows sharing of collaboration-unaware applications (that is applications that were not designed for collaboration) and a set of collaborative applications, such as a whiteboard and a distributed presentation tool, that are collaboration aware. The reason for providing a special set of collaborative applications is that application-sharing systems provide a very tightly coupled and inflexible model of collaboration in which What You See Is What I See (WYSIWIS).  Collaborative applications relax this model by allowing, for example, different users to scroll to different parts of a whiteboard or presentation. The reason for providing the application sharing system is that the cost of implementing collaborative applications is high. We are developing a technique that supports both WYSIWIS and non-WYSIWIS sharing of collaboration-unaware applications. Our goal is to show that it is possible to support all known ways to relax WYSIWIS in a generic application sharing system. This research direction holds the promise of more flexibly collaborating with a wider range of tools such as document editors and spreadsheets for which special collaborative applications are not developed.

User-interface Generation for Network Appliances and Teaching Programming

One of the visions of mobile computing is the ability to use an interactive mobile computer to control networked appliances such as lamps, TVs, and water sprinklers. An issue here is: how are the user-interfaces of these appliances created on the mobile computer? Assuming that they have been preloaded on the mobile device limits the device’s interaction with only those network appliances it knows about. Downloading them from the network appliances creates security and other problems. The approach we are taking dynamically generates the user-interface by reflecting on the class implementing the appliance object. It is exploring several novel ideas such as retargetting a user interface generated for one device to another device, lazily generating parts of a user-interface as they are needed, generating user-interface parts based on the history of interaction with the device, and creating user-interfaces to  dynamically created compositions of appliances.


In general, a generated user-interface may not be the one desired by the user. We believe this is not so much of a problem in the domain of network appliances, which can be expected to have relatively simple user interfaces.  Another constrained domain is the teaching of introductory programming. Today, students are taught user-interface toolkit primitives as “magic” they are not expected to really understand. Moreover, introducing, using and debugging these primitives detracts from the teaching of programming concepts – the reason beginning students do not have a real grasp on object-oriented programming. The alternative we are exploring is automatic user-interface generation and using the time that would have been spent in learning toolkits to understand design patterns. This is consistent with the way functionally programming is taught – students never have to use I/O primitives, as the interpreter automatically provides a user interface to invoke functions. We are essentially adapting this style to object-oriented programming.

Mixed Initiative Access Control

Security in general and access-control in particular is paradoxically both an old and hot research area. It is an old area because it has always been important. It is a hot area because every computing advance makes it more important, and the techniques developed so far have been relatively unsatisfactory. Today’s access control models are too complicated for most users to use – for example few users have used negative rights. On the other hand, they are too inflexible to specify for example, the frequency with which idle-time and other presence information is transmitted to others watching us. We are attacking this problem in two ways. First, we are developing access control models that are more expressive than the state-of-the-art, targeting the needs of presence and other collaboration tools. Second, we are exploring a “mixed-initiative” rights distribution scheme where the task of specifying access rights is distributed among information producers and consumers, and tools that run on their behalf. Our ultimate goal is to have most of the work of specifying access rights be done automatically by tools, which allows for far more complicated - and hence expressive - access control models. This work was started during my recent sabbatical at Microsoft and is being done in collaboration with Jonathan Grudin and Eric Horvitz of Microsoft Research.

From Programming Interfaces to Patterns

Today, it is considered good programming practice to write classes that conform to interfaces that specify the signatures of the methods implemented by the class. An extension of the idea is to write classes that conform to “programming patterns,” which specify parts of the signatures of methods and relationships among these parts. An interface is simply a programming pattern that specifies the complete signatures. A simple example of a programming pattern is the JavaBean convention for specifying getters and setters of properties. The JavaBean conventions are hardwired and informally specified. We are exploring programmer-defined patterns in the spirit of programmer-defined interfaces that are used to solve a variety of systems problems. An example of such a problem is user-interface implementation. Manual implementation implies creating user-interface code for a specific interface. Automatic generation, in contrast, can be considered creating user-interface code for a general pattern that applies to a family of interfaces.  We are also exploring pattern-based solutions to problems in access control and collaboration.