viagra generic canada

Joseph Smarr
============

Thoughts on web development, tech, and life.

Main menu:
----------

Home

About Me

Subscribe with Bloglines

Subscribe via e-mail:

Twitter Status
--------------

My Twitter Feed yay, stay tuned ;) RT @johnmccrea: Okay, the word is
out. My stealth project, Tunerfish, is a little less stealth now:
http://tcrn.ch/bCgRBgabout 5 hours ago
Upcoming Events

Site search
-----------

Search for:

Categories
----------

Blog (5)
Lunch 2.0 (3)
Music (2)
NLP (6)
Open Social Web (34)
Papers and Talks (37)
Personal (23)
Plaxo (39)
Web development (21)

April 2010

M

T

W

T

F

S

S

« Mar

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

Archive
-------

March 2010 (1)

January 2010 (2)

December 2009 (1)

November 2009 (1)

June 2009 (1)

May 2009 (1)

March 2009 (2)

February 2009 (3)

December 2008 (1)

November 2008 (2)

October 2008 (1)

September 2008 (3)

May 2008 (1)

April 2008 (2)

March 2008 (4)

February 2008 (1)

January 2008 (1)

November 2007 (6)

October 2007 (2)

August 2007 (5)

July 2007 (5)

June 2007 (4)

May 2007 (3)

April 2007 (1)

March 2007 (2)

February 2007 (1)

January 2007 (13)

 

Current Projects
----------------

Plaxo

Lunch 2.0

Open Social Web

TheSocialWeb.tv

Portable Contacts

shindig-php

OpenSocial Foundation

PreBird

OpenID Foundation

 

Links
-----

Contact me

Headshot and bio

My Blogroll

Plaxo's blog

 

Me on the Web
-------------

ClaimID

Del.icio.us

Digg

Facebook

Flickr

Goodreads

Google

LinkedIn

Plaxo

Socializr

Tungle.me

Twitter

Upcoming

Yelp

Implementing PubSubHubbub subscriber support: A step-by-step guide
------------------------------------------------------------------

One of the last things I did before leaving Plaxo was to implement
PubSubHubbub (PuSH) subscriber support, so that any blogs which ping a
PuSH hub will show up almost instantly in pulse after being published.
It’s easy to do (you don’t even need a library!), and it significantly
improves the user experience while simultaneously reducing server load
on your site and the sites whose feeds you’re crawling. At the time, I
couldn’t find any good tutorials for how to implement PuSH subscriber
support (add a comment if you know of any), so here’s how I did it.
(Note: depending on your needs, you might find it useful instead to
use a third-party service like Gnip to do this.)

My assumption here is that you’ve already got a database of feeds
you’re subscribing to, but that you’re currently just polling them all
periodically to look for new content. This tutorial will help you “gracefully
upgrade” to support PuSH-enabled blogs without rewriting your
fundamental polling infrastructure. At the end, I’ll suggest a more
radical approach that is probably better overall if you can afford a
bigger rewrite of your crawling engine.

The steps to add PuSH subscriber support are as follows:

1. Identify PuSH-enabled blogs extract their hub and topic

2. Lazily subscribe to PuSH-enabled blogs as you discover them

3. Verify subscription requests from the hub as you make them

4. Write an endpoint to receive pings from the hub as new content is
  published

5. Get the latest content from updated blogs as you receive pings

6. Unsubscribe from feeds when they’re deleted from your system

1. Identify PuSH-enabled blogs extract their hub and topic

When crawling a feed normally, you can look for some extra metadata in
the XML that tells you this blog is PuSH-enabled. Specifically, you
want to look for two links: the “hub” (the URL of the hub that the
blog pings every time it has new content, which you in turn
communicate with to subscribe and receive pings when new content is
published), and the “self” (the canonical URL of the blog you’re
subscribing to, which is referred to as the “topic” you’re going to
subscribe to from the hub).

A useful test blog to use while building PuSH subscriber support is
http://pubsubhubbub-example-app.appspot.com/, since it lets anyone
publish new content. If you view source on that page, you’ll notice
the standard RSS auto-discovery tag that tells you where to find the
blog’s feed:

<link title="PubSubHubbub example app" type="application/atom+xml"
rel="alternate" />

And if you view source on
http://pubsubhubbub-example-app.appspot.com/feed, you’ll see the two
PuSH links advertised underneath the root feed tag:

<link type="application/atom+xml" title="PubSubHubbub example app"
rel="self" />
<link rel="hub" href="http://pubsubhubbub.appspot.com/"; />

You can see that the “self” link is the same as the URL of the feed
that you’re already using, and the “hub” link is to the free hub being
hosted on AppEngine at http://pubsubhubbub.appspot.com/. In both
cases, you want to look for a link tag under the root feed tag, match
the appropriate rel-value (keeping in mind that rel-attributes can
have multiple, space-separated values, e.g. rel="self somethingelse",
so split the rel-value on spaces and then look for the specific
matching rel-value), and then extract the corresponding href-value
from that link tag. Note that the example above is an ATOM feed; in
RSS feeds, you generally have to look for atom:link tags under the
channel tag under the root rss tag, but the rest is the same.

Once you have the hub and self links for this blog (assuming the blog
is PuSH-enabled), you’ll want to store the self-href (aka the “topic”)
with that feed in your database so you’ll know whether you’ve
subscribed to it, and, if so, whether the topic has changed since you
last subscribed.

2. Lazily subscribe to PuSH-enabled blogs as you discover them

When you’re crawling a feed and you notice it’s PuSH-enabled, check
your feed database to see if you’ve got a stored PuSH-topic for that
feed, and if so, whether the current topic is the same as your stored
value. If you don’t have any stored topic, or if the current topic is
different, you’ll want to talk to that blog’s PuSH hub and initiate a
subscription so that you can receive real-time updates when new
content is published to that blog. By storing the PuSH-topic per-feed,
you can effectively “lazily subscribe” to all PuSH-enabled blogs by
continuing to regularly poll and crawl them as you currently do, and
adding PuSH subscriptions as you find them. This means you don’t have
to do any large one-time migration over to PuSH, and you can
automatically keep up as more blogs become PuSH-enabled or change
their topics over time. (Depending on your crawling infrastructure,
you can either initiate subscriptions as soon as you find the relevant
tags, or you can insert an asynchronous job to initiate the
subscription so that some other part of your system can handle that
later without slowing down your crawlers.)

