You’ll see interviews with Guido van Rossum (creator of the Python language), Eric S. Raymond (author of “The Cathedral and the Bazaar” and the excellent article “Why Python?”), and Tim Peters (known a.o. from The Zen of Python).

The film was originally called “A Python Love Story”, and was was made in 2001 by a class of high school students in Yorktown High School (Arlington, Virginia) together with their Computer Science teacher Jeff Elkner. Elkner is known for translating Allen Downey‘s “How to Think Like a Computer Scientist” into Python. The original (and longer) version of the video is available from the Python Bibliotheca.

Ubicomp 2009

Our work on supporting why and why not questions to improve end-user understanding in Ubicomp environments was accepted as a poster to Ubicomp 2009

Jo Vermeulen, Geert Vanderhulst, Kris Luyten, and Karin Coninx. Answering Why and Why Not Questions in Ubiquitous Computing. To appear in the Ubicomp ’09 Conference Supplement (Poster), Orlando, Florida, US, September 30th – October 3rd, 2009, 3 pages.

Abstract: Users often find it hard to understand and control the behavior of a Ubicomp system. This can lead to loss of user trust, which may hamper the acceptance of these systems. We are extending an existing Ubicomp framework to allow users to pose why and why not questions about its behavior. Initial experiments suggest that these questions are easy to use and could help users in understanding how Ubicomp systems work.

There is a separate page for the poster on my homepage, including a PDF version of the poster and the extended abstract.

Mario Romero has an excellent Ubicomp 2009 photo set on Flickr.

Here’s a picture of me explaining the poster:

And here I am presenting in the One Minute Madness session:

Karel Robert helped me create a video for the One Minute Madness session that would stand out. Although it might have been a bit too attention-grabbing, I certainly had fun making it and presenting in the Madness session.

Here is the video:

Next to presenting my poster, I also served as a Ubicomp 2009 student volunteer, which earned me a place in Joe McCarthy’s opening slides for the conference (slide 6)

Being a student volunteer was lots of fun! I got to meet a lot of interesting people, and still had the opportunity to follow most of the sessions. I also explored the parks together with a few of the other volunteers (Ubicomp 2009 was held in Disney World), and we even played beach volley on the last day

When we went to the Magic Kingdom, I had to see Randy Pausch’s plaque at the Mad Tea Party:

The plaque contains a quote from Randy’s Last Lecture:

If you haven’t watched the Last Lecture yet, I strongly recommend you do! It will be an hour well-spent.

Full paper accepted to AmI 2009

The full paper that we submitted to the third international conference on Ambient Intelligence 2009, was accepted as well. This work was a collaboration with Jonathan Slenders, one of our Master’s students.

Jo Vermeulen, Jonathan Slenders, Kris Luyten, and Karin Coninx. To appear in the Proceedings of AmI ’09, the Third European Conference on Ambient Intelligence, Salzburg, Austria, November 18th – 21st, 2009, Springer LNCS, 10 pages.

Abstract: The design ideal of the invisible computer, prevalent in the vision of ambient intelligence (AmI), has led to a number of interaction challenges. The complex nature of AmI environments together with limited feedback and insufficient means to override the system can result in users who feel frustrated and out of control. In this paper, we explore the potential of visualizing the system state to improve user understanding. We use projectors to overlay the environment with a graphical representation that connects sensors and devices with the actions they trigger and the effects those actions produce. We also provided users with a simple voice-controlled command to cancel the last action. A small first-use study suggested that our technique could indeed improve understanding and support users in forming a reliable mental model..

There is again a separate page for the paper on my homepage, together with a PDF version.

Basically, our technique visualizes the different events that occur in a Ubicomp environment, and shows how these events can lead to the system taking actions on behalf of the user and what effects these actions have. Here is a video of the technique:

The AmI 2009 conference takes place in Salzburg in about three weeks.

Talk at SIGCHI.be

I also submitted a paper to SIGCHI.be‘s (the Belgian SIGCHI chapter) 2009 Fall Conference on New Communities. The paper was titled Improving Intelligibility and Control in Ubicomp Environments, and motivated the need for intelligibility and control in Ubicomp while also giving a short summary of the Ubicomp 2009 poster and AmI 2009 paper.

