« The rural, backwards Northwest | Main | IDEA 2006 »

May 23, 2006

Reading user interface libraries

Google recently released the Google Web Developer Toolkit (GWT). Javascript web development frameworks are nothing new, but we’re starting to see more of them from the big players (Microsoft, Yahoo, now Google.) While on one hand, they’re “just code” that’s either fast or slow, extensible or closed, or standards-compliant or not; I can’t help but look at these as texts that reflect their developers’ values, even their corporate owners’ values.

Here’s how Google described their latest:

Google Web Toolkit (GWT) is a Java development framework that lets you escape the matrix of technologies that make writing AJAX applications so difficult and error prone. With GWT, you can develop and debug AJAX applications in the Java language using the Java development tools of your choice. When you deploy your application to production, the GWT compiler to translates your Java application to browser-compliant JavaScript and HTML.

Some of the features of GWT do sound impressive: built-in support for the browser Back button and page history, a combination of layout controls and UI widgets, and good cross-browser support. What do you have to give up to use the GWT? Well, you have to be a Java programmer (and also not a Mac user GWT does work on the Mac, though it’s unsupported), so don’t bother, you PHP or Ruby people. And you have to hand over your client-side code entirely to the compiler. That’s an approach that makes it fairly nasty to integrate with other client-side libraries. In fact, the almost unstated assumption is that you don’t want to get your hands dirty with Javascript or HTML: just let the toolkit handle all that junk! This is very similar to Microsoft’s ASP.NET, an architecture that seems built primarily around the assumption that you’re dragging and dropping components together in your IDE. At every turn, the developer is reminded she is too good, too busy, and too smart to demean herself by actually touching HTML or Javascript.

A glance tells you the GWT lacks style and refinement. The GWT widget demos don’t just look programmer-designed, their benefits are entirely directed at the developer, not the end user. “Lay out Widgets automatically in Panels. Send your Widget to other developers in a JAR file.” The GWT e-mail client example (which is snappy) is deeply ugly. The “kitchen sink” example simply groups UI elements into one hideous tabbed pile; it’s not even a component library. (Kitchen sink presentations can have their place: check out the excellent Flex style browser.)

The GWT is Google all over: functional, technically impressive, but generally lacking in taste. If they never iterate it again, that’ll be the real proof, ha! Which is not to say I don’t appreciate their products, the quickness and capaciousness of Gmail, or the responsiveness and flexibility of Google Maps—I happily use these several times a day. But there’s no poetry to these applications, they don’t sing. Actually, despite its clunky interface, Google Earth, one of the products they didn’t develop, does have a sort of spectacular Romantic poetry to it. I mean, that thing is Caspar David Friedrich 2.0, isn’t it?

Compare the GWT to Yahoo’s Yahoo User Interface library (YUI). With YUI, it’s assumed you will write some Javascript by hand. But more significantly, it’s assumed that you care about user interface design patterns, not just UI widgets, that you care about basic visual design principles like grids and white space, and that you care a lot about how things work across browsers. Yahoo’s design pattern examples are visually attractive and inviting, the benefits pitched at designers and to users. The Invitation pattern can be used when the “Designer needs to cue the user about what will happen if they click the mouse on the hovered object.” And for developers, some of their code, sings too. (Another difference: Yahoo’s code has named authors.)

Thomas Vander Wal writes today:

Yahoo has the components in place today to build on top of and make it [the Personal Infocloud] happen. Google is not only lacking the structure, but they are not executing well on their products they produce. Google does the technically cool beta, but does not iterate and fix the beta nor are they connecting the dots. Yahoo on the other hand is iterating and connecting….

His conclusion is dead on:

Google is a technology company that is focussed on some hard problems, but it has to focus on solutions that people can use. Google aims for simple interfaces, but does not provide simple solutions or leaves out part of the solutions to keep it simple.

Tom’s not the first to point this out (see this Economist article), but he really nails it: where Google focusses on the problem, Yahoo and (bizarrely) Microsoft focus on the person.

(Update: In a follow-up to my post, Thomas makes some good points about where the GWT might work well that I hadn’t thought of.)

Posted by Andrew at May 23, 2006 10:00 PM

Trackback Pings

TrackBack URL for this entry:
http://www.heyotwell.com/cgi-bin/mt/mt-tb.cgi/122

Comments

Why Google isn’t customer-centric: http://genuineincorporated.com/2006/04/06/pride-goeth-before-a-fall/

Posted by: Jordan at May 24, 2006 01:05 AM

I riffed on this post over on my blog in the post titled Developing the Web for Whom?.

Posted by: vanderwal [TypeKey Profile Page] at May 24, 2006 12:06 PM

Your treatment of GWT is entirely unfair,

you said that it doesn’t allow you to write your own javascript,

It does.

you said that it doesn’t allow you to style your objects,

But it very much does, one is absolutely not limited to the styles that come in the demos. GWT uses native browser components, so anything is easily theme/stylable with CSS, you do know CSS, right?

as to writing HTML, you can write your whole page in html, give IDs to elements that you want to put GWT widgets into, and have your GWT script search for those elements and place the widgets there.

You didn’t read a line of the code, did you?

Posted by: Professional Developer at June 20, 2006 09:32 PM

I’m glad you pointed these things out. No, I didn’t read any of the code, partly becuase I’m primarily a designer, not a developer. But part of my point was that google pretty much only offers the GWT as a tool for developers, where I think Yahoo considers a much larger ecosystem of developers, designers, and users.

I’m glad that GWT doesn’t lock up styling and Javascript entirely. That information isn’t mentioned on the GWT’s site; in fact they strongly suggest the opposite: they imply you don’t have to write Javascript at all, which I think is a misguided thing to encourage.

What I’m worried about is that the GWT’s pitched a lot like ASP.NET, which in my experience (yes, I worked a lot with ASP.NET) is a terrible environment for producing good web applications. Although I’ve known developers who like ASP.NET a lot, its widgets and constraints are in most cases really really awful. It’s a bad citizen of the web.

I look forward to seeing stuff built with the GWT that’s clean, responsive, standards-compliant, and attractive. Please let me know if you’ve seen (or built) anything like that!

Posted by: Andrew at June 20, 2006 09:55 PM