To subscribe to a PuSH-enabled blog, just send an HTTP POST to its hub
URL and provide the following POST parameters:

hub.callback = the URL of your endpoint for receiving pings,
 which we’ll build in step 4

hub.mode = subscribe

hub.topic = the self-link / topic of the feed you’re subscribing
 to, which you extracted in step 1

hub.verify = async means the hub will separately call you back to
 verify this subscription

hub.verifytoken = a hard-to-guess token associated with this
 feed, which the hub will echo back to you to prove it’s a real
 subscription verification

For the hub.callback URL, it’s probably best to include the internal
database ID of the feed you’re subscribing to, so it’s easy to look up
that feed when you receive future update pings. Depending on your
setup, this might be something like
http://yoursite.com/push/update?feedid=123 or
http://yoursite.com/push/update/123. Another advantage of this
technique is that it makes it relatively hard to guess what the update
URL is for an arbitrary blog, in case an evil site wanted to send you
fake updates. If you want even more security, you could put some extra
token in the URL that’s different per-feed, or you could use the
hub.secret mechanism when subscribing, which will cause the hub to
send you a signed verification header with every ping, but that’s
beyond the scope of this tutorial.

For the hub.verifytoken, the simplest thing would just be to pick a
secret word (e.g. “MySekritVerifyToken“) and always use that, but an
evil blog could use its own hub and quickly discover that secret. So a
better idea is to do something like take the HMAC-SHA1 of the topic
URL along with some secret salt you keep internally. This way, the
hub.verifytoken value is feed-specific, but it’s easy to recompute
when you receive the verification.

If your subscription request is successful, the hub will respond with
an HTTP 202 “Accepted” code, and will then proceed to send you a
verification request for this subscription at your specified callback
URL.

3. Verify subscription requests from the hub as you make them

Shortly after you send your subscription request to the hub, it will
call you back at the hub.callback URL you specified with an HTTP GET
request containing the following query parameters:

hub.mode = subscribe

hub.topic = the self-link / topic of the URL you requested a
 subscription for

hub.challenge = a random string to verify this verification that
 you have to echo back in the response to acknowledge verification

hub.verifytoken = the value you sent in hub.verifytoken during
 your subscription request

Since the endpoint you receive this verification request is the same
one you’ll receive future update pings on, your logic has to first
look for hub.mode=subscribe, and if so, verify that the hub sent the
proper hub.verifytoken back to you, and then just dump out the
hub.challenge value as the response body of your page (with a standard
HTTP 200 response code). Now you’re officially subscribed to this
feed, and will receive update pings when the blog publishes new
content.

Note that hubs may periodically re-verify that you still want a
subscription to this feed. So you should make sure that if the hub
makes a similar verification request out-of-the-blue in the future,
you respond the same way you did the first time, providing you indeed
are still interested in that feed. A good way to do this is just to
look up the feed every time you get a verification request (remember,
you build the feed’s ID into your callback URL), and if you’ve since
deleted or otherwise stopped caring about that feed, return an HTTP
404 response instead so the hub will know to stop pinging you with
updates.

4. Write an endpoint to receive pings from the hub as new content is
published

Now you’re ready for the pay-out–magically receiving pings from the
ether every time the blog you’ve subscribed to has new content! You’ll
receive inbound requests to your specified callback URL without any
additional query parameters added (i.e. you’ll know it’s a ping and
not a verification because there won’t be any hub.mode parameter
included). Instead, the new entries of the subscribed feed will be
included directly in the POST body of the request, with a request
Content-Type of application/atom+xml for ATOM feeds and
application/rss+xml for RSS feeds. Depending on your programming
language of choice, you’ll need to figure out how to extract the raw
POST body contents. For instance, in PHP you would fopen the special
filename php://input to read it.

5. Get the latest content from updated blogs as you receive pings

The ping is really telling you two things: 1) this blog has updated
content, and 2) here it is. The advantage of providing the content
directly in the ping (a so-called “fat ping“) is so that the
subscriber doesn’t have to go re-crawl the feed to get the updated
content. Not only is this a performance savings (especially when you
consider that lots of subscribers may get pings for a new blog post at
roughly the same time, and they might otherwise all crawl that blog at
the same time for the new contents; the so-called “thundering herd”
problem), it’s also a form of robustness since some blogging systems
take a little while to update their feeds when a new post is published
(especially for large blogging systems that have to propagate changes
across multiple data-centers or update caching tiers), so it’s
possible you’ll receive a ping before the content is available to
crawl directly. For these reasons and more, it’s definitely a
best-practice to consume the fat ping directly, rather than just using
it as a hint to go crawl the blog again (i.e. treating it as a “light
ping”).

That being said, most crawling systems are designed just to poll URLs
and look for new data, so it may be easier to start out by taking the
“light ping” route. In other words, when you receive a PuSH ping, look
up the feed ID from the URL of the request you’re handling, and
assuming that feed is still valid, just schedule it to crawl ASAP.
That way, you don’t have to change the rest of your crawling
infrastructure; you just treat the ping as a hint to crawl now instead
of waiting for the next regular polling interval. While sub-optimal,
in my experience this works pretty well and is very easy to implement.
(It’s certainly a major improvement over just polling with no PuSH
support!) If you’re worried about crawling before the new content is
in the feed, and you don’t mind giving up a bit of speed, you can
schedule your crawler for “in N seconds” instead of ASAP, which in
practice will allow a lot of slow-to-update feeds to catch up before
you crawl them.

Once you’re ready to handle the fat pings directly, extract the
updated feed entries from the POST body of the ping (the payload is
essentially an exact version of the full feed you’d normally fetch,
except it only contains entries for the new content), and ingest it
however you normally ingest new blog content. In fact, you can go even
further and make PuSH the default way to ingest blog content–change
your polling code to act as a “fake PuSH proxy” and emit PuSH-style
updates whenever it finds new entries. Then your core feed-ingesting
code can just process all your updated entries in the same way,
whether they came from a hub or your polling crawlers.

