iWear.

We went a year or more without a grill, until the weather showed some signs of life this spring. At that point, I decided to do some research online and ended up buying a Dyna-Glo grill from Amazon for about $275. The grill got excellent reviews so I was looking forward to trying it out.

Though I assembled the grill and hooked it up to a propane tank a couple of weeks ago, I didn't get to christen it until tonight. I cooked up chicken for my wife, hot dogs for my kids and a nice big steak for myself. The grill fired up instantly, cooked all three to near perfection (I need to leave myself some room to grow as a griller) and didn't disappoint, despite the already high expectations.

It felt good to barbeque again.

She joined our family back in 2008, just a couple months before our daughter was born, and she has now left our family way too soon after becoming very sick. I'll always remember her for the restraint she showed while enduring our two toddlers' investigative curiosity, and our house already feels too empty without her here.

Of all the mixtapes I recorded, there was one that I might have listened to the most. Up until tonight, I could only gather that I had recorded it sometime in the 80s. I don't know if any of it came from the radio or if it was all sourced from my dad's 45s, but I know it ran the gamut from songs like Bill Haley and the Comets' "See You Later Alligator" to Johnny Preston's "Running Bear" to Barry Mann's "Who Put the Bomp". It was more eclectic than that, though, because it also featured an undeniably 80s synthpop song that has stuck in my head for decades.

Over the past several years, I've tried to find both that mixtape and the name of that one particular song to no avail. The latter has driven me more and more crazy as of late, since I'm usually pretty good at remembering or picking out a few lyrics in order to find a song via Google. As embarrassing as it is to admit, I had always misinterpreted the lyrics of the only part of the song I could truly remember, so it left me severely handicapped when trying to track down the song through lyrics alone. I even went so far as to try humming the tune into midomi, but no dice.

Tonight, I gave Google another try and searched for a portion of the lyrics I was pretty sure about: "if I am right or if I'm wrong." Buried among some Roberta Flack-related links was a single link to the lyrics to a song named "That Smiling Face." I was pleasantly surprised to read through the lyrics and realize that "That Smiling Face," a song by a German synthpop group named Camouflage that was released in the U.S. in 1988, was the song that had been eluding me for so long.

Here's a video of the band performing "That Smiling Face" in Dresden in 2006:

Long live the 80s!

Anyone who has worked on speech recognition knows that the more sounds you have to work with, the easier it is to recognize the spoken utterances. In fact, if you pay close attention to the hypothesis -- the text utterance generated based on your spoken utterance -- returned by the dictation engines built into Windows or under the hood of Google's iOS app, you'll notice that some of the words actually change while you're speaking. For example, as you're saying something like "where is the stadium from here?" you may see a progression of hypotheses appear such as "were is" followed by "where is the" and so forth. As the underlying speech recognition engine gathers more sounds, it can contextualize the words in such a way that it forms a stronger, and more likely, hypothesis of what you actually said.

Since more data is better, it's easy to see how users' familiarity and comfort with "Google search speak" actually poses a problem for speech recognition. In fact, I feel it is one of the biggest hurdles that speech recognition will have to overcome in order to become a more natural (see NUI) and widely used form of input.

That leads me to the point of this blog entry, which is that Facebook Graph Search, despite any of its other strengths and weaknesses, is a step in the right direction for speech recognition. In an article titled For Search, Facebook Had to Go Beyond 'Robospeak', it is revealed that the team that built Graph Search included two linguists and focused on teaching "Facebook's computers how to communicate better with people." In fact, the lead of the natural language processing part of the project is quoted as saying "It used to be you had to go to the computer on the computer's terms. Now it's the user."

Teaching computers to communicate more like humans is a big part of the sea change that needs to happen. The bigger part, though, is teaching users that it's okay to talk to computers like they talk to other humans. That is a hard problem to solve, and it is going to take a while, particularly since the gigantic troves of data the big powerhouses like Google and Microsoft base their speech-enabled search products on are made up mostly of typed search queries. With another powerhouse like Facebook changing the paradigm of how users search, though, users are getting their first chance to build some trust with a more "human-like" interface. Once that trust becomes more widespread, it won't be long before the more popular VUIs begin to rely on or at least more openly encourage human-speak vs. robospeak.

With Facebook taking the lead with Graph Search and already cozying up to linguists and the like, it isn't that big of a stretch of the imagination to picture them getting into the speech recognition space themselves in the not-too-distant future.

Since that moment in 2008, I've made no changes to my Internet package or my basic cable TV package. Here's what my average monthly Comcast bill has looked like since then:

The future doesn't look so awesome anymore.

The first thing you'll notice if you try to build your own Tumblr API-consuming application is that they immediately gloss over the first roadblock to building one: authentication. For example, the whole process of using OAuth to gain access is covered with the following three sentences:

Tumblr supports OAuth 1.0a, accepting parameters via the Authorization header, with the HMAC-SHA1 signature method only. There's probably already an OAuth client library for your platform.

If you've worked with Twitter's OAuth implementation, you'll feel right at home with ours.

Passing the responsibility for documentation off to Twitter, a direct competitor? Really? Granted, Twitter's API documentation sets the gold standard, but at least try!

It's that glossing over of the details that led me to wasting far too much time trying to obtain my OAuth access token and secret key. There is no definitive sample code on their site, but there is a handful of scripts that lead one to believe that the process is straightforward; however, that was not my experience.

What I found when running those scripts is that the final step of requesting the access token would always return a result of "Missing or invalid oauth_verifier." I was using the scripts as-is, only modifying the consumer key and secret, and having absolutely no luck. After contacting Tumblr support and being told my question was "too technical," it was recommended that I post a question in the Google Groups Tumblr API discussion forum. However, that forum requires you to apply to join just in order to ask a question. Like I said previously -- the bar to entry is unnecessarily high.

After contacting the developer behind one of the aforementioned scripts and not receiving a response, I decided to roll up my sleeves again and try to tackle the problem from a different angle. Since I was following the scripts to a tee and not having any luck, and getting an error that doesn't seem to have been run into very often by anyone else (yet), I wondered if maybe the version of my oauth2 module (1.0.2) was newer than the one used by those who had found success with those scripts. Or maybe it didn't support the older 1.0a version of OAuth that the Tumblr API still requires (though Wikipedia claims OAuth 2.0 should be backward-compatible).

Those thoughts led me to a different OAuth module for Python called Rauth. I very quickly tweaked their example code to work with the Tumblr API instead of Twitter's and ran the script. To my dismay, the script raised an exception:

TypeError: session() takes no arguments (1 given)

Because the script working out of the box would just be too easy, right? Upon realizing that the error was being thrown from within the Requests module that Rauth depends on, I was lucky enough to stumble upon a Stack Overflow post mentioning that a recent Requests version change was littered with backward-incompatible changes. It recommended rolling back to version 0.14.2, so I did the following from the command-line (on Linux):

sudo pip install --upgrade requests=0.14.2

I then ran my modified script again, and lo and behold, it ran to completion and printed out my access token and secret.

If you're at all interested in the script I ended up using to do so, you can check it out on Github.