Here are some pics of it in action:

and

Press: New York Times, CNet, Seattle PI, Seattle Times, Read Write Web

]]> http://www.codepresencelabs.com/2010/08/24/bing-food-cart-finder/feed/ 0 http://www.codepresencelabs.com/2010/08/15/home-turf-finder/ http://www.codepresencelabs.com/2010/08/15/home-turf-finder/#comments Mon, 16 Aug 2010 02:32:48 +0000 josh http://www.codepresencelabs.com/?p=58 Home Turf Finder was a Bing Map App, developed in Silverlight and Javascript (downlevel) for Bing Maps to help users find a great place to watch their favorite team during the 2010 World Cup.  It mashed up data from Bing Maps, ThrillList and FourSquare to show the most popular destination to watch your team.  We did all of the development work for this application and worked with 8Ninths and Microsoft Marketing to bring it to completion.  This application was covered by TechCrunch, ThrillList, and others.

In short the gem monitors the queries that your server is making and notifies you as to whether or not you are encountering any N+1 scenarios.  It also notifies you as to whether or not you have unused eager loads.  It can be configured to notify you via javascript alerts, growl notifications, firebug notifications, or just log the instances.

Thus far it has been invaluable in finding instances where an eager load would help.  It can (and should) be configured to run only in Development mode and will sit in the background until it has something to notify you about, so you can just turn it on, keep coding, and as you browse around your local instance, get notified as to potential areas for optimization.

While it is definitely worth installing a few things to note:

1. You still need to use your judgement as to what is the right call, this just points out areas to investigate (though it does tell you what models to include)
2. It has some bugs still.  There are instances where it correctly insists that you should include something, and then incorrectly tells you that you have an unused eager load once you include it

If you have your development.rb file in source control and shared among developers, one slight modification to the code on the github site that removes the gem dependency from your fellow developers is as follows:

  
config.after_initialize do
begin
require 'bullet'
Bullet.enable = false
Bullet.alert = false
Bullet.bullet_logger = true
Bullet.console = true
Bullet.rails_logger = true
Bullet.disable_browser_cache = true
begin
require 'ruby-growl'
Bullet.growl = true
rescue MissingSourceFile
end
rescue MissingSourceFile
end
end

IDE

 For an IDE I am using EasyEclipse for LAMP which is a nice little package.  It uses Eclipse as its base IDE but integrates plugins for PHP, Python, Ruby on Rails (not that good), Subclipse and others.  Just download the latest build and install it.

XAMPP

 To run locally you can install WAMP (I used to use this, it was good) or XAMPP.  I am trying XAMPP for now because it is integrated nicely into Eclipse.  Out of the box you will get MySQL, Apache, FileZilla and Mercury up and running if you install this.

At this point you can import directly from you subversion repository into the xampp\htdocs directory and you should have a working enlistment deployed (make sure Apache is started) to http://localhost/your_enlistment

There are a few more things that you might want to install, including PEAR and Memcached.

PEAR

To install PEAR for XAMPP, open a command prompt (cmd.exe) as an Administrator (Vista only).

Then navigate the your xampp\php\PEAR\PEAR and execute the go-pear.phar script (its PHP) via:

php go-pear.phar

You should be able to use the default settings (unless you’ve tweaked your XAMPP installation).  When prompted as to whether you would like to update your php.ini file, say Yes.

At this point you should be done and can now reference PEAR libraries in your PHP scripts.

Memcached

If you need memcached you can get this up and running in a variety of ways.  If you want to build from source you can find it here.  Otherwise search for a pre-compiled windows32 version.  Copy the binaries to some place on your development machine and then you will need to start and install the service.

To install the service open a command prompt as an administrator and navigate to the directory with memcached.exe.  Install the service by typing: memcached -d install

To start the service type: memcached -d start

Note that the default reserved cache size for memcached is only 64MB, so if you would like it to be larger, launch the service and append a -m followed by the number of megabytes as an integer.  So to launch and reserve a half gig you would launch it as: memcached -d start -m 512

Now that the service is running, you will need to let php know that it is.  Make sure that you have the correct extension (php_memcache.dll) in the php\ext folder in your xampp directory.  After you have verified that this is there, you should update the php.ini file and uncomment (remove the preceding “;”) the following line:

extension=php_memcache.dll

Make sure that this is the php.ini file associated with apache if you want to test this on your local pc (i.e. the one in your apache folder), otherwise you will just have access to this via the CLI version of PHP.  Restart Apache and you should be good to go.  If you are having issues make sure that there is a Memcache section in your phpinfo() output to verify that the extension is being loaded.

Hope this helps, leave any questions in the comments and I’ll try to help.

The SpeechRecognitionEngine class can load one or many Grammar objects. The MSDN page describes these Grammar objects in the following way:

The System.Speech.Recognition..::.Grammar class provides run time objects that allow an application to specify a specific combination of words, choices of words, and other speech elements that the Speech platform uses to identify meaningful phrases.

The Grammar object fully supports the W3C Speech Recognition Grammar Specification (SRGS) and Context Free Grammar (CFG) specifications. For more information, see SpeechRecognitionGrammar Specification.

Grammars may be precise word phrases, such as “Turn the computer off,” or provide choices, semantic lookup tables or wildcards, such as “Change color to” and a look up table of acceptable values.