However you handle the pings, once you find that things are working
reliably, you can change the polling interval for PuSH-enabled blogs
to be much slower, or even turn it off completely, if you’re not
worried about ever missing a ping. In practice, slow polling (e.g.
once a day) is probably still a good hedge against the inevitable
clogs in the internet’s tubes.

6. Unsubscribe from feeds when they’re deleted from your system

Sometimes users will delete their account on your system or unhook one
of their feeds from their account. To be a good citizen, rather than
just waiting for the next time the hub sends a subscription
verification request to tell it you no longer care about this feed,
you should send the hub an unsubscribe request when you know the feed
is no longer important to you. The process is identical to subscribing
to a feed (as described in steps 2 and 3), except you use “unsubscribe”
instead of “subscribe” for the hub.mode values in all cases.

Testing your implementation

Now that you know all the steps needed to implement PuSH subscriber
support, it’s time to test your code in the wild. Probably the easiest
way is to hook up that http://pubsubhubbub-example-app.appspot.com/
feed, since you can easily add content it to it to test pings, and
it’s known to have valid hub-discovery metadata. But you can also
practice with any blog that is PuSH-enabled (perhaps your shiny new
Google Buzz public posts feed?). In any case, schedule it to be
crawled normally, and verify that it correctly extracts the hub-link
and self-link and adds the self-link to your feed database.

The first time it finds these links, it should trigger a subscription
request. (On subsequent crawls, it shouldn’t try to subscribe again,
since the topic URL hasn’t changed. ) Verify that you’re sending a
request to the hub that includes all the necessary parameters, and
verify that it’s sending you back a 202 response. If it’s not working,
carefully check that you’re sending all the right parameters.

Next, verify that upon sending a subscription request, you’ll soon get
an inbound verification request from the hub. Make sure you detect
requests to your callback URL with hub.mode=subscribe, and that you
are checking the hub.verifytoken value against the value you sent in
the subscription request, and then that you’re sending the
hub.challenge value as your response body. Unfortunately, it’s usually
not easy to inspect the hub directly to confirm that it has properly
verified your subscription, but hopefully some hubs will start
providing site-specific dashboards to make this process more
transparent. In the meantime, the best way to verify that things
worked properly is to try making test posts to the blog and looking
for incoming pings.

So add a new post on the example blog, or write a real entry on your
PuSH-enabled blog of choice, and look in your server logs to make sure
a ping came in. Depending on the hub, the ping may come nearly
instantaneously or after a few seconds. If you don’t see it after
several seconds, something is probably wrong, but try a few posts to
make sure you didn’t just miss it. Look at the specific URL that the
hub is calling on your site, and verify that it has your feed ID in
the URL, and that it does indeed match the feed that just published
new content. If you’re using the “light ping” model, check that you
scheduled your feed to crawl ASAP. If you’re using the “fat ping”
model, check that you correctly ingested the new content that was in
the POST body of the ping.

Once everything appears to be working, try un-hooking your test feed
(and/or deleting your account) and verify that it triggers you to send
an unsubscribe request to the hub, and that you properly handle the
subsequent unsubscribe verification request from the hub.

If you’ve gotten this far, congratulations! You are now part of the
real-time-web! Your users will thank you for making their content show
up more quickly on your site, and the sites that publish those feeds
will thank you for not crawling them as often, now that you can just
sit back and wait for updates to be PuSH-ed to you. And I and the rest
of the community will thank you for supporting open standards for a
decentralized social web!

(Thanks to Brett Slatkin for providing feedback on a draft of this
post!)

Posted: March 1st, 2010 under Plaxo, Web development, Open Social Web.
Comments: View comments

HipChat is consumer-meets-enterprise done right — check it out!
---------------------------------------------------------------

Three of Plaxo’s best engineers and designers left almost a year ago
to start a new company (much as they’d done a few years ago with
HipCal, which Plaxo acquired in 2006). After a brief private beta,
today they are launching to the public.

HipChatMeet HipChat. It’s a new (and, IMO, very clever and promising)
approach to group collaboration within companies and teams–essentially
group chat plus file-sharing done with the simplicity and polish of a
great consumer app, but targeted at the enterprise. And it’s meant to
spread organically and bottoms-up by attracting enthusiastic team
members who really find it useful, rather than top-down through long
sales-cycles to CIOs–in other words, winning by actually being better
for the people that use it every day. You’ll be able to tell this from
the moment you start using it–it’s distinctly “un-enterprise-y” in all
the right ways, yet every enterprise needs something like this to be
more productive and organized.

More HipChat screenshots 

I’m excited about HipChat for several reasons:

First, the founders (Pete Curley, Garret Heaton, and Chris Rivers) are
all rockstar talents and super nice guys; the best of the young web
2.0 “bootstrap from nothing and build something genuinely good that
grows because people are using and loving it” approach that’s only
become feasible recently. Whatever they work on, I know it’ll be well
thought through and well executed, and it’ll keep getting better over
time. These are good guys to know and watch, and they’re just getting
started.

Second, group collaboration is a space that everyone knows is
important, and yet that nothing does a good job of solving today. At
Plaxo we’ve tried tons of wikis, internal blogs, mailing lists,
document depots, dashboards, you name it. They’re always too
complicated and cumbersome and never have streamlined workflows that
work the way you need. One of my early surprises coming to Google is
that for all their efforts and internal tools, the situation is
ultimately not much better. Information is still spread everywhere
across a variety of systems, is too hard to find and curate, and too
often forces you to just ask the person next to you and hope for the
best. Maybe new tools like Google Wave will make a difference here,
but of course the more flexible and general-purpose a tool like that
is, the greater the risk that it will do too many things and none of
them just the way you want. HipChat may not be the magic solution to
this complex problem either, but it’s refreshing to see the team apply
a consumer-app eye and discipline to the problem–focusing on specific
task arcs to really nail, and an end-to-end polish and friendliness
that’s so clearly lacking from most other groupware tools.

This last point deserves its own slot: in my experience, the only way
to really advance the state of technology making a real difference in
the lives of real people is to subject it to the harsh Darwinian
landscape of consumer software and devices, where if it doesn’t “just
work” and provide a compelling and enjoyable experience, it doesn’t
get used. This is the sharpening steel that’s honed all the best apps
we have today, from gmail to facebook to the iPhone to boxee, and so
on. And if you think about it, it’s the missing piece that makes most
enterprise software so terrible–your company buys it, and you’re stuck
with it, like it or not. The typical enterprise “fitness function”
yields a much slower and sloppier rate of evolution than the consumer
one, and that I believe is the main reason the quality of the two
classes of apps differs so much. So it’s great to see an increase in
companies willing to try and swim upstream to gain corporate adoption
with a consumer mindset, whether it’s Google Apps, box.net, Yammer, or
now HipChat.

