Despite the initial let down, I decided to stick with it for a week, and try to use it for different tasks where I would normally use e-mail, instant messaging, or a wiki. The result?

I love it, despite a couple of rough spots.

The experience that won me over was working with a client on requirements for extending their web application. This is the sort of work I do every day — collaborating with people to determine how and what we’re going to build for them. It’s an organic process, involving considerable back-and-forth discussion and documentation of expectations, assumptions, dependencies, time, and money.

Our approach with Google Wave was to make the leading message the canonical requirements document, with the subsequent messages serving as reference and justification for how and why we made the decisions.  It worked well.

The main thread principally contained questions — we kicked off the session by writing out our initial thoughts and questions into separate messages. Then we regrouped and collaborated on answering those questions in their own threads. When we reached a decision, one of us would record it in the leading message at the top of the wave, while the other gardened the discussion to remove tangental points and highlight the important bits.

It was a fairly intense process, and took a couple of hours to flesh out a fairly complete requirements document for the features we were mulling over. The session was long, but it undoubtedly required less time than if we had followed the usual phone + email + meetings + instant messaging strategy to achieve the same result — and it was easier to reference the original conversation points for how we made our decisions.

The icing on the cake is that we were able to share the discussion with our Wave-enabled colleagues, allowing them to trace our decision making process, and follow up with questions and concerns of their own.

So, I’m sold. I think Google Wave is a useful and practical tool for resolving and documenting complex processes in the real world, and beats the pants off of the traditional multi-channel approach of phone calls, e-mails, instant messages, and wikis.

But, like I said, there are still some rough edges.

The biggest problem is that not everyone has access to Google Wave. Invitations are scarce, and this poses a frustrating Catch-22: People won’t use Google Wave for important documentation and communication until it’s ubiquitous, and it won’t become ubiquitous until everyone wants it for important documentation and communication. Fortunately, I think this is temporary. Google is opening up the invitation spigot a little more every day, and when the source code is released for public consumption, we’ll all be free to set up our own Wave servers.

That said, once you have access to a Wave system, you’ll still have to deal with the learning curve. It’s similar to several tools we already use for online communication, but it’s a fundamentally different beast, and most people will have to thunk around before that “ah hah!” moment arrives. That’s particularly frustrating in a limited, invitation-only environment, where you may not be able to connect with people for meaningful discussions.

All things considered, I think Google Wave is a big step forward in online communication, and has the potential to be a huge win for Google. I can honestly say it has provided real world value for my clients, myself, and my employer. Wave has taken a prominent place in my communication toolbox, along side e-mail and instant messaging. I hope it stays there, and I’m looking forward to the time when I can connect with all of my friends, colleagues, and clients.

Who else has had the opportunity to use Google Wave in a production environment, to solve real world problems?  I’d love to hear how it succeeded or failed, and what techniques other people are using.

PS: If you’re already on board, send me a wave at peatbakke@googlewave.com!

Think of it this way:  SimpleDB is a big hash of hashes that’s web accessible.  That’s basically it.  You get to store arbitrary sets of key-value pairs, each with it’s own unique identifier, in a big bucket in the sky.

Huh.  Interesting.  So where would you use SimpleDB instead of a traditional relational database?

There are two things that SimpleDB handles incredibly well: concurrency, and accessibility.

SimpleDB is designed to stay responsive to queries even when you’re pumping it full of records.  Logging and analysis is a great example of this, and a great example is BrowserMob’s monitoring service.  They poke your site every few minutes to ensure it’s responding — but it’s not just checking to see that your web server is alive, but also monitoring the load time for every object in the page:  images, CSS files, etc.  You can check the status and compare responses over time to see how your site is doing as it gets more popular, and as you change pieces under the hood.  The data from all of the sites they monitor are pumped into SimpleDB, and the results are available for their customers to see in real time.¹

That level of concurrency, of accepting a substantial number of simultaneous writes while querying the complete data set, is hard to do, especially when every piece of the data is being indexed.  Most relational databases fall over pretty quick, but SimpleDB keeps on ticking.

The second thing that SimpleDB excels at is being accessible.  It’s available to any device that can talk to the web: your computer, of course, but also phones (even the cheap ones), game consoles (portables too), DVD players, information kiosks, environmental monitors, toasters, etc.  Instead of building a web service around a traditional database, you can save a lot of time, energy, and frustration by using SimpleDB as queryable, web accessible, data storage.²

… But only if your data model works with SimpleDB, of course.  There are some drawbacks, like eventual consistency, no transactions, and weak constraints that make it difficult or impossible to use for many applications.  Never the less, it’s an important tool to have in your toolbox — a complement rather than competition to traditional RDBMSes.

Last week I gave a presentation at “The Act of Making Clouds” on SimpleDB.  I touched on some of these subjects, and although there isn’t an audio track, you’re welcome to check out the deck, below.