An application’s recognition engine, as managed by instances of SpeechRecognizer or [T:System.Speech.Recognition.SpeechRecognitionEngine,] may create and load one or more instances Grammar, independently enabling or disabling particular grammars instance, and set Grammar properties such as priorities (Priority and weight (Weight)

So you can see that we can construct Grammars that will recognize certain types of input and then load these into the SpeechRecognitionEngine. These can be prioritized to help with conflict resolution as well as toggled on and off if you know that only certain grammars are appropriate for a certain context.

So how do we construct these grammars? Grammars can be constructed in a variety of ways, but we are going to examine the GrammarBuilder Class as this is the easiest way to programmatically construct a Grammar.

The simplest example is simple string matching. If you have a discrete atomic command (e.g. shutdown) that takes no parameters, you can initialize a GrammarBuilder with a string and it will fire its recognize event when that string is heard.

  
GrammarBuilder stringGb = new GrammarBuilder("shutdown");

If this was added to a Grammar and loaded in the Recognizer it would fire a recognized event for this Grammar whenever the word “shutdown” was heard. This is easy enough, but somewhat limited, because what if you wanted to also allow them to say “turn off” or “quit”? At this point you would have to add 3 Grammars, one with each of those strings. Enter the Choices class.

The Choices class allows us to create a phrase where one part of the phrase may have many different acceptable values. In our above example, we want the verbs “shutdown”, “turn off” and “quit” to be interchangeable. To show how this can be used with a phrase, lets make the user ask nicely by preceding either of those with “please”.

  
GrammarBuilder choicesGB = new GrammarBuilder("please");
Choices verbChoices = new Choices("shutdown", "turn off", "quit");
choicesGB.Append(verbChoices);

Now our grammar will trigger an event for all of the following phrases:

• please shutdown
• please turn off
• please quit

You can probably now imagine how you could combine strings and choices to come up with a variety of different recognizable phrases. However, there is a lot more that this engine can handle, but before we get into that lets review what happens when a phrase is recognized by the SpeechRecognitionEngine.

Remember that when a phrase is recognized, all that the engine will trigger is a SpeechRecognizedEvent to which you can assign a handler. This same event is fired for all phrases in all grammars that are loaded, so the problem becomes figuring out which phrase triggered the event. There are numerous strategies for dealing with this so I won’t go into detail here, but note that the SpeechRecognizedEventArgs object has a RecognitionResult that contains a pointer to the Grammar as well as the Text of the phrase in addition to any Semantic Values that you have assigned (more on that later). For an example see [post=16 text='here'].

Why take that little detour? Because once you’ve tried to actually do something with the result of a recognition event you’ll realize the utility of SemanticValues. Semantic Values allows you to assign values to certain responses so that you do not have to do annoying string parsing in the event handler.

Our first basic example will show how we can simply get the appropriate text in the event handler without having to do string parsing. Lets say that we know that the user is either going to say ‘yes’ or ‘no’ to a request, but we want to recognize synonyms of those phrases. We can do something like the following:

  
GrammarBuilder yesChoices = new Choices("yes", "yeah", "ok").ToGrammarBuilder();
yesChoices.Append(new SemanticResultValue(true));
GrammarBuilder noChoices = new Choices("no", "nope").ToGrammarBuilder();
noChoices.Append(new SemanticResultValue(false));
Choices allChoices = new Choices(yesChoices, noChoices);
SemanticResultKey choiceKey = new SemanticResultKey("YesNoBool", allChoices);
GrammarBuilder choiceGB = new GrammarBuilder(choiceKey);

What does this do for us? It creates a GrammarBuilder that has 2 choices. Each of these Choices has a SemanticValue that can be obtained in the recognition handler. Semantically there is a Yes choice (which is actually itself a choice of “yes”, “yeah” and “ok”) and a No choice (“no” and “nope”). The Recognition engine, since we have assigned semantic values to these, will set the “YesNoBool” variable to either true or false depending on which Semantic choice the user makes. This is great for us. No string parsing, and thus we can easily build up grammars with many synonyms and never worry about adding more complexity in the event handler.

So far we have looked at inputs that are just combinations of predefined words. This is great for many scenarios, but what if we want to allow more free form input? Lets say that our grammar is built to allow users to get a current stock price. You would probably want to match on any of the following phrases:

• Show me the stock price of foo
• Let me see the stock price of foo
• What is the price of foo

Here foo may be any stock ticker and lets say we’re lazy so we don’t want to hard code all of them. The solution lies in the DictationGrammar class. This class is exactly what it sounds like–a class for dealing with understand user dictation. Now, extracting the ‘foo’ from any of those in the event handler could be error prone, especially as you add more and more recognized ways of asking for a stock price. This is where semantic values come into play again. So lets see how this might work:

  
GrammarBuilder stockGB = new GrammarBuilder();
GrammarBuilder dictation = new GrammarBuilder();
dictation.AppendDictation("spelling");
stockGB.Append(new Choices("Show me the stock price of", "Let me see the stock price of", "What is the stock price of"));
stockGB.Append(new SemanticResultKey("DictationInput", dictation));

This code creates a choice of antecendents and then appends a SemanticResultKey whose name is DictationInput. Note that since we assigned no semantic value, the value that is assigned to DictationInput will be the actual text of the dictation. Finally, note that when we created the Dictation we passed the parameter “spelling”. This was to let the Recognizer know that we wanted the user to spell out the ticker name and that it should not interpret the input as words. If we had not passed that parameter it would have tried to match the input to words. That type of dictation might be useful if you were trying to build a voice IM client for example.

That’s all for now. Good luck and let me know if you build anything cool