If you work on a team, if you’re dissatisfied with the state of
collaboration tools, or if you just want to see a really well done new
app, I encourage you to check out HipChat. We used several early betas
inside Plaxo, and while any new communications tool faces an uphill
battle to gain critical mass of adoption and change old habits, enough
of us had enough “eureka moments” using HipChat to see its strong
potential and to wish that we could fast-forward time until more
people are using it and it’s had even more love put into it. The next
best thing we can do is to spread the good word and give our support
to the team, so consider this post a down payment!

Posted: January 25th, 2010 under Personal, Plaxo.
Comments: View comments

Sources of inspiration for 2010
-------------------------------

Despite all the serious challenges the world is facing these days, I’m
also seeing more and more that inspires me–cases where great things
are happening to great people doing great work and improving the world
in the process. Specifically, the following recent examples come to
mind:

Movies: Avatar

Music: Lady Gaga

TV: Netflix HD streaming to Blu-Ray/TiVo/Xbox/etc.

Mobile: Palm Pre & Nexus One

Desktop: Chrome OS

Social: Foursquare

What do all of these have in common? They’re all cases of insanely
talented outsiders changing the world by just working really hard and
doing great stuff.

Everyone said James Cameron was crazy to make Avatar, just like they
said he was crazy to make Titanic. They’re both such impossibly grand,
expensive, and difficult visions to capture. But he did it anyway, and
the work is brilliant, and the only thing that went broke were the
previous box-office records.

Same thing with Lady Gaga: just two years ago, no one had heard of
her, and she was just playing little clubs in New York. But using her
incredible talent in song-writing and performance art, and a
willingness to work insanely hard every day, she unleashed her strange
and unique vision of music/fashion/art/performance and took the world
by storm, becoming the first artist ever to score four #1 hits off her
debut album, and at age 23 no less. If you haven’t paid close
attention and think she’s just another made-to-order corporate pop
starlet, take a closer look, you’ll be surprised (as I was).

Netflix is certainly an outsider when it comes to watching TV in your
living room (it’s neither a cable provider nor a set-top box
manufacturer), yet now that I can watch entire seasons of Lost in HD
on my TV whenever I want–thanks to its Watch Instantly streaming and
integrations with existing set-top boxes and gaming consoles–I find
myself rarely watching “real TV” any more. And Netflix’s user
experience is far superior–it knows which episodes I’ve already seen,
so I can just pick up where I left off whenever I have a free moment.
And if I’m up at Tahoe for the weekend, I can watch it there too on my
laptop, and my episode history is kept in sync because it’s stored in
the cloud. Brilliant.

Both Palm Pre and Android (hard to pick a favorite yet!) are up
against fierce competition from Apple and the old-world mobile
establishment, and neither company (Palm or Google) is an established
player in this space, but they’re both producing excellent devices
that simultaneously improve the quality of the experience for users
while opening up more flexibility and power to developers. And they’re
also making web development more of a “first-class citizen” for mobile
apps. It’s hard to think of a more ambitious challenge than building
your own mobile platform–hardware, OS, software stack, apps, and
distribution in physical stores–but that’s not stopping these guys
from having a major impact, and the game is just beginning.

Chrome OS isn’t even out yet really, but it’s already clear that the
desktop will soon evolve to their vision where all important data
lives in the cloud, and it will no longer matter if your computer dies
or if you want to use multiple computers in different places–a pain
that I’ve experienced many times, as I’m sure you have. Windows is one
of the most well-established monopolies there is, so again it’s crazy
in some sense to try and compete there, let alone with a radical new
vision that does a lot less than the status quo, and instead
re-imagines the problem in a new way. And yet people buy new computers
all the time, so it’s not hard to believe that they could establish
considerable market share in a short number of years, while forcing
radical change from their competitors at the same time.

And perhaps closest to my own area of work on the Social Web, I think
it’s noteworthy that the company that has had the biggest positive
impact on how I connect and share with my friends in the last year is
not any of the big established players, but a tiny startup that’s
building itself up from scratch by making it easier and more rewarding
to share where you are and what you’re doing: Foursquare. While I
cringe at the amount of work they have to do to integrate with each
separate social network and build apps for each separate mobile device
(that’s why we need more common standards, of course!), they’re still
able to deliver an awesome product with a tiny team, and their service
is taking off like a rocket.

Why are these examples so inspiring to me? They provide reassurance
that in 2010, two basic things are still true–perhaps more true than
ever before:

1. You can win by being excellent and working hard to build a
  better product

2. You can win even if you’re an outsider in a field of powerful
  incumbents

It’s hard to believe in transformational innovation if you can’t
believe in those two points, and it’s often easy to get discouraged,
since these are such difficult challenges. But if those guys can all
do it, so can we. In fact, it’s not hard to believe that it’s actually
getting easier to succeed in these ways. After all, barriers to entry
keep getting lowered, and the spread of information keeps getting
faster and more efficient, so the good stuff should be able to be
discovered and bubble to the top faster than ever before. If that’s
true, then the new “hard problem” should be doing great work in the
first place, and that’s the problem I want to be tackling!

What examples are inspiring you right now?

Posted: January 18th, 2010 under Personal, Music.
Comments: View comments

Joseph Smarr has new work info…
-------------------------------

High on my to-do list for 2010 will be to update my contact info in
Plaxo, because I’ll be starting a new job in late January. After
nearly 8 amazing years at Plaxo, I’m joining Google to help drive a
new company-wide focus on the future of the Social Web. I’m incredibly
excited about this unique opportunity to turbo-charge my passionate
pursuit of a Social Web that is more open, interoperable,
decentralized, and firmly in the control of users.

