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.
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.
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.
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.
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.
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.