No big surprises in the list of course, but nevertheless interesting to have a look at. The problem (at least in Belgium) seems to be that the rankings used for university funding are focused mostly on journals. The top conferences are often only ranked slightly higher than average conferences, meaning that two or three papers at a mid-level conference will be better in terms of funding than one paper at a top conference. Of course, there is always the prestige and international recognition you receive when getting a paper accepted at a top conference
Page 3 of 18
Lode pointed me to an interesting article on Wired about research done at the Fluid Interfaces group of MIT Media Lab. The article was based on the recent TED Talk by Prof. dr. Pattie Maes (who is a Belgian by the way :-)).
In their prototype, the user carries a wearable projector that projects information on physical surfaces or objects. This is essentially augmented reality but without having to use VR helmets/goggles or other devices (e.g. mobile phones) to view digital annotations. Although there are already systems that use wall-mounted projectors to augment rooms with digital annotations (Jonathan Slenders also looked into this for his Master’s thesis), in this prototype the projector is mobile as it is simply worn around the user’s neck. The device could project useful annotations on physical objects, such as Amazon reviews on books or flight information on boarding passes:
This reminds me of the topics that my student Ruben Thys explored for his Master’s thesis (paper, video). Our solution was a bit more clumsy than this one though (it required a mobile device to view information attached to physical objects). I also remember reading a related UIST’06 paper that described multi-user interaction techniques with handheld projectors.
Wearable projectors seem to be a promising approach to provide feedback in ubiquitous computing, and might help to further bridge the physical and virtual worlds.
Research is to see what everybody else has seen, and to think what nobody else has thought.
— Albert Szent-Gyorgyi (Hungarian Biochemist, 1937 Nobel Prize for Medicine, 1893-1986)
I got the idea to document the way I read papers from a discussion with Lode (he uses mostly the same approach as I do). I’m pretty certain this is obvious for many people, but I hope it may still be useful for others.
In this post I focus on processing lots of (related) papers in the least amount of time. I will not discuss how you find interesting papers, since this is fairly easy. Reading prestigious conference proceedings or journals in your field usually allows you to end up with a couple of seed papers that are representative for your specific area of interest. If you do research in ubiquitous computing, reading the proceedings of Ubicomp, Pervasive or Percom, and journals such as Personal and Ubiquitous Computing will get you along quite nicely. If you focus on the human-computer interaction aspects of ubiquitous computing, throw in the proceedings of CHI and UIST, together with the TOCHI and Human-Computer Interaction journals. The papers you find here will be stepping stones to related papers (and conferences) using the simple technique I will discuss in this post.
I estimate that of all papers I read, I only process 1 out of 5 in full detail. Most of the time when I find a paper that seems interesting, I start with skimming the paper briefly. I focus mostly on the abstract, the last part of the introduction (which should list the contributions), relevant pictures in the main matter, and the conclusion/discussion. I do several passes over the paper to validate my early understanding of what the authors did. I also go through the related work and references. This allows me to see if the authors refer to work that I don’t know but which could be interesting (which I mark for later processing). This will usually take little more than 5 minutes.
Now I have a pretty good idea whether the paper is interesting to me. If it’s not, I just go through the interesting references (if any) using the same process and stop there. If it is interesting, I go one step further, treating the paper as a seed paper that allows me to find other relevant work.
If the paper is not too recent, there will probably be (lots of) other articles that refer to this paper. Even if the paper is fairly new, it is still worth looking up papers that already refer to it. Looking up these articles allows me to discover relevant related work and to see how others critically describe this paper. A critical review could contradict of the results of the paper (e.g. through replication, such as Shumin Zhai’s work on target expansion), or might offer new insights (such as suggesting a new direction for research related to the original paper, as Yvonne Roger’s Ubicomp’06 paper did for Mark Weiser’s original Ubicomp paper). Both types of critical reviews are very useful for your own understanding of the paper.
After entering a title in Google Scholar, it presents you with a list of matching papers. Below each item, there is a link with the number of papers that cite it (indicated in orange in the figure below). In this case there are 118 citations:
After clicking on this link, Google Scholar shows all articles that cite the previous one, sorted by their relevance (in other words, the number of times these articles are themselves cited):
This approach to reading papers has one disadvantage: your reading list will quickly grow. You can end up with 30 more papers to read starting from just 1 interesting seed paper (which is what happened to me when I looked for papers that cited Intelligibility and Accountability: Human Considerations in Context-Aware Systems by Victoria Bellotti and Keith Edwards). In my opinion, this is actually an advantage as it allows you to quickly find many related (and hopefully interesting) papers. Furthermore, because you’re skimming papers, you never spend more than 5 minutes on papers that are not relevant or interesting.
After I have found a significant number of papers that I want to read, I of course will go through them in more detail. Papers that are very relevant for my work or give me the feeling they deserve a more thorough reading (e.g. because they provide many new insights), will be read from beginning to end. A few examples that I also discussed in my blog are: Range: Exploring Implicit Interaction through Electronic Whiteboard Design, Evaluating User Interface Systems Research and two chapters from Beyond the Desktop Metaphor: Designing Integrated Digital Work Environments.
I recently read an interesting CSCW 2008 paper by Wendy Ju: Range: Exploring Implicit Interaction through Electronic Whiteboard Design. She describes a framework for implicit interaction and applies it to the design of an interactive whiteboard application called Range.
The paper is situated in the field of ubiquitous computing. The goal of Mark Weiser‘s vision of ubiquitous computing was calm computing, where calm reflects the desired state of mind of the user. Invisibility in ubicomp is more about enabling seamless accomplishment of task than staying beneath notice. Just as a good, well-balanced hammer “disappears” in the hands of a carpenter and allows him or her to concentrate on the big picture, computers should participate in a similar magic disappearing act. Calm computing moves between the center and the periphery of attention. The periphery informs without overwhelming the user, but the user can still move to the center to get control. The implicit interaction framework presented in this paper contributes to how calm computing can be effectively realized. It allows to reason about the way users can mitigate actions the system takes, and is a good complement to Eric Horvitz’s work on mixed-initiative interaction.
Implicit interactions enable communication and action without explicit input or output.One way that an action can be implicit is if the exchange occurs outside the attentional foreground of the user (e.g. auto-saving files, filtering spam, and ubicomp interaction). The other way is if the exchange is initiated by the computer system rather than by the user (e.g. an email alert, screen saver, etc.). Although it may seem strange that something that grabs attention is implicit, the key factor is that the interaction is based on an implied demand for information or action, not an explicit one.
The implicit interaction framework divides the space of possible interactions along the axes of attentional demand and initiative:
Attentional demand is the degree of cognitive and perceptual load imposed on the user by the interactive system. Foreground interactions require a greater degree of focus, concentration and consciousness and are exclusive of other focal targets. Background interactions are peripheral, have less demand and can occur in parallel with other interactions.
Initiative is an indicator of how much presumption the interactive system uses in the interaction. Interactions that are initiated and driven by the user explicitly are called reactive interactions, while interactions initiated by the system based on inferred desire or demand are proactive interactions.
The implicit interaction framework builds on Bill Buxton’s background/foreground model. Buxton’s model assumes attention and initiative are inherently linked. On the contrary, this framework decouples attention and initiative in two separate axes. Buxton’s foreground corresponds to the reactive/foregound quadrant, while his background corresponds to the proactive/background quadrant.
An example: a word processing program that …
- auto-saves because you command it to is situated in the reactive/foreground quadrant
- auto-saves because you have set it to do so every 10 minutes is situated in the reactive/background quadrant
- auto-saves because it feels that a lot of changes have been made is situated in the proactive/background quadrant
Being proactive means the word processing program is acting with greater presumption with respect to the needs and desires of the user.
Designers can manipulate the proactivity and reactivity by (1) dictating the order of actions (does the system act first or wait for the user to act?); or by (2) choosing the degree of initiative (does the sytem act, offer to act, ask if it should act, or merely indicate that it can act?); or by (3) gathering more data to ensure the certainty of the need for an action or when they design features to mitigate the potential cost of error for the action. Even in the reactive realm, the degree of initiative can vary based on the amount that the user needs to maintain ongoing control and oversight of an action in progress.
Ju discusses 3 implicit interaction techniques:
- user reflection
- system demonstration
User reflection is how the system indicates what it feels the users are doing or would like to have done.
A good example are modern spell-checking programs. Early versions had to be invoked explicitly, and engaged the user in an explicit dialog about potentially misspelled words to repair. Current spell-checking programs run continuously in the background allowing users to more easily notice potential errors. The implicit alert of this interaction is far more seamless than that of earlier spell-check programs. A similar example is the continous compilation used by modern IDEs such as Eclipse and Visual Studio. Earlier programs only showed compile errors when the user explicitly activated the compile command.
System demonstration is how the system shows the user what it is doing or what it is going to do.
In Range, the whiteboard animates its transition from ambient display mode (where it displays a set of images related to the workspace) to drawing mode (where users can make sketches and diagrams) as a demonstration-of-action that calls more attention to the mode change than a sudden switch would, and provides a handle for override (see later).
Override techniques allow users to repair misinterpretation of the user’s state or to interrupt or stop the system from engaging in proactive action.
This usually occurs after one of the previous techniques (user reflection or system demonstration) alert the user to some inference or action that is undesirable. Override is distinct from “undo” because it is targeted at countering the action of the system rather than reverting a command by the user.
An example of override in Range is that in the transition between modes users are able to “grab” digital content to use it as part of the whiteboard contents, or to stop the motion of objects that are being moved to make space for drawings.
The main contribution of this framework compared to prior models for implicit interaction lies in the key variable of initiative. Without this variable, it would not be possible to distinguish user reflection techniques from system demonstration techniques or to map the role of override.
In conclusion, a very interesting paper that offers a framework to reason about proactive user interfaces and make sure that users are always in control.
I had to position the camera a bit lower, because it would sometimes not recognize my face when I was looking at the bottom of my screen. Having a dual-monitor setup doesn’t help either, since you should ideally position the webcam in the middle of the two displays to have good coverage. I positioned the webcam in the middle of the two displays at the bottom and tilted it upwards, which gives good results:
I guesstimated that if the system couldn’t detect a face for a period of 10 seconds, I would be away from my desk (or at least not paying attention to the screen). I played around a bit with pygtk and notify-python to create a status icon and show notification bubbles whenever my status changed. Here’s what happens when it detects that I’m away from my desk (notice the bubble in the upper right corner):
When I return, the system will change its status icon accordingly and notify me again:
OpenCV is fun!