Summary
Margin marks is a user interface concept that aims to expose microformats on a web page in a way that’s intuitive, useful, and positionally relevant, yet has minimal interaction with the page presentation. This concept can be also extended to emphasize other, typically invisible aspects of the content, such as fragment identifiers, classes and even to letting the users add their own marks. You can go ahead and just look at the pictures if you don’t feel like reading.
Motivation
I’ve been following the thought process of microformats UI in Firefox 3 as documented in Operator‘s
functionality, Alex‘s blog, and uf-discuss list. It’s been exciting to think about the power of microformats and its consumption potential being built into the browser, and as such the decisions about the user interface exposing this power are certainly quite heavy in weight. The greatest problem as it appeared to me was exposing content, marked up with microformats in a way that does not interfere with the page presentation, while at the same time providing comfortable and immediately useful experience for the users. Mike’s current experiment, the Operator, has cool ideas and lots of configurable options, but it still left me wanting something more. Primarily, my holy grail was positional relevance of the consumer user interface to the actual marked-up content. Looking at pages like twitter.com and my own blog comments, I realized that a page with a lot of microformatted content practically begs for positional correlation between the Operator’s
action drop-downs and the page itself. That’s how the margin marks came along.
General Concept
The margin bar is a vertical pane that is shown on one side of the browser window. Whether it’s on the left or on the right may be configurable by the user. The contents of the margin bar are vertically attached to the page, so
that when the page contents are scrolled, the margin bar contents are scrolled as well. Visually, it’s an extra margin to the page that is controlled by the browser, not page presentation (hence, the margin bar). The margin bar can be visible or hidden, as desired by the user. Naturally, open
should be the default state.
The margin bar is narrow, with minimal impact on the width of the browser window. The information provided is hint-like, abbreviated down to icons and perhaps numeric indicators. Visually, it’s a set of glyphs, each positioned alongside the start of relevant content fragment. These glyphs are margin marks. Margin mark identifies vertical position of a content fragment in the margin bar. The mark can be visually presented as an arrow or any other sort of pointer with an icon on it.
Grouping Marks
In situations, when there are more than one marks occupying the same space, the marks are combined into one mark, visually identifying multiple items, together with the number of combined marks. The icon, associated with the top-most mark is displayed.
Mark Actions
Each mark may have one or more actions, associated with it, with one action designated as default. Configuring the actions is part of the browser preferences UI. It is possible that the action may have an icon associated with
it. For instance, if the action is to add event to Microsoft Outlook calendar, the Outlook icon is displayed in the mark, rather than a generic address card. However, this may introduce more confusion, given the diversity of platforms and applications that may be potentially invoked by the users.
Mouse Navigation
When the user hovers the mouse over the mark, the details window is revealed. Moving the mouse off the mark closes the details window. Clicking on the mark invokes the default action. Visually, default action is placed at the top of the details window, so hovering and clicking are intuitively connected: the user does not need to make any further mouse movements to invoke the default action. Hovering the mouse over a group opens the group: the marks in the group are lined up in the bar vertically, allowing the user to explore the marks within the group. Admittedly, this is not very elegant. Perhaps you could come up with a better idea.
Keyboard Navigation
Margin bar participates in the browser chrome tab cycle, preferably placed immediately before the page. Also, there should be a keyboard shortcut to bring keyboard focus into the margin bar. Once the bar acquires keyboard focus, the top-most mark gains it automatically. Then, the following keyboard events are recognized (this list is just a suggestion and food for thought):
- Down Arrow — move to next mark
- Shift-Down Arrow — move to next mark within the group. If at the end of the group, move to next mark
- Up Arrow — move to previous mark
- Shift-Up Arrow — move to previous mark within the group. If at the beginning of the group, move to previous mark
- Space — scroll the page down and jump to the first mark in the visible span of the page
- Enter — invoke mark/note action
- Tab — go to the browser window
- Shift-Tab — go to the previous item in the tab cycle
Aural Presentation
Ideally, when used with a browser that is equipped with voice-reading software,
such as JAWS, the user interaction should occur as follows:
- When the margin bar gains focus, the reader announces:
X marks on the page. Mark One. Type: Address Card. Name: Rulon Oboev…
and continues reading the mark contents
- Using arrows, the user can move between the marks. Upon each move, the reader announces the sequential number of the mark, it’s type and contents.
- After reading contents, the reader announces each action as a link.
- In addition to standard actions, the “Go to content on page” action is added after the default action.
Microformats Marks
Whenever microformat markup is encountered on page, a mark is placed on the bar at the current vertical position of the starting element of the markup fragment. Should the position change as a result of DOM operation or changing geometry of the page, the mark changes the position accordingly. This may be difficult to implement, so an acceptable solution would be to detect detachment (position change) and somehow change the appearance of the mark to no longer “point” to a place in content. Each mark contains a distinctive icon of the corresponding microformat (address card icon for an hCard, calendar icon for hCalendar event, etc.).
When hovered over the microformat data is presented as a complete note, perhaps using a metaphor, relevant to the specific microformat. For example, the hCard could be rendered as a Rolodex card, and an hAtom entry would be probably best presented as a yellow-pad note, a common visual hint of blog post.
Other Types of Marks
One can also easily extrapolate the use of the margin mark to other types of page metadata. For instance, a mark with a feed icon may be placed whenever a feed is encountered on the page. Usually, these would be at the top, but should there be an a element with the type attribute of application/rss+xml, the mark would be placed accordingly there, too.
Also, the marks could be used to provide a UI to unobtrusively identify HTML elements with an id attribute (HTML fragments). Other uses may include tracking a set of user-specified elements, attribute values, or content (mark everything containing “microformats” on the page).
User Marks
It would be really interesting to offer the users to add their own marks to the page, perhaps by clicking (or right-clicking) on the bar, as a way to annotate the page. As the users add a new mark, they can fill in the fields in the provided dialog box. Typically, this would be a simple note (an hAtom entry), but one can envision adding reminders (an hCalendar event), contact information (an hCard), perhaps re-purposing non-microformatted content from the page), or other types of content. After the mark is added, it is persisted within the browser.
Persistently and reliably identifying is a potential challenge of user mark implementation. Since it is not known when or how the content of the page will change upon next visit, a visual equivalent of um.. somewhere around here
may be applied: if the browser can not identify the precise location of the user mark, an extra hint (a question mark, maybe, or a spatial glow/spread to signify uncertainty in position) is added to the mark. When this hint is present, the point line is not displayed.
Other Random Thoughts
Taking one step further brings us to the ability of the browser to communicate with the server when new user marks are added or deleted. Using some simple detection scheme, a browser could recognize that the page accepts mark updates and send newly added marks to the server transparently. An existing blog comment API with some positional extensions could be used or a new protocol could be proposed. I’ll let you figure out what would be best here.
When the margin mark is hovered over or has focus, an additional visual hint could be introduced: a point on the page where the relevant content begins and a horizontal line, connecting it with the mark, like a laser pointer. This could really address the issues of positional relevance.
When the page has more microformatted content beyond the current scroll view, a teaser hint could be shown at the bottom or top of the margin bar (an arrow of some sort?) to indicate that there’s more crunchy markup above or bellow the currenty visible portion of the page.
The margin bar could also have an expanded state, in which it shows details along with the marks. I originally had this in the concept, but I instinctively felt it makes the whole thing too complicated.
Inspiration, Disclaimer, and Licensing
This concept is inspired by the entire super-awesome premise of microformats and the great people around them, by the Alex Faaborg‘s
post on Firefox 3 microformat UI concepts, Mike
Kaply‘s ground-breaking Operator extension, and quite obviously, Jack Slocum‘s blog comment system.
I am not a browser developer and honestly do not know how much effort would it take to implement something like this. I did take a brief stroll in a Mozilla trunk and soon realized that one cannot evaluate implementation feasibility by just taking a brief stroll through the code of a browser. I am positive this can be done completely in Javascript, and thus assume that the feasibility is pretty high.
Should anyone find this concept, in full or in parts useful, inspiring, and/or worthy of implementation, I release it as public domain. I think that it would be awfully splendid of you to mention my name, even if somewhere deep in the comments of your shiny new toy. Or maybe bake me a low-carb cake. Or a MacBook Pro. But I won’t insist.