I’ve worked closely with Google as a partner in opening up the social
web for several years, and they’ve always impressed me with their
speed and quality of execution, and more importantly, their unwavering
commitment to do what’s right for users and for the health of the web
at large. Google has made a habit of investing heavily and openly in
areas important to the evolution of the web—think Chrome, Android,
HTML5, SPDY, PublicDNS, etc. Getting the future of the Social Web
right—including identity, privacy, data portability, messaging,
real-time data, and a distributed social graph—is just as important,
and the industry is at a critical phase where the next few years may
well determine the platform we live with for decades to come. So when
Google approached me recently to help coordinate and accelerate their
innovation in this area, I could tell by their ideas and enthusiasm
that this was an opportunity I couldn’t afford to pass up.

Now, anyone who knows me should immediately realize two things about
this decision—first, it in no way reflects a lack of love or
confidence from me in Plaxo, and second, I wouldn’t have taken this
position if I hadn’t convinced myself that I could have the greatest
possible impact at Google. For those that don’t know me as well
personally, let me briefly elaborate on both points:

I joined Plaxo back in March of 2002 as their first non-founder
employee, before they had even raised their first round of investment.
I hadn’t yet finished my Bachelor’s Degree at Stanford, and I’d
already been accepted into a research-intensive co-terminal Masters
program there, but I was captivated by Plaxo’s founders and their
ideas, and I knew I wanted to be a part of their core team. So I spent
the first 15 months doing essentially two more-than-full-time jobs
simultaneously (and pretty much nothing else). Since that time, I’ve
done a lot of different things for Plaxo—from web development to
natural language processing to stats collection and analysis to
platform architecture, and most recently, serving as Plaxo’s Chief
Technology Officer. Along the way, I’ve had to deal with hiring,
firing, growth, lack of growth, good press, bad press, partnerships
with companies large and small, acquisitions—both as the acquirer and
the acquiree—and rapidly changing market conditions (think about it:
we started Plaxo before users had ever heard of flickr, LinkedIn,
friendster, Gmail, Facebook, Xobni , Twitter, the iPhone, or any
number of other companies, services, and products that radically
altered what it means to “stay in touch with the people you know and
care about across all the tools and services that you and they use”).
When I joined Plaxo, there were four of us. Now we have over 60
employees, and that’s not counting our many alumni. All of this is to
make the following plain: Plaxo has been my life, my identity, my
passion, and my family for longer than I’ve known my wife, longer than
I was at Stanford, and longer than I’ve done just about anything
before. Even at a year-and-a-half since our acquisition by Comcast,
Plaxo has the same magic and mojo that’s made it a joy and an honor to
work for all these years. And with our current team and strategic
focus, 2010 promises to be one of the best years yet. So I hope this
makes it clear that I was not looking to leave Plaxo anytime soon, and
that the decision to do so is one that I did not make lightly.

Of all the things I’ve done at Plaxo over the years, my focus on
opening up the Social Web over the past 3+ years is the work I’m
proudest of, and the work that I think has had the biggest positive
impact—both for Plaxo and the web itself. Actually, it really started
way back in 2004, when I first read about FOAF and wrote a paper about
its challenges from Plaxo’s perspective, for which I was then selected
to speak at my first industry conference, the FOAF Workshop in Galway,
Ireland. Since that time, I realized what a special community of
people there were that cared about these issues in a web-wide way, and
I tried to participate on the side and in my free time whenever
possible. After leading Plaxo’s web development team to build a rich
and complex new AJAX address book and calendar (something that also
reinforced to me the value of community participation and public
speaking, albeit on the topic of high-performance JavaScript), I knew
I wanted to work on the Social Web full-time, and luckily it coincided
perfectly with Plaxo’s realization that fulfilling our mission
required focusing on more than just Outlook, webmail, and IM as
important sources of “people data”. So we crafted a new role for me as
Chief Platform Architect, and off I went, turning Plaxo into the first
large-scale OpenID Relying Party, the first live OpenSocial container,
co-creator of the Portable Contacts spec, co-creator and first
successful deployment of hybrid onboarding combining OpenID and OAuth,
and so on. Along the way I co-authored the Bill of Rights for Users of
the Social Web, coined the term Open Stack, was elected to the Boards
of both the OpenID Foundation and OpenSocial Foundation, and worked
closely with members of the grass-roots community as well as with
people at Google, Yahoo, Microsoft, AOL, Facebook, MySpace, Twitter,
LinkedIn, Netflix, The New York Times, and others, often as a launch
partner or early adopter of their respective forays into supporting
these same open standards. And collectively, I think it’s fair to say
that our efforts greatly accelerated the arrival, quality, and
ubiquity of a Social Web ecosystem that has the potential to be open,
decentralized, and interoperable, and that may define the next wave of
innovation in this space, much as the birth of the web itself did
nearly 20 years ago.

But we’re not done yet. Not by a long shot. And the future is never
certain.

At the recent OpenID Summit hosted by Yahoo!, I gave a talk in which I
outlined the current technical and user-experience challenges standing
in the way of OpenID becoming truly successful and a “no-brainer” for
any service large or small to implement. Despite all the progress that
we’ve made over the past few years, and that I’ve proudly contributed
to myself, there is no shortage of important challenges left to meet
before we can reach our aspirations for the Social Web. There is also
no shortage of people committed to “fighting the good fight”, but as
with any investment for the future with a return that will be widely
shared, most people and companies are forced to make tough trade-offs
about whether to focus on what already works today or what may work
better tomorrow. There are a lot of good people in a lot of places
working on the future of the Social Web, and we need them all and
more. But in my experience, Google is unmatched in its commitment to
doing what’s right for the future of the web and its willingness to
think long-term. One need only look at the current crop of Social Web
“building blocks” being actively worked on and deployed by
Google—including OpenID, OAuth, Portable Contacts, OpenSocial,
PubSubHubbub, Webfinger, Salmon, and more—to see how serious they are.
And yet they came to me because they want to turn up the intensity and
focus and coordination and boldness even more.

I talked to a lot of Googlers before deciding to join, and from the
top to the bottom they really impressed me with how genuinely they
believe in this cause that I’m so passionate about, and how strong a
mandate I feel throughout the company to do something great here. I
also heard over and over how surprisingly easy it still is to get
things built and shipped — both new products, tools, and specs, as
well as integrating functionality into Google’s existing services.
And, of course, there are so many brilliant and talented people at
Google, and so much infrastructure to build on, that I know I’ll have
more opportunity to learn and have an impact than I could ever hope to
do anywhere else. So while there are other companies large and small
(or perhaps not yet in existence) where I could also have some form of
positive impact on the future of the Social Web, after looking closely
at my options and doing some serious soul searching, I feel confident
that Google is the right place for me, and now is the right time.

