Project Ideas

A number of people have asked for suggestions for project ideas. I've put together this list of possible ideas, including projects that people have done in the past. Please don't consider yourself limited to just these ideas--you're welcome to come up with cool UI techniques on your own. This list is just meant to convey the scope and scale of what we're looking for.

In general, good project ideas will represent a solid chunk of implementation work (for the grads the project replaces the final three undergrad homework assignments, so think at about this scale).

It'll hopefully represent a novel interaction technique, or at least a novel application of an existing interaction technique. For example, just reimplementing Pie Menus is not very novel, since it's been done tons of time. But creating an interesting (and well motivated!) variation of Pie Menus might be acceptable.

Here are some projects that have been done in the past, as well as potential project ideas from the TAs and myself. Please note that the project requirements may have changed somewhat from previous years. For example, not all of the projects below may have the "use one topic from the second half of class" requirement.

• A set of Magic Lenses for web browsing and development. For example, these might allow "see through" web browsing (allowing you to preview links through the magic lens), or letting you see the underlying page structure (you pass a lens over rendered content and see the underlying markup, or vice versa), or allow you to do content editing or image tweaking through the lens.
• Creation of a toolkit and associated interaction techniques for two-handed input in games. This might allow, for example, two mice to be used at the same time with independent cursors. You'd also have to use this system to come up with some interesting interaction techniques such as components that respond to multiple inputs, applications in collaboration or competition, etc.
• A layout management framework for Macromedia Flash development.
• A system for "remoting" a user interface. In other words, a way to have an application running on one platform and display its UI on another system across the network. This could involve retargetting the UI (translating it so that it works better on a PDA or phone, for example), or could deal with issues such as latency or possible disconnection.
• Speech UI toolkit, allowing existing Swing components or applications to be controlled using speech, and with speech output. This could include techniques such as "barge-in" (allowing speech synthesis when user speaks), visual cues, etc.
• Create a "context call" application that allows you to see the context of another party before you place a cell phone call to them.
• Create a new UI toolkit for use on J2ME phones.
• Create a hybrid constraint system implementation, expressing multi-way constraints as collections of one-way constraints.
• Cheating Fitts' Law: Create an interaction technique that determines potential mouse targets and resizes them to achieve better performance. Magnification might be determined by the speed of the cursor and direction of cursor movement. Something like this should work within the context of an existing UI toolkit, such as Swing.
• Create a system that automatically creates web front-ends to Swing UIs. You might create a special "container" class into which you put arbitrary applicatons; the container would intercept Swing drawing requests and turn them into web output, and would also take input on the web site and use it to drive the application.
• Create Debugging Lenses for Swing, a la the Hudson and Smith paper. Or, alternatively, you might explore other debugging/development tools that tap into Swing to allow you to expose and manipulate thie hidden GUI structure and debugging information in context.
• Create a WhyLine for Swing, a la the Myers paper.
• Implement a range of new interaction techniques to "beat" Fitts' Law in normal Swing applications: Jumping Menus, Force-Enhanced Menus, Force-Enhanced Buttons (basically using semantic snapping to create a set of new Swing components).
• Create a set of alternative input methods using accelerometers to control Zooming User Interfaces.
• Create a constraint-based layout manager for Swing.
• Create a set of input devices using piezo-resistive foam and use these to develop a range of interaction techniques for a particular domain (for example, music playing).
• Develop a set of extensions to the desktop interface, such as in the videos we saw earlier in the class (such as in the Bumptop videos or the work of Michel Beaudouin-Lafon ). (You could do these inside a Swing DesktopPane rather than having to write platform-native code.)
• "Fitts' Calendar" -- a calendar Component that uses semantic snapping and dynamic scaling to have better Fitts' Law properties
• Hierarchical Pie Menus that meet the standard Swing menu interface, and can serve as drop-in replacements for Swing menus
• Animation toolkit for Swing, supporting various techniques discussed in class (slow-in, deformation of objects, etc.), and effects such as movement, fades, opacity changes, etc.