Archive for the ‘web’ Category

Mojo at Rojo

Thursday, March 16th, 2006

I’ve been working really hard building our new Mojo feature at Rojo. Adding Mojo to stories in Rojo is a convenient way to show the world news that you like.

I’m especially excited because we’ve really “kicked it upstairs” for this feature with a new back-end architecture that we designed to make our mojo extremely snappy and scalable.

Here’s a screenshot showing this story’s mojo count in the upper-right corner. Just click it to add your mojo to any story. The first person to add mojo to each story gains a little bit of “microfame” (the link in the bottom right corner).


Acid2 Test

Wednesday, November 2nd, 2005


I am pleased to see that this kind of black box testing is out there for browser compatibility standards. This Acid2 test reminds me of the “Machine Problems” we had to do in Computer Science at the University of Illinois, where we had to match our output byte-for-byte to a reference implementation.

Recursive Mofo-blogging

Friday, May 27th, 2005

Kevin took a photo of us having a Rojo team lunch and blogged it from the restaurant with is Treo. When the story popped up in my Rojo reader after lunch, Kevin recursively mofoblogged that too. So I thought I’d better add another level to the recursion stack and blog him doing that:


Paper Airplane 0.1.1 Released

Sunday, February 6th, 2005

My friend Brad Neuberg has put out an alpha version of his Paper Airplane project. Talk about a cool project, Paper Airplane lets you create collaborative wiki sites with arbitrary top level domain names through a P2P DNS, and then serve them up through NATs and firewalls. Nice work Brad.

Foglog 0.1.1 Released

Sunday, February 6th, 2005

Foglog 0.1.1 is released!

I created Foglog for my own photo organizing and publishing needs, and am pleased to offer it to the open source community.

Foglog is a web based photolog hosting system built on top of a web-accessible, lightweight digital image repository. Foglog achieves both hosted photo publishing and archival quality private collection management from a single repository. This eliminates the need to upload an arbitrary subset of your work (as well as low resolution copies) into a separate photo blogging tool. All the work that you invest in your photo collection (organizing, categorizing, rotating, etc.) will immediately be reflected in your published photos as well.

My example installation of Foglog can be seen at

Foglog operates in two modes, public browsing mode and private management mode. The public sees a published photostream and can browse public photos by date, set, tags, and by individual permalink. When logged in as the owner of the photos, management features are available to browse, rotate, tag, organize sets, and publish photos. Additional admin features include viewing photos by popularity and graphical access logs by session.

The target user is an individual photographer who would like to share photos and photoblog.

Foglog is written in Python, and uses Apache, MySql, and netpbm. It currently runs on Debian.

This is an alpha-level release, but still has basic photo hosting functionality. Please give it a try and tell me what you think.

Lunch with Rojo

Friday, January 7th, 2005

Rojo is hosting a lunch:

We are hosting a lunch with a select group of Rojo users at our offices in San Francisco on Wednesday, January 12th at noon. If you’d like to participate and help Rojo be the best it can be, please let us know by emailing us at Space is limited and participation is by RSVP only.

The Danger of Losing Context with XFN

Friday, December 31st, 2004

As I re-posted Robert Scoble’s geek dinner attendance list, I noticed that he included XFN notation in the links. When I re-posted the links, I made sure to edit all of the rel attributes to reflect my own relationships. But I could imagine that someone who uses a tool to copy links or simply is not yet aware of XFN might copy and paste them without realizing that s/he was specifying accidental semantic web relationships.

Those rel attributes convey one-way relationship information; from the owner of the containing page to the owner of the link. XFN tools must infer that the originator of the relationship is the owner of the page in which the link exists.

Since one half of the relationship is implied from the context of the containing document, there is a danger of misrepsenting relationship information by decontextualizing (re-posting) links that contain rel attributes. This problem would apply to any use of the XHTML rel attribute.

Maybe this won’t happen much, but I wonder if we can come up with something to help keep the XFN network from being corrupted by such decontextualization.

DHTML is Growing Up

Thursday, December 30th, 2004

Brad Neuberg recently spotted a programmer in a coffee shop hacking on a DHTML application. There have been quite a few DHTML sightings lately, making me believe that DHTML is finally coming of age.

Dynamic HTML is not a specific technology but rather a technique of creating rich internet applications by augmenting static HTML with client-side scripting and style definitions. In practice this is often done with HTML, JavaScript, and CSS.

There are various other frameworks for rich internet applications, such as Flex and Laszlo, but they have not gained popularity; perhaps this is because they rely on Flash as a 3rd party browser extension. Since DHTML relies only on Javascript and CSS, which are now both widely supported in modern browsers, DHTML should be clear for take off.

So what is the holdup? The biggest gotcha with using DHTML is having to wade through the qaugmire of browser incompatibilities in their support for Javascript and CSS. Javascript-based DOM methods in one browser might not have the same effect in another browser. Also, the lack of cross-browser CSS support creates a large amount of developer consternation.

Some folks are working to fix the mess. The open-source x library encapsulates all the DOM incompatibilities by creating a browser-independent javascript API for DOM manipulation. On the CSS front, Dean Edwards has taken the approach of “leveling the playing field”; his cheekily-named IE7 project is a complex layer that makes Internet Explorer behave in a CSS compliant way.

These kinds of grassroots efforts are typical with DHTML, because unlike Flex and Laszlo, DHTML has no standard libraries or toolkits. In fact, the community has been re-inventing DHTML tools for years without coming up a standard cross-browser DHTML solution.

Things have come a long way, however, and the frontiers are now being pushed with DHTML. Mihai Bazon of Dynarch, for example, has produced some really slick DHTML menus and other widgets; I even found myself right-clicking on them to convince myself that they were not actually coded in Flash.

DHTML seems to work best when applied lightly and transparently, avoiding the worries of rich internet applications. Some of the best uses of DHTML are when you don’t even realize that it is DHTML, such as Google’s GMail. I believe DHTML is least effective when used in an attempt to make a web application look like a desktop application.

With all these cool new techniques, DHTML can also bring a few annoying possibilities, such as DHTML pop-up ads. Many users have been switching to security conscious browsers and otherwise blocking ads that pop up in separate os-native windows, but DHTML pop-ups are a whole new way to get your attention. The first time I visited this Time Magazine story, I was barraged with two (annoying but harmless) DHTML pop-up ads.

As more DHTML libraries and widgets are released with open-source licenses, it seems more likely that DHTML will continue to gradually enrich web applications enough so that the adoption of a separate RIA framework like Flex or Laszlo might no longer be necessary.

I’ve been Rubhubbed!

Wednesday, December 29th, 2004

“That’s great! Actual physical contact! Can you move?”
“I feel so funky

Rubhub, the XFN Aggregator, finally indexed my XFN Friendly blog. Last month I wrote a post XHTML Friends Network. Inside that post, I included some links with xhtml rel attributes (with values from the XFN spec) to specify my outgoing relationship to various people. After that I visited rubhub and added my site to their aggregation list. Now, rubhub has indexed some of the relationships that I included in the post and in my blogroll. For some reason though, it only picked up 3 out of the 8 distinct links I had adorned with XFN rel attributes.

Representational State Transfer (REST)

Thursday, December 9th, 2004

REST (REpresentational State Transfer) describes an architecture style for networked systems. It also happens to be the underlying architectural model of the Web. Roy Fielding coined the term in his PhD dissertation.

The basic characteristics of a REST system are:

  1. Client (browser) and server
  2. Stateless Interactions
  3. Cacheable Resources (using Meta info)
  4. A uniform interface (HTTP)
  5. Named resources (URIs)
  6. Interconnected resource Representations (a href)

So, the web is already a RESTian system. The parenthetical information after each item in the above list shows how the current Web satisfies that design principle.

The idea of making a RESTian system is to see it as a data resource manipulation problem. To sum up the REST Best Practices from a presentation by Roger L. Costello:

  1. Expose a URI for each resource
  2. Use logical URIs (not physical)
  3. Use nouns in the URIs (not verbs)
  4. Use the / in URIs to represent parent/child relationship
  5. Minimize use of query strings
  6. use GET for resource representations (not POST)
  7. Make all HTTP GET requests side-effect free
  8. Include links in responses, gradually unfolding information.

Strong proponents of REST such as Mark Baker purport that it is a natural tendency for document oriented systems, because documents are in fact state.

From an article by Paul Prescod:

The best part about REST is that it frees you from waiting for standards like SOAP and WSDL to mature. You do not need them. You can do REST today, using W3C and IETF standards that range in age from 10 years (URIs) to 3 years (HTTP 1.1).