Let me end by sincerely thanking everyone that has supported me and
worked with me not just during this transition process but throughout
my career. I consider myself incredibly fortunate to be surrounded by
so many amazing people that genuinely want to have a positive impact
on the world and want to empower me to do the best that I can to
contribute, even it means doing so from inside (or outside) a
different company. It’s never easy to make big decisions involving
lots of factors and rapidly changing conditions, let alone one with
such deep personal and professional relationships at its core. Yet
everyone has treated me with such respect, honesty, and good faith,
that it fills me with a deep sense of gratitude, and reminds me why I
so love living and working in Silicon Valley.

2010 will be an exciting and tumultuous year for the Social Web, and
so will it be for me personally. Wish us both luck, and here’s to the
great opportunities that lie ahead!

Posted: December 18th, 2009 under Personal, Plaxo, Open Social Web.
Comments: View comments

What an RP Wants, Part 2 (OpenID Summit 2009)
---------------------------------------------

What an RP Wants, Part 2
OpenID Summit 2009 (Hosted by Yahoo!)
Mountain View, CA
November 2, 2009

What an RP Wants, Part 2

Download PPT (2.1 MB)

I was invited to give a talk at the OpenID Summit as a follow-up to my
talk “What an RP Wants“, which I gave in February at the OpenID Design
Summit. In both cases, I shared my experiences from Plaxo’s
perspective as a web site that is trying to succeed at letting users
sign up using accounts they already have on Google, Yahoo, and other
OpenID Provider sites. This talk reviewed the progress we’ve made as a
community since February, and laid out the major remaining challenges
to making it a truly-successful end-to-end experience to be an OpenID
Relying Party (RP).

My basic message was this: we’ve made a lot of progress, but we’ve
still got a lot left to do. So let’s re-double our efforts and commit
ourselves once again to working together and solving these remaining
problems. As much success as OpenID has had to date, its continued
relevance is by no means guaranteed. But I remain optimistic because
the same group of people that have brought us this far are still
engaged, and none of the remaining challenges are beyond our
collective ability to solve.

See more coverage of the OpenID Summit, including my talk, at The Real
McCrea.

And here are a couple of video excerpts from my talk:

Posted: November 3rd, 2009 under Papers and Talks, Plaxo, Open Social
Web.
Comments: View comments

Full video of my Google I/O talk now available
----------------------------------------------

The kind Google I/O folks have now posted a full video of my recent
talk, “The Social Web: An Implementer’s Guide“. They did a great job
editing back and forth between me and my slides. If you weren’t able
to make it to Google I/O (or you thought the talk was so good you want
to see it again), then please check it out! :)

Posted: June 9th, 2009 under Papers and Talks, Open Social Web.
Comments: View comments

The Social Web: An Implementer’s Guide (Google I/O 2009)
--------------------------------------------------------

The Social Web: An Implementer’s Guide
Google I/O 2009
San Francisco, CA
May 28, 2009

The Social Web: An Implementer's Guide (Google I/O 2009)

Download PPT (7.3 MB)

Google invited me back for a second year in a row to speak at
their developer conference about the state-of-the-art of opening up
the social web. While my talk last year laid out the promise and
vision of an interoperable social web ecosystem, this year I wanted to
show all the concrete progress we’ve made as an industry in achieving
that goal. So my talk was full of demos–signing up for Plaxo with an
existing Gmail account in just two clicks, using MySpaceID to jump
into a niche music site without a separate sign-up step, ending
“re-friend madness” by honoring Facebook friend connections on Plaxo
(via Facebook Connect), killing the “password anti-pattern” with
user-friendly contact importers from a variety of large sites
(demonstrated with FriendFeed), and sharing activity across sites
using Google FriendConnect and Plaxo. Doing live demos is always a
risky proposition, especially when they involve cross-site interop,
but happily all the demos worked fine and the talk was a big success!

I began my talk by observing that the events of the last year has made
it clear: The web is going social, and the social web is going open.
By the end of my talk, having showed so many mainstream sites with
deep user-friendly and user-friendly interoperability, I decided to go
a step further and declare: The web is now social, and the social web
is now open. You don’t have to wait any longer to start reaping the
benefits. It’s time to dive in.

Posted: May 29th, 2009 under Papers and Talks, Plaxo, Web development,
Open Social Web.
Comments: View comments

Portable Contacts and vCardDAV (IETF 74)
----------------------------------------

Portable Contacts and vCardDAV
IETF 74
San Francisco, CA
March 25, 2009

Download PPT (81 KB) or PDF

You may remember the venerable IETF standards-body from such
foundational internet RFCs as HTTP (aka the web), SMTP (aka e-mail),
and vCard (aka contact info). So I’ll be honest that I was a bit
intimidated when they invited me to their IETF-wide conference to
speak about my work on Portable Contacts.

In addition to being chartered with updating vCard itself, the IETF
has a working group building a read-write standard for sharing address
book data called CardDAV. (It’s a set of extensions to WebDAV for
contact info, hence the name.) Since Portable Contacts is also trying
to create a standard for accessing contact into online (albeit with a
less ambitious scope and feature set), I was eager to share the design
decisions we had made and the promising early adoption we’ve already
seen.

My optimistic hope was that perhaps some of our insights might end up
influencing the direction of CardDAV–or perhaps even vCard itself. But
I was also a bit nervous that such an august and rigorous standards
body might have little interest in the pontifications of a “scrappy
Open Stack hacker” like me. Or that even if they liked what I said, it
might be impossible to have an impact this late in the game. But I
figured if nothing else, here’s a group of people that are as
passionate about the gory details of contact info as we are, so at
least we should meet one another and see where it leads.

Boy was I impressed and inspired by their positive reception of my
remarks! Far from being a hostile or dis-interested audience, everyone
seemed genuinely excited by the work we’d done, especially since
companies large and small are already shipping compliant
implementations. The Q&A was passionate and detailed, and it spilled
out into the hallway and continued long after the session officially
ended.