The twist is that you probably won’t be able to spend it.  I collect paper money from foreign countries, and I have a pile of money sitting in my office that I’m trying to get rid of. They’re duplicates that are already represented in my collection, and since I don’t collect the high priced stuff, it’s not worth trying to divide up and sell on eBay.

So I’m giving it away.

It’s neat stuff.  Paper money from over a dozen countries, spanning the last half century of world history.  It never fails to start conversations with people who are interested in politics, finance, art, or travel.  It beats the crap out of monopoly money.  It’s fun to leave in tip jars.  Kids say “whoa!” and “cool!”

If you’re interested, send me an e-mail with your name and address, and I’ll send you an envelope with 10 different banknotes in it.  Pretty simple.

Free money, for the first 18 people who want it.  Seriously.

Update: I stuffed and sent out a pile of envelopes this weekend.  If you got in touch with me before Friday, you’re getting an extra banknote.  Free money, people!  Come get it!

It’s pretty low flow — 10 to 15 articles per day, and throttled at one tweet per hour to keep things fresh.

This is an experiment in combining three of my favorite activities:  I read voraciously, I enjoy sharing my interests with other people, and I tinkering with software and the Internet for a living.  Between my career and my family, I don’t always have time to blog or tweet or comment on the specific articles I enjoy, so I’ve written a tool that scrapes my reading list and publishes the notable articles for me.

For those of a technical persuasion, here’s how it fits together:

I use Google Reader to consume and organize hundreds of news feeds.  When I see an article I like, I share it on my public feed.  The tool checks the feed for new articles, and every hour one of the shared articles is published to the @peatsreader account.  Hooray for automation!

I’ll be happy to share the Ruby source on GitHub if there’s any interest.  In the meantime, follow @peatsreader and let me know what you think.

“Serving the Next Billion” is an hour long session about the perspective that people from developing nations bring to the Internet, and how web nerds can help improve the parts of the world that need it most.

Empowering the forgotten people of the world is one of the greatest challenges to humanity, and one I’ve struggled to reconcile with my profession as a software developer.  But I have hope:  the Internet is converging with billions of people, and it’s an unprecedented opportunity for people like me (and you) to connect with and learn from the rest of the world.

I also excited about being featured on a web page in close proximity to Mark Frauenfelder.

So, put it in your calendar:  WebVisions runs from May 20th to 22nd here in Portland.  I’ll be doing my thing on Friday morning at 9:00, and I hope to see you there!

Alvin is working in his store when he hears a booming voice from above that says, “Alvin, sell your business!”  He ignores it.  The voice goes on for days saying, “Alvin, sell your business for three million dollars!”  After weeks of this, he relents and sells his store.

The voice says, “Alvin, go to Las Vegas!”

Alvin asks why.

“Alvin, just take the three million dollars and go to Las Vegas.”

Alvin obeys, goes to Las Vegas, and visits a casino.

The voice says, “Alvin, go to the blackjack table and put it all down on one hand!”

Alvin hesitates but gives in.  He’s dealt an eighteen.  The dealer has a six showing.

“Alvin, take a card!”

“What?  The dealer has …”

“Take a card!”

Alvin tells the dealer to hit him, and gets an ace.  Nineteen.  He breathes easy.

“Alvin, take another card.”

“What?”

“TAKE ANOTHER CARD!”

Alvin asks for another card.  It’s another ace.  He has twenty.

“Alvin, take another card!” the voice commands.

“I have twenty!” Alvin shouts.

“TAKE ANOTHER CARD!” booms the voice.

“Hit me!” Alvin says.  He gets another ace.  Twenty-one!

And the booming voice says, “Un-fucking-believable!”

It’s from a little book with a big name, “Plato and a Platypus Walk into a Bar: Understanding Philosophy Through Jokes.”

Highly recommended.  Go get it.

Why is RPX useful?  Aren’t there a bunch of OpenID plugins out there for [favorite language] or [preferred web development framework]?

There are a lot of libraries and plugins for a lot of platforms, but most of them have three problems: complexity, incompatibility, and poor usability.

The Old Way

Complexity:  Most of the existing tools require you to build database tables and maintain extra libraries on your production systems. I like to avoid tools and libraries that step on my schema and cause extra maintenance work, and I expect you do too.

Incompatibility:  Most current tools don’t fully support OpenID 2.0, which is a deal buster when you’re trying to build a site for anyone who wants to accept i-names or directed identities.

Usability:  Existing plugins don’t usually provide a user friendly interface for the vast majority of people on the web. User experience matters, and it’s nice to get a helping hand when it’s available.

RPX solves these issues in one swoop — it’s mercifully simple, feature rich, and user friendly.

Did I mention free? That’s nice, too.

Seeking Simplicity

Here’s what it takes to get RPX running with your app:

• A free account on rpxnow.com (premium accounts are available if you need extra features).
• A dab of Javascript on your login page (provided by rpxnow.com, example below).
• A few lines of code on your server side application (example below).

It took me less than half an hour to get it running the first time.

Feature Rich

Full support for OpenID 2.0 is a great thing — and not having to worry about future OpenID enhancements is even better. But wait, there’s more: RPX provides authentication statistics, a testing tool, and a well documented API. It also lets users authenticate with their Facebook and MySpace profiles. It’s the gift that keeps on giving.

User Friendly

RPX provides your visitors with a an attractive dialog that ushers them through the OpenID authentication process. Even if they don’t know what OpenID is, there are big friendly buttons that will help them use their accounts at Yahoo, AOL, Google, Facebook, or MySpace. As more providers come online, RPX will update that interface on your behalf.

How Does It Work?

In a nutshell, RPX is a hosted service that handles the nitty gritty of the OpenID authentication process for you. The only work for you is fetching the authentication information from the RPX server.

The flow looks something like this:

• I come to your web app and click the link to login.
• The RPX interface pops up and prompts me for my OpenID.
• After I authenticate with my OpenID provider, the RPX server directs me back to your app with a unique token.
• Your app queries the RPX server with that token, and gets my authentication information in return.

Pretty straight forward. What’s that look like in code?

A specific example (with Rails) looks something like this:

The view (HTML + JS):

<a class="rpxnow" onclick="return false;" href="https://your-com.rpxnow.com/openid/v2/signin?token_url=http://your.com/rpx">Sign In</a>

<script src="https://rpxnow.com/openid/v2/widget" type="text/javascript"></script>
<script type="text/javascript">
  RPXNOW.token_url = 'http://your.com/rpx';
  RPXNOW.realm = "mysite.com";
  RPXNOW.overlay = true;
</script>

The token_url in the link and the javascript points to a URL on your site, and the RPXNOW.realm is your OpenID authentication realm (typically the root URL for your site).

Rails handler at http://your.com/rpx:

rpx_token = params[:token]

rpx = Net::HTTP.new('rpxnow.com', 443)
rpx.use_ssl = true
path = "/api/v2/auth_info"
args = "apiKey=#{RPX_API_KEY}&token=#{rpx_token}"
http_resp, response_data = rpx.post( path, args )

rpx_data = JSON.parse( response_data )

Briefly stated, this code:

• Collects the token parameter from the user’s request after they authenticate.
• Performs an HTTPS POST against the RPX server containing that token and a secret API key.
• Parses the JSON response into a usable format — in this case, a hash named rpx_data.

This isn’t limited to Rails, of course. Every major development language and web framework can set up an HTTPS connection and parse JSON … and if JSON isn’t your style, you can get an XML response instead.

Real World Use

This morning I converted the OpenID Foundation’s membership website to use RPX, and ditched the old plugin I hacked up to support the OpenID 2.0 features. If you’re interested in seeing it in action head on over to their site: https://openid.net/foundation/members

I also encourage anyone who’s interested in the future of OpenID to become a member. Individual memberships are cheap, and the pay off is big — you can participate directly in the election of board members, review and ratify specifications, and participate in working groups.

Feedback

Still confused? Know of a better solution? Leave a comment, let me know!

Two things got me excited on their site. First, they’re opening an online cinema. For $5 you can watch a movie as often as you like over the course of a week, and those greenbacks get credited to your account if you want to purchase the real deal to play on your home entertainment system. I’m a little skeptical of the quality of the streamed video — if it’s anything like Netflix, it’ll be chunky and pause to rebuffer right when you wish it really wouldn’t — but bandwidth keeps getting better so I’m sure it’ll be fast and fluid in the near future.

Which gets me to Netflix. I think I pay $9/mo. for the basic unlimited package, but I still get to stream as many movies as I like. Great for casual movie nights. I’m looking forward to when The Sopranos become available. The only downside is the above mentioned streaming quality. When it’s running, it’s pretty darned good … but after 15 minutes the network will crap out and I’ll have to grab a drink while the buffers refill. My inside man at Netflix swears up and down it’s a problem with Comcast and their throttling policies. Boo.

Anyhow, back to my original story of clicking around on the Criterion site. I’m super excited to see them working with The Auteurs, a social networking site for film aficionados that has been in the works for over a year. Hats off to Efe Cakarel for seeing it through. The world desperately needs an alternative to the eye-gougingly terrible IMDB forums.

Alright. Back to work for me. Gotta tie up some loose ends before Turkeyfest 2008.

Here’s Peat’s shared items. You’ll probably notice I’m a fan of Boing Boing, Make Magazine, and a heap of odd nerdly things.

Feedburner says most of the people who read my blog are also using Google Reader, so if you’re sharing articles, I’d love to read ‘em!