Here are the slides:

Thanks to everyone at our lab who contributed in one way or another (either by participating in user studies, or by reviewing drafts of the papers)

Specials thanks to:

• Karel Robert for designing the visualizations we used in the AmI 2009 paper and for helping me with the Ubicomp 2009 One Minute Madness video.
• Daniël Teunkens for drawing the why question storyboards that were used in the SIGCHI.be presentation.
• Mieke Haesen for being a great actress in the AmI 2009 movie
• Kris Gabriëls for posing in the picture we used for the Ubicomp 2009 poster abstract.

Although I already created a Facade project page a while ago and made the code available through Bazaar, I never announced it here. To make it easier to try the script out, I also uploaded an archive of the code. This version includes a simple Python script that works on Windows (simple_winclient.py) that performs face detection.

I noticed today that Jinwei Gu, a PhD student at the University of Columbia and teaching assistant for the course COMS W4737 (E6737) Biometrics, included my blog post in a list of links to resources for doing face detection.

Last year, two students improved the presence detection in Facade during their Bachelor’s theses.

Bram Bonné worked on the network aspect, to allow users to have their presence detected on multiple computers. When users would move from one computer to another (or to a mobile device), their messages would automatically be routed to their current machine.

Here are a few screenshots from Bram’s thesis:

Bram also created a demo video of his system:

Kristof Bamps worked on supporting a more diverse set of sensors (e.g. presence of a Bluetooth phone, keyboard and mouse input). He used a decision tree to model all these sensors, and determine the user’s correct presence based on the collected information.

Two screenshots from Kristof’s thesis:

Kristof’s demo video:

I have unfortunately not yet found the time yet to merge Kristof’s and Bram’s code into the main Facade branch, but this should not be too big of a problem.

The group blog features an interesting post by Tessa Lau, titled Three Misconceptions About Human-Computer Interaction, which raises a few interesting points. In my opinion, HCI is much more fundamental to creating interactive systems than people usually believe. In this context, I would like to refer to an interview with Patrick Baudisch that I recently read, in which he explains how he got started in HCI:

Doantam: How did you get started working on human-computer interaction?

Patrick: Without knowing it. I was a Ph.D. student in Darmstadt, Germany and worked on user interfaces for information filtering systems. A friend of mine saw my work and said “oh, I did not know you were in HCI, too”.

That was the first time I heard of that field.

A few months ago I decided to look for a better solution. I experimented with various solutions, including Drupal (with a lot of help from Wim Leers, thanks Wim!) and WikkaWiki (with a few tips from Dario Tarborelli) before finally settling on PmWiki. In this post, I will describe my rationale for choosing PmWiki over Drupal and WikkaWiki.

An advantage of Drupal is that it is extremely flexible. For instance, the website’s menu and corresponding URL structure can be completely customized. It also allows you to define content types such as “Course” or “Student” in a graphical way with the CCK module and visualize them with the Views module. However, this takes quite some initial work. Moreover, changes to the structure (e.g. allowing courses to have associated pictures of student projects) requires changing all this again. I believe that I should be able to change the structure of my homepage at any time. Adding a related publication to a software project or to a Master’s thesis should not involve a whole day of editing content types. Although I could use the Page content type for all my content, this is considered bad practice since Drupal only uses Page for static pages that almost never change. Of course, using Drupal only to provide a shared template and a global menu is massive overkill

In the same period, I read an interesting blog post on Academic Productivity about using a wiki to invisibly power a (research) homepage by Dario Tarborelli. A wiki seemed to provide a solution to structural flexibility, since it allows users to quickly rearrange content. However, as Dario points out, there are two problems that often make people suspicious of using a wiki for their website:

1. anyone can edit the content of a wiki
2. wikis look wikish

Dario demonstrates in the blog post that WikkaWiki can easily overcome both issues with access control lists and an easy-to-use skin system. He continues by giving a few advantages of using wikis for content management:

• they allow you to edit and modify content at the speed of light
• they allow you to easily embed all sort of contents in a page
• they allow you to set granular access privileges for specific pages, which is a very powerful solution for collaborative work with colleagues and coauthors

I started to experiment with a WikkaWiki-based homepage and was able to very quickly migrate my content and create a custom skin. I was impressed! There was a catch though. WikkaWiki did not support file uploads in an easy way, and custom markup (e.g. lists with a certain CSS class) seemed to be hard to achieve. Having the ability to upload files was essential for me, since I did not want to use an (S)FTP client everytime I wanted to add a publication or screenshot. Custom markup would be nice to style my publications list. Although WikkaWiki supports embedding HTML directly, it is obviously not ideal to have large amounts of embedded HTML in the content of a page.

Then I decided to have a look at PmWiki . I already heard about PmWiki before. Jori used it to power his homepage, and Peter also used it to power the Mobile and Pervasive Computing course website. Of course, the fact that 6th most frequent author in HCI uses PmWiki to power his personal homepage and the homepage of his research group helps as well A few other examples of PmWiki usage by HCI researchers or groups:

• personal website of Jakob E. Bardram
• the website of the in|situ research group in Paris, France
• personal website of Sean Gustafson

But the question was of course: how can I use PmWiki to invisibly power my website? I decided to post a message on the PmWiki mailing list asking for help, and got many helpful responses. One of the things I especially like about PmWiki is the helpful and lively community. Everything I wanted to do with PmWiki was either explained in the Cookbook, or pointed out by someone on the mailing list. As an example of a very nice website invisibly powered by PmWiki, take a look at the Village School website.

These are the steps that I followed:

1. Install PmWiki: this is very easy, just extract the archive and point a web browser to pmwiki.php (detailed instructions). PmWiki does not require a database, it uses flat files (yes, flat files!). That means you can easily copy a PmWiki installation from one directory to another (or even from one server to another).
2. Create a new skin by copying the default pmwiki skin in a new directory and give it an appropriate name.
3. Start editing the page template and CSS file to suit your liking. Hide typical wiki elements with CSS or by removing them from the template. PmWiki supports conditional markup so you can change the displayed page actions based on your login status. For more information, see this post on the mailing list and the documentation about page actions. You can also add conditional markup to hide the PmWiki documentation pages from the sidebar. If you refer to images in your CSS file, just keep in mind that the path is relative (e.g. refer to pmwiki/pub/skins/myskin/icons/trash.gif as background: url(icons/trash.gif);).
4. Set a password for editing pages.
5. Set up file uploads (disabled by default). Once uploads are enabled, PmWiki will automatically create the uploads/ directory when you upload a file. You might have to change the maximum upload size.
6. Set up clean URLs like Main/Homepage instead of pmwiki.php?n=Main.Homepage (preferably with mod_rewrite). This is a lot easier than it sounds due to the excellent documentation.
7. Done! Now you can start adding your content.

A few other random tips:

• You delete a page by replacing its contents with the word “delete”.
• Conditional markup is extremely useful to hide content that you don’t want to show yet. Just surround it with (:if false:) and (:ifend:) directives.
• PmWiki’s markup is very flexible. You can easily add CSS classes to elements (see WikiStyles) and create advanced tables (see Table directives).
• PmWiki supports wiki groups. This allows you to structure your pages in namespaces, so you can have for example both a Research.Activities and a Teaching.Activities page.

Finally, here is the result:

All in all, I am very happy with it. I especially like the fact that I can add or change content quickly, wherever I am. All I need is a browser.

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

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:

<p><em>There is embedded content here that you cannot see. Please <a href="http://blog.jozilla.net/?p=239">open the post in a web browser</a> to see this.</em></p>

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.

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.

I usually use Google Scholar to find citations (and downloadable versions of articles), since it indexes the major publisher databases (e.g. the ACM Digital Library, IEEE Xplore or SpringerLink):

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.

A few related guides:
* Research Techniques by Alan Dix (especially the slides about gathering information)
* Reading AI from How to do Research At the MIT AI Lab

Thanks to Lode for having a look at an early draft of this post, and for providing the example of replication in HCI by Shumin Zhai.

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
• override

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!