a.placebetween.us Mention

A quick shout-out (yeah, I just said that) to Chris Augeri who mentioned a.placebetween.us on his blog Forest Road!

a.placebetween.us LogoFor those who do not know, (read: everyone) A Place Between Us is a tool that will let you and someone you’re meeting find a good mid-way point for meeting.  You get to pick the type of meeting place, like “coffee” or “thai food.”

This was conceived by Aron and me (and then built by Aron) when we were working on a startup in 2007.  We were working from our homes and always looking for places to meet each other or other people.

Now you know.

Formtastic Bootstrap: Formtastic Form Generator for Twitter Bootstrap

I’ve just released the Formtastic Bootstrap gem. This provides a Formtastic-compatible form builder that will generate HTML to which the Twitter Bootstrap framework can be applied easily.

I was kind of surprised this didin’t exist already! Any feedback and/or contributions are very welcome. You can find the gem on RubyGems and the code on Github.

Panini 1.1 Released

I’ve just released a new version of Panini, a Ruby gem that generates sentences from a given grammar.  This release adds a new derivator that will exhaustively create every sentence in a grammar if called enough times.


This code:

grammar = Panini::Grammar.new

n_s = grammar.add_nonterminal
n_a = grammar.add_nonterminal
n_b = grammar.add_nonterminal

n_s.add_production([@n_a, @n_a, @n_b])  # S -> AAB
n_a.add_production(['a'])               # A -> 'a'
n_a.add_production(['x'])               # A -> 'x'
n_b.add_production(['b'])               # B -> 'b'

derivator = Panini::DerivationStrategy::Exhaustive.new(grammar)
  s = derivator.sentence
  puts s.join(' ') unless s.nil?
end while !s.nil?

Will create this output:

"a a b"
"a x b"
"x a b"
"x x b"


Tracy Hoy Clark Sold My Condo

I want to take  a few words to recount my recent and very positive experience selling my condo with Tracy Hoy Clark of Chobee Hoy Associates Real Estate in Brookline Village.  I retained Tracy after my condo had languished on the market for 10 months with two other realtors.  Five days later I had an offer which exceeded my expectations.

Tracy quickly came up with a pricing strategy and marketing approach to salvage my disaster of a sale.  She’s very knowledgeable about the area and the market.

At all times she was to the point and made things happen.  She just handled it.  Most of our communication was by text (and some email) which I appreciated.  (I’m not sure if this is always her preferred way to communicate, or if she just listend to what I said to her when we first met.  Either way, yay.)

One place where Chobee Hoy need to up their game is on their website contact form.  I initially tried to get in touch this way and it took a day for someone to get back to me. (Compare this with their Brookline Village competitor who got back to me in 10 minutes.)  However, after that small bump, we were off and running.

Your mileage may vary, but consider me one very happy customer.  If you’re in Brookline Village, Coolidge Corner, Washington Square or anywhere else in Brookline looking for a realtor, I don’t know how you’re going to do better.

A Rails Rake Task to Dump The Asset Path

Here’s a rake task that dumps out the current asset path.  For those who don’t know, the asset pipeline is a major (cool!) new feature in Rails 3.1.  I’ve been working on some gems that provide assets (javascript and stylesheets) and I’ve gotten tired of going to the console to look at the asset path.

Here’s the code:

namespace :assets do
  desc "Display asset path"
  task :paths => :environment do
    Rails.application.config.assets.paths.each do |path|
      puts path

Also available as a gist.

Idea: Coffee Meeting Matchmaker

Yesterday’s blog entry by Mark Suster, “Why You Need to Take 50 Coffee Meetings,”caused me to come up with (yet another) idea for a product. I’ve passed my 50 coffee mark some time ago, but I in no way take 250 meetings a year, as Mark suggest. And the farther along I get in my career, the more I believe that advice is sound.

But I’ve got a problem. I would take more meetings but I need to find more reasons to meet with more people. I’m not very good at this! So here’s a proposed solution: the coffee meeting matchmaker.

In short, people you know suggest people they know with whom they think you should meet for some reason which they would specify. After both parties agreed to the meeting, you’d set it up and have your coffee.

One possible refinement is that you are not given any recommendations until you make some of your own. Or alternatively you’re given some period of time to return the favor. This seems to be in the spirit of the service.

Another refinement might be requiring more than one recommender before a match is considered good. That is, I would be told I should meet a person until N number of people have said I should meet that person.

This is built off of your LinkedIn social graph. I have no idea how it makes money.

If you build it (or already did,) please let me know!

Panini: A Way to Generate Sentences From A Context Free Grammar

One of the coolest things I ever learned about were Context Free Grammars (also known as a CFG.) I’ll leave the description of CFGs to Wikipedia.

I’ve always had an interest in using CFGs to generate sentences that could be used to seed data sets, or to create a series of certain actions within a bounded set (e.g. to drive a GUI for testing purposes.)

I was never able to do that because I didn’t have the tools. So, a couple of months ago I started creating a toolkit in Ruby called Panini that would allow me to do this.

Getting Started

The gem can be installed via:

  gem install panini

You can also find the code on GitHub.


Defining a grammar is easy. Create a grammar object, add some nonterminals and then add the productions to those nonterminals.

Here’s how a grammar to create sequences of the letters “a” and “b” is defined:

  grammar = Panini::Grammar.new

  nt_s = grammar.add_nonterminal
  nt_a = grammar.add_nonterminal
  nt_b = grammar.add_nonterminal

  n_s.add_production([n_a, n_b])        # S -> AB
  n_s.add_production([n_a, n_s, n_b])   # S -> ASB
  n_a.add_production(['a'])             # A -> 'a'
  n_b.add_production(['b'])             # A -> 'b'

Sentences are created from Grammars using a Derivator. Creating the sentences from the grammar can be tricky, and certain derivation strategies may be better for some grammars.

  derivator = Panini::DerivationStrategy::RandomDampened.new(grammar)

To generate a sentence, call the derivator’s sentence method like thus:

derivator.sentence -> ['a', 'a', 'b', 'b']

You will get a new sentence (depending on the grammar) with every call:

derivator.sentence -> ['a', 'a', 'a', 'a', 'b', 'b', 'b', 'b']

Check out the README at GitHub to learn more!