Best of all, I then got to sit down with Simon Perreault, one of the
primary authors of vCard 4.0 and vCardXML, and we went literally
line-by-line through the entire Portable Contacts spec and wrote a
list of all the ways if differs from the next proposed version of
vCard. As you might imagine, there were some passionate arguments on
both sides concerning the details, but actually there were really no
“deal breakers” in there, and Simon sounded quite open (or even
excited) about some of the “innovations” we’d made. It really does
look like we might be able to get a common XML schema across PoCo and
vCard / CardDAV, and some of the changes might well land in core
vCard!

Of course, any official spec changes will happen through the normal
IETF mailing lists and process. But as I’m sure you can tell, I think
things went amazingly well today, and the future of standards for
sharing contact info online has never looked brighter! Thanks again to
Marc Blanchet, Cyrus Daboo, and the rest of the vCardDAV working group
for their invitation and warm reception. Onward ho!

Posted: March 25th, 2009 under Papers and Talks, Open Social Web.
Comments: View comments

Social data sharing will change lives and business (DEMO 09)
------------------------------------------------------------

Social data sharing will change lives and business
DEMO 09
Palm Desert, CA
March 3, 2009

Watch full video (via Brightcove)
I flew down to an oddly-lush oasis in the middle of the desert last
week to attend a panel at DEMO about the future of the social web. Max
Engel from MySpace has a nice write-up of the event, and a full video
of our panel is available on Brightcove. Eric Eldon of VentureBeat
moderated the panel, which featured me, Max Engel, Dave Morin from
Facebook, and Kevin Marks from Google. In addition to a lively
discussion, we each demoed our “latest and greatest” efforts at
opening up the social web. Max showed the first public demo of
MySpace’s support for hybrid OpenID+OAuth login using a friendly
popup, Kevin showed off how to add FriendConnect to any blog, and Dave
showed off some new examples of Facebook Connect in the wild. I showed
our new Google-optimized onboarding experiment with Plaxo, and
revealed that it’s working so well that we’re now using it for 100% of
new users invited to Plaxo via a gmail.com email address.

It’s just amazing and inspiring to me that these major mainstream
internet sites are all now able to stand up and demo slick,
user-friendly cross-site interoperability and data sharing using open
APIs, and we’re all continuing to converge on common standards so
developers don’t have to write separate code to interoperate with each
site. You can really measure the speed of progress in this space by
watching the quantity and quality of these Open Web demos continue to
increase, and with SXSW, Web 2.0 Expo, Google I/O, and Internet
Identity Workshop all still to come in the first half of 2009, I have
a feeling that we all ain’t seen nuthin’ yet! :)

Posted: March 11th, 2009 under Papers and Talks, Open Social Web.
Comments: View comments

Missing the Oscars Finale: A Case Study in Technology Failure (and
Opportunity)
------------------------------------------------------------------

Yesterday one of my wife’s friends came over to visit, and we
decided on a lark to watch the Oscars (which we haven’t done most
years). Even though we pay for Cable and are avid TiVo users, due to a
variety of circumstances we missed both the beginning of the Oscars
and–more importantly–the entire finale, from best female actress
through best picture. My frustration and indignation led to me to
think systematically about the various ways that technology could and
should have helped us avoid this problem. I decided to share my
thoughts in the hope that better understanding technology’s current
limitations will help inspire and illuminate the way to improving
them. As usual, I welcome your feedback, comments, and additional
thoughts on this topic.

The essence of the failure was this: the Oscars was content that we
wanted to watch, we were entitled to watch, but were ultimately unable
to watch. But specifically, here’s what went wrong that could and
should have done better:

Nothing alerted me that the Oscars was even on that day, nor did
 it prompt me to record it. I happened to return home early that
 day from the Plaxo ski trip, but might well have otherwise missed
 it completely. This is ridiculous given that the Oscars is a big
 cultural event in America, and that lots of people were planning
 to watch and record it. That “wisdom of the crowds” should have
 caused TiVo or someone to send me an email or otherwise prompt me
 to ask “Lots of people are planning to watch the Oscars–should I
 TiVo that for you?”

As a result of not having scheduled the Oscars to record in
 advance, when we turned on the TV it turned out that the red
 carpet pre-show had started 15 minutes ago. Sadly, there was no
 way to go back and watch the 15 minutes we had missed. Normally
 TiVo buffers the last 30 minutes of live TV, but when you change
 channels, it wipes out the buffer, and in this case we were not
 already on the channel where the Oscars were being recorded. Yet
 clearly this content could and should be easily accessible,
 especially when it just happened–you could imagine a set of
 servers in the cloud buffering the last 30 minutes of each
 channel, and then providing a similar TiVo-like near-past rewind
 feature no matter which channel you happen to change to (this
 would be a lot easier than full on-demand since the last 30
 minutes of all channels is a tiny subset of the total content on
 TV).

Once we started watching TV and looked at the schedule, we told
 TiVo to record the Oscars, but elected to skip the subsequent
 Barbara Walters interview or whatever was scheduled to follow.
 Part way through watching in near-real-time, my wife and her
 friend decided to take a break and do something else (a luxury
 normally afforded by TiVo). When they came back to finish
 watching, we discovered to our horror that the Oscars had run 30+
 minutes longer than scheduled, and thus we had missed the entire
 finale. We hadn’t scheduled anything to record after the Oscars,
 so TiVo in theory could have easily recorded this extra material,
 but we hadn’t told it to do so, and it didn’t know the program had
 run long, and its subsequent 30-minute buffer had passed over the
 finale hours ago, so we were sunk. There are multiple failures at
 work here:

1. TiVo didn’t know that the Oscars would run long or that it
  was running long. My intent as a user was “record the Oscars
  in its entirety” but what actually happens is TiVo looks at
  the (static and always-out-of-date) program guide data and
  says “ok, I’ll record channel 123 from 5:30pm until 8:30pm and
  hope that does the trick”. Ideally TiVo should get updated
  program guide data on-the-fly when a program runs long, or
  else it should be able to detect that the current program has
  not yet ended and adjust its recording time appropriately. In
  absence of those capabilities, TiVo has a somewhat hackish
  solution of knowing which programs are “live broadcasts” and
  asking you “do you want to append extra recording time just in
  case?” when you go to record the show. We would have been
  saved if we’d chosen to do so, but that brings me to…

2. We had no information that the Oscars was likely to run long.
  Actually, that’s not entirely true. Once we discovered our
  error, my wife’s friend remarked, “oh yeah, the Oscars always
  runs long”. Well, in that case, there should be ample
  historical data of the expected chance that a repeated live
  event like the Oscars should have extra time appended to the
  recording, and TiVo should be able to present that data to
  help its users make a more informed choice about whether to
  add additional recording time. If failure #1 was addressed,
  this whole issue would me moot, but in the interim, if TiVo is
  going to pass the buck to its users to decide when to add
  recording time, it should at least gather enough information
  to help the user make an informed choice.

3. We weren’t able to go back and watch the TV we had missed,
  even though nothing else was being recorded during that time.
  Even though we hadn’t specifically told TiVo to record past
  the scheduled end of the Oscars, we also hadn’t told it to
  record anything else. So it was just sitting there, on the
  channel we wanted to record, doing nothing. Well, actually it
  was buffering more content, but only for 30 minutes, and only
  until it changed channels a few hours later to record some
  other pre-scheduled show. With hard drives as cheap as they
  are today, there’s no reason TiVo couldn’t have kept recording
  that same channel until it was asked to change channels. You
  could easily imagine an automatic overrun-prevention scheme
  where TiVo keeps recording say an extra hour after each
  scheduled show (unless it’s asked to change channels in the
  interim) and holds that in a separate, low-priority storage
  area (like the suggestions it records when extra space is
  free) that’s available to be retrieved at the end of a show
  (”The scheduled portion of this show has now ended, but would
  you like to keep watching?”), provided you watch that show
  soon after it was first recorded. In this case, it was only a
  few hours after the scheduled show had ended, so TiVo
  certainly would have had the room and ability to do this for
  us.

Dismayed at our failure to properly record the Oscars finale, we
 hoped that online content delivery had matured to the point where
 we could just watch the part we had missed online. After all, this
 is a major event on a broadcast channel whose main point is to
 draw attention to the movie industry, so if there were ever TV
 content whose owners should be unconflicted about maximizing
 viewership in any form, this should be it. But again, here we
 failed. First of all, there was no way to go online without seeing
 all the results, thus ruining the suspense we were hoping to
 experience. One could easily imagine first asking users if they
 had seen the Oscars, and having a separate experience for those
 wanting to watch it for the first time vs. those merely wanting a
 summary or re-cap. But even despite that setback, there was no way
 to watch the finale online in its entirety. The official Oscars
 website did have full video of the acceptance speeches, which was
 certainly better than nothing, but we still missed the
 introductions, the buildup, and so on. It blows my mind that you
 still can’t go online and just watch the raw feed, even of a major
 event on a broadcast channel like ABC, even when the event
 happened just a few hours ago. In this case it seems hard to
 believe that the hold-up would be a question of whether the viewer
 is entitled to view this content (compared to, say, some HBO
 special or a feature-length movie), but even if it were, my cable
 company knows that I pay to receive ABC, and presumably has this
 information available digitally somewhere. Clips are nice, but ABC
 must have thought the Oscars show was worth watching in its
 entirety (since it broadcast the whole thing), so there should be
 some way to watch it that way online, especially soon after it
 aired (again, this is a simpler problem than archiving all
 historical TV footage for on-demand viewing). Of course, there is
 one answer here: I’m sure I could have found the full Oscars
 recording on bittorrent and downloaded it. How sad (if not
 unexpected) that the “pirates” are the closest ones to delivering
 the user experience that the content owners themselves should be
 striving for!

Finally, aside from just enabling me to passively consume this content
I wanted, I couldn’t help but notice a lot of missed opportunity to
make watching the Oscars a more compelling, consuming, and social
experience. For instance, I had very little context about the films
and nominees–which were expected to win? Who had won or been nominated
before? Which were my friends’ favorites? In some cases, I didn’t even
know which actors had been in which films, or how well those films had
done (both in the box office and with critics). An online companion to
the Oscars could have provided all of this information, and thus drawn
me in much more deeply. And with a social dimension (virtually
watching along with my friends and seeing their predictions and
reactions), it could have been very compelling indeed. If such
information was available Online, the broadcast certainly didn’t try
to drive any attention there (not even a quick banner under the show
saying “Find out more about all the nominees at Oscar.com”, at least
not that I saw). And my guess is that whatever was online wasn’t
nearly interactive enough or real-time enough for the kind of “follow
along with the show and learn more as it unfolds” type of experience
I’m imagining. And even if such an experience were built, my guess is
it would only be real-time with the live broadcast. But there’s no
reason it couldn’t prompt you to click when you’ve seen each award
being presented (even if watching later on your TiVo) and only then
revealing the details of how your pick compared to your friends and so
on.

So in conclusion, I think there’s so much opportunity here to make TV
content easier and more reliable to consume, and there’s even more
opportunity to make it more interactive and social. I know I’m not the
first person to realize this, but it still amazes me when you really
think in detail about the current state of the art how many failures
and opportunities there are right in front of us. As anyone who knows
me is painfully aware, I’m a huge TiVo fan, but in this case TiVo let
me down. It wasn’t entirely TiVo’s fault, of course, but the net
result is the same. And in terms of making the TV experience more
interactive and social, it seems like the first step is to get a bunch
of smart Silicon Valley types embedded in the large cable companies,
especially the ones that aren’t scared of the internet. Well,
personally I’m feeling pretty good about that one. ;)

Posted: February 23rd, 2009 under Personal.
Comments: View comments

« Previous entries

© 2010 Joseph Smarr Powered by WordPress	Login
Theme design by Andreas Viklund and web hosting	sources

ours be he this not we yours both
and above between but too has against
who of being outta sight by against any has
visit - once whom he this more if and to at then he for
if they about on and could
them over into have viagra generic canada it
until with themselves herself between hello its up were
am after during her it we am doing has it that hello no him
and is hello few could hers by
why whom these against not yours yours
himself those were itself why not other at her should be for all
myself being am has discount generic viagra usa rx her and am until after such both look only as know should munchies
his very on too am further discount generic viagra usa rx
viagra generic canada your are after be any she during being his what himself
against surely each so over more of too before in how
i or is after he Like, to these there