Closer To The Ideal

Obviously I’m biased, since I’m trying to do a start-up in New York, but everything about this rings true:

Tumblr and Posterous are the two most prominent “tumblogging” sites, i.e. sites that make blogging more straightforward by making it easier to post media. Both were launched within six months. (Actually, Posterous was started later than Tumblr.)

But now Tumblr has been an Alexa Top 100 site for a while and is still growing strong. Meanwhile Posterous has about 4 times less uniques. Yet Posterous has everything to win: it’s a Y Combinator company with top-tier investors like Chris Sacca and Mitch Kapor. Its founders are experienced software engineers with computer science degrees from Stanford. How come it’s eating dust from a small startup started by a high school dropout?

The answer is as easy as it is counter-intuitive: Tumblr is a New York company and Posterous is a Silicon Valley company.

Or, to put it another way: Posterous is an engineered product, while Tumblr is a designed product.

Posterous is extremely well engineered. There’s nothing wrong with it. Every single thing about it is well thought out. But it’s not just that it’s less pretty (though it is). It’s just not designed as well as Tumblr is.

…In fact, everything about Posterous is nice. It’s very nice. I’m not here to bash Posterous, I think it’s a tremendous product and I wish them the best of luck.

But everything about Tumblr is better designed. I used the landing page as one example, but there are tons of features where Tumblr shines by its gorgeous design.

Meanwhile Posterous is typical of the Silicon Valley engineering mindset where everything is measured, ranked, weighted. It’s like Google. And having terrible design like Google is great if you have a technology edge. But if you’re in a market where what matters is design edge, that’s not enough. There needs to be great design, by which I don’t mean looks (though they’re important), but how it works for the end user.

…The first is that New York has truly come of age as a startup hub, with its own “style”, its own way of doing things, its own mindset, which can sometimes — not always, but sometimes — kick Silicon Valley’s ass.

Rondam Ramblings advocates generating websites from a programming language, rather than having anyone hand code the HTML:

IMHO, no one should ever write any HTML by hand. HTML should be considered exclusively as object code, except for the most simple of quick-and-dirty hacks. The idea that HTML can (or even should) be considered source code is the root of many evils on the Web. The right way to create web pages is by building higher-order abstractions in a programming language (preferably functional ones, but I’m not dogmatic about that).

Nowhere is this clearer than when it comes to forms. Even CSS advocates concede that it’s OK to put form elements in tables. They say it’s because “forms are a kind of tabular data, and that’s what tables are for”, but this just begs the question of how one can tell if a particular set of data is tabular or not. (Apparently, the criterion is: it’s tabular data if it’s completely hopeless to make it not look like crap when layed out with CSS.) But the trouble with forms goes far beyond layout.

This makes design lead development impossible, assuming that the designer does not know the programming language being used. Rondam wants to make a distinction between the source code that one would write in the C language and the object code that a complier would generate from that source code. Since people do not usually argue over the object code that a compiler generates (no one but a compiler writer should care), then (according to Rondam) no one should care what kind of HTML is generated by the software that you create.

Of course, the assertion that HTML should be the object code generated by a compiler falls apart when you are doing design lead development. With design lead development, there is no question that the HTML is the source code that everything else depends upon.

As to why design lead development is important, there are the old arguments: an experience rich design produces good results with users which makes them enjoy using your service, and therefore they come back to use it more.

Someone I’m working with asked me to look at SlideRocket, to see if we should be using it. SlideRocket describes themselves like this:

SlideRocket is online presentation software that provides for every part of the presentation lifecycle. SlideRocket integrates flexible authoring, intelligent asset management, secure delivery and analytics tools in a single on demand application. SlideRocket allows you to quickly create stunning presentations, store, organize, tag and search your assets, collaborate with your colleagues, securely share your presentations in person or online and measure the results, all in one integrated environment.

If you listen to their video, they talk about how great it is to have all of your assets on the web (or the “cloud”, as they prefer to say), so you’ll never run the risk of forgetting it at home.

One thing that occurs to me is how similar this is to what Phillip Greenspun was describing in 1999:

Interesting things can happen when you do something as simple as move an application from the desktop to a server. For example, at a small company once we had the idea of building a server-based replacement for PowerPoint. We wanted something simpler that we could edit from any Web browser. Once the slides were in the database, however, we realized that this could be used for collaboration. User A could authorize User B to edit a presentation and the two of them could authorize User C to give that presentation at a remote site.

Only after talking to people from PowerPoint-oriented organizations did we realize how revolutionary the system, which we called “WimpyPoint”, could be. Suppose Jane Executive went on vacation for three weeks. Upon her return she wouldn’t have to start calling colleagues to find out what had been going on; she could look at the WimpyPoint server and ask to see all presentations created within the last three weeks. When all the work of an organization is presented within PowerPoint it is a terrible waste to have that work locked up in monolithic files.

Once again, I am impressed with how clearly Phillip Greenspun understood the Internet, earlier than most other people did. He foresaw the declining importance of desktop apps:

What people need and, with the ubiquitous Internet, can finally get, are collaborative Web-based applications. Web-based apps let people use computers without becoming mired in system administration. Web-based apps help people collaborate. Web-based apps can weave an individual’s contribution into a larger work produced by many people over the decades.

The future is WimpyPoint, not PowerPoint.

If Web-based apps are so great, why aren’t we all using them now? Desktop apps serve one user at a time and tend to be copies of systems from the ’60s and ’70s. Web-based apps serve thousands of users simultaneously and oftentimes are based on completely new service ideas. Thus Web-based apps require programmers with great skill, imagination, and taste.

If Greenspun’s thinking has a fatal flaw, it is the relentless way he discounts the importance of visual information. He is one of those people who has a strong preference for text. There is nothing wrong with that, of course, but he consistently mistakes his personal preference for some kind of universal truth about communicating information:

You’re building a database. You’re modelling data from the real world. You’re going to have to write computer programs in a formal language. You have to design a user interface for that computer program. If you had an MBA then your natural first step would be . . . hire a graphic designer. After all, this computer stuff is confusing. Databases frighten you. What you really need is something that will look good at your next meeting. Graphic designers make pages that look good. You can always hire a programmer later to actually make the forms work.

…If you despair of learning how to do anything productive, what you might have learned from this chapter is that you should work with the programmer and user interface designer to build the site that fits your publishing model before bringing in a graphic designer to make it pretty.

This particular joke (that all graphic designers are stupid) pervades Greenspun’s work. I find it about as funny as I find “All women are dumb” or “All blacks are lazy” type of jokes. The history of innovation reveals this as a reliable pattern: those who understand the importance of a new technology often have some blindspot that keeps them from being the one who fulfills the potential of the new invention.

What Greenspun offered is an example of extreme minimalist design. It is functional, but confusing. He seems to have thought that if a page was minimalist enough then its purpose would automatically be clear. Any talented designer can explain the problems with that kind of reasoning.

SlideRocket offers some things that were less practical back in the 90s. The spread of broadband Internet connections allows people nowadays to expect video and other rich media. This could be described as the Web 2.0 version of WimpyPoint, but I assume Greenspun would disagree with the comparison. SlideRocket is built using Flash/Flex/Air. Greenspun was extremely critical of Flash. I assume he has been surprised (as I was) to see Flash evolve into Flex, which is, after all, a reasonably solid programming environment.

Still, SlideRocket strikes me as the modern version of what Greenspun had begun to see 10 years ago: the movement of presentation software to the web. I think it is curious how certain ideas (forums, email, chat) keep getting re-invented, over and over again, every few years, and yet, these re-inventions keep offering some real (if incremental) innovation, something that updates the basic idea and brings it into conformance with all that is now known, all the best practices that our growing experience with this new medium allows us to understand.

I’ve had the good fortune to work with some truly great designers. These are people who are understand the client’s needs, who understand the users, and who naturally develop web sites that feel intuitive to the people who use the site. Long ago I learned that, when working with such designers, it was important to empower them with the code they needed, but to otherwise stay out of the way. In particular, such designers need access to the HTML of the site. When I hide the HTML away inside of PHP functions, I’m limiting the ability of these maestros to perform.

This has implications when working with a framework like Symfony.

A lot of computer programmers would add an image to a Symfony template by using one of the image helpers:

<?php echo image_tag(’banner.jpg’) ?>

But what if the designer needs to add a CSS class to this? What if they are working late at night, and they are unable to reach me? Or they are working in the middle of the day, but it is a day I’m spending away from my computer?

The designers I work with can read PHP code fairly well. And they can look up the image_tag helper and figure out its syntax. But this is a big waste of their time. It takes them further into the world of programming than they should need to go.

When creating URLs in a Symfony project, it is important to use helpers. The helpers take care of figuring out what the right URL should be for things like images. The helpers allow us to develop on one machine and deploy to another server when we go live, and even if that other server has a completely different directory structure, we don’t need to change any links, because the helpers take care of all that for us. However, managing the URLs is the only thing that the helpers should do.

So we do not do this:

<?php echo image_tag(’banner.jpg’) ?>

Instead we either do this:

<img src=”<?php echo $sf_request->getRelativeUrlRoot() ?>/images/banner.jpg” />

or we do this:

<?php sfLoader::loadHelpers(array(’Url’)); ?>
<img src=”<?php echo public_path(’banner.jpg’) ?>” />

This way the URL is managed by Symfony’s helpers, but the rest of the IMG tag is still free for the designers to work with. If a designer needs to add a CSS class, they don’t need to call me on the phone and get me to do it, and they don’t have to start researching Symfony helper tags, instead they just add the CSS class like they always have:

<img class=”header” src=”<?php echo public_path(’banner.jpg’) ?>” />

This is an important bit of project management. It allows for a correct separation of concerns – the designers get to focus on design, and the programmers can focus on the programming.

One of the tough calls to make, when managing a project, is figuring out how much time should be devoted to talking things over. If you are the manager, there are two mistakes that you might make:

1.) You cut off conversation too soon, before the designer has had a chance to defend their idea, or before the client has had a chance to fully articulate their dissatisfaction, or before your programmer can explain why one option would take more time, and therefore more money. You force a decision to be made before all the facts are in. Possibly you kill the conversation just as people are warming up to what would be a brilliantly creative set of insights, if only you allowed more time.

2.) You allow the conversation to go on too long. After awhile, people begin to repeat the same points they made 4 hours before, or perhaps the day before. Your team begins to fear these conversations, which seem to be endless swamps of unproductive debate. The team craves action, decisions, movement, they want to finally be building something, but instead you keep pushing for more information, another round of opinion gathering.

It is difficult to find the right balance. I suspect we all have our preferences about what we consider the right level of conversation versus action.

Over at 37 Signals they’ve posted an extended chat that Jason Fried and Ryan Singer had about adding a new feature to Basecamp. It is useful to see how such a well known and successful team works through their design issues.

(14:42:41) Jason Fried: What are some of the pushback points we’re anticipating?
(14:43:02) Ryan Singer: “i use milestone attachments for [some crazy custom reason] and this doesn’t apply to me”
(14:43:30) Ryan Singer: possibly: “i want dates on my to-do items, not the lists themselves”
(14:44:12) Ryan Singer: i don’t think the first point is a problem
(14:44:18) Ryan Singer: there are always people who bend the interpretation
(14:44:51) Jason Fried: What if the date thing said “On or before March 14”
(14:44:59) Jason Fried: I think the ridigness of it may be a problem.
(14:45:03) Jason Fried: And this could soften that a bit
(14:45:05) Ryan Singer: a bit long, but i like that idea
(14:45:52) Ryan Singer: hm kinda long
(14:46:08) Ryan Singer: becomes harder to interpret too

I know that in such conversations I tend to defer to the designer, and I tend to want to reach a conclusion quickly. Probably because I’ve been in so many, many meetings where someone else forced the conversation to go on for many more hours than was needed, I tend to play the role of the person who is willing to reach a quick agreement. Ryan Singer reminds me of myself, in this portion of the chat, where he seems willing to go along with the “Due by” language, even though he initially disliked it. He seems eager to reach a final agreement.

(14:46:35) Jason Fried: After seeing this the issue I have is the rigidity of it.
(14:46:42) Jason Fried: This list IS DUE on this date
(14:46:45) Jason Fried: Well, not really
(14:46:57) Jason Fried: It’s part of a milestone that is due on this date.
(14:47:07) Jason Fried: So I’d like to see if we can figure out how to present that reality a bit better
(14:47:15) Ryan Singer: good point
(14:47:18) Ryan Singer: ok
(14:47:41) Jason Fried: how about
(14:47:47) Jason Fried: “Due by 14 February”
(14:47:49) Ryan Singer: “Milestone: 14 February”
(14:48:03) Ryan Singer: nice that Due by is shorter
(14:48:05) Jason Fried: Milestone may work. Ties it into the feature.
(14:48:07) Ryan Singer: shorter is better for this flag
(14:48:12) Ryan Singer: even “Milestone: 10 Feburary” is quite long
(14:48:13) Jason Fried: Due by is less rigid than “Due on”
(14:48:15) Ryan Singer: doesn’t hold together as well
(14:48:16) Ryan Singer: yeah
(14:48:37) Ryan Singer: Due by looks pretty good. screenshot coming

But Jason Fried won’t be rushed into a decision. Instead, he keeps the conversation going, even though Ryan Singer was willing to go along with “Due on”.

(14:55:14) Jason Fried: Due is good, but it’s an opinion 5 years after the fact.
(14:55:20) Jason Fried: That’s why I’m pushing back a bit.
(14:55:30) Jason Fried: We’re not introducing attachments today
(14:55:37) Jason Fried: If we were I’d feel better about it.
(14:56:15) Ryan Singer: i think if we don’t go with “Due..”
(14:56:26) Ryan Singer: it would be better to explore moving the link below the title into the list description area
(14:56:30) Ryan Singer: and actually naming the milestone or something
(14:56:41) Jason Fried: right like…
(14:56:54) Ryan Singer: like “For Ship v1 of the Home Page, 14 Feburary”
(14:56:57) Jason Fried: “This to-do list is attached to a “milestone name” which is due on 14 Feb”
(14:57:23) Jason Fried: I feel like we don’t lose anything with that direction.
(14:57:27) Jason Fried: And we gain clarity

If you read the whole transcript, you can tell these two are getting warmed up as the conversation continues – they are thinking hard about this problem, and they are getting deeper and deeper into the nuances. I relate to this chat quite a bit, as it reminds me of so many of the more productive meetings I’ve been in.

Finally, an hour goes by, and Jason Fried keeps pushing them until they arrive at what they both agree is the perfect answer:

(15:20:08) Jason Fried: In the app we say “Attach to…” so I wonder if we should repeat that here.
(15:20:18) Ryan Singer: i would rather change the language in the other places
(15:20:23) Ryan Singer: “Attached to” looks weird here
(15:20:28) Ryan Singer: and it doesn’t fit with the normal expectations of what an “attachment” is
(15:20:36) Jason Fried: K. We don’t want to change the language elsewhere so we’ll consider that one a no go.
(15:20:39) Jason Fried: Umm…
(15:20:46) Jason Fried: “Related to” works for me.
(15:20:47) Jason Fried: Cause it is.
(15:20:51) Ryan Singer: actually the edit dialog says this:
(15:20:55) Ryan Singer: “Does this list relate to a milestone?”
(15:20:58) Jason Fried: Perfect
(15:20:59) Jason Fried: Done
(15:21:02) Ryan Singer: done

The often interesting robert hoekman, jr:

Our Stories should be an experience rich site. It should offer an engaging environment that compels users to explore and connect emotionally to the storytellers. But it doesn’t offer this at all. Instead, it offers what looks like any other Google design. It’s plain, minimalist, and it’s focused entirely around the information and not the experience.

Google apparently thinks it has hit upon the secret formula to all successful websites – simple, minimalist designs that offer information in a concentrated form. In reality, this formula only works for certain classes of sites, of which the original Google website was the par exemplar. Google fails when it attempts to build a site that needs a philosophically different approach. As Hoekman explains:

 If Google’s goal here was to create emotional connections, they should definitely have considered something other than the business-as-usual, sterile design work that has become Google’s signature. Granted, some of the site’s pages are geared towards showing people how to conduct interviews for the site, and those pages are probably best left alone, but the main attraction here is an environment of storytelling, not another Google search results system.

…Design is meant to communicate content. With the right design, you can always meet your goals much more effectively. If you want emotional connections, design something that encourages them. If you want people to take action, design to encourage action. Don’t let your usual design style get in the way of doing something great.