Sam Rayner

Statto - The Ultimate stats tracker

2016-12-07T15:54:00+00:00

I don’t really blog about Ultimate Frisbee but when I’m not looking at a screen it’s what I’ll be out doing or at least thinking about.

For the past two years I’ve had the privilege of representing Great Britain, competing in the Mixed division at the European and World Championships. I also coach and captain the local club team, Sheffield Steal and help coach Sheffield’s university teams.

Ultimate is growing rapidly in popularity and recognition as a sport. With that growth has come an increasing desire for advanced statistical analysis to gain a better insight into player performance and team strategies.

It will be many years before Ultimate has the funding for the kind of GPS player tracking of more mainstream sports. In the meantime, I’ve developed an app for the iPhone and iPad to allow coaches, broadcasters and fans to track and analyse Ultimate stats. It’s called Statto and is available on the App Store.

Try it out today for free, or for more information visit the website.

Discographer

2015-07-23T12:54:00+01:00

As a fun little project over the last few weeks, I’ve built a Web app that helps you discover more music by artists in your iTunes library. It’s called Discographer, and uses the Spotify API to fetch albums, ticking off the ones you own so you can see what you might have missed.

It was a nice opportunity to play with some new web APIs (Drag and Drop, File and Flexbox), the main benefit being your library is never uploaded but parsed locally in your browser. The only thing transmitted is the name of any artist you click.

It was linked on Lifehacker a couple of days ago and I’ve since received some great feedback. Please give it a go and let me know what you think!

GitHub Spectacles

2014-02-14T15:38:00+00:00

At Terracoding we regularly review pull requests from each other when working on a project. GitHub’s “Commits” and “Files Changed” tabs make it pretty painless but we wanted a way to easily view Ruby implementation files alongside their specs.

I created a bookmarklet to arrange the file pairs 2-up for review. With the files side-by-side it’s easy to spot code that isn’t covered by tests and we get a better idea of what methods are meant to do. It also hides the code of deleted files which I never bother to read during review.

To install, drag this button into your bookmarks bar:

GitHub Spectacles

Try it out on this commit. Just click the bookmark when viewing the file changes.

The CoffeeScript for the bookmarklet is opensourced on GitHub.

Octoclark Kentocat by Cameron McEfee

Retiring Lando

2013-11-12T12:24:00+00:00

Yesterday I finished porting this site to Middleman, a static blog generator written in Ruby. Since releasing Lando, I’ve barely written a line of PHP and, short of rewriting it in Ruby (which I unfortunately don’t have time to do), I’ve been put off working on Lando because of that.

I am very proud of how Lando turned out and have genuinely enjoyed using it to power my own site but it felt like it was time to switch to something written in the language I use day-to-day. If you use Lando, I am sorry I won’t be continuing its development. Rest assured it will stay open-sourced on GitHub and if anyone wants to take over managing it please get in touch.

If you’re looking for a replacement, translating my Lando templates to Middleman was remarkably simple, with the majority of helper functions and content properties matching across the two systems. I recommend it over Jekyll/Octopress which I found to be less flexible and hampered by their Liquid templates.

Thanks to everyone who tried Lando out and gave feedback. I learned a lot building it.

Alfred Lyrics Search Workflow

2013-08-04T20:05:00+01:00

Ever had the lyrics of a song stuck in your head but can’t for the life of you remember the artist or title? I get it all the time so wrote this Alfred workflow to search my iTunes library and start playing the first match it finds.

Download Lyrics Search

To get it working with your music collection you’ll need to make sure all of your tracks have lyrics downloaded for them. Don’t panic though, a great little Mac app called Get Lyrical can automate the process, tagging songs you select or tagging in the background as you play them.

Once your library is tagged with lyrics, install the workflow and type sing followed by the lyrics.

Under The Hood

For those interested in the technical side, the Workflow is just an Applescript:

on normalize(theString)
  --trim everything but letters and numbers
  return do shell script "echo " & quoted form of theString & " | tr '\r' ' ' | sed 's/[^[:space:][:alnum:]]//g'"
end normalize

tell application "iTunes"
  set theQuery to my normalize("{query}")
  --playlist 1 should be your whole music library
  set theTracks to tracks of library playlist 1
  set match to ""
  
  repeat with i from 1 to number of items in theTracks
    set theTrack to item i of theTracks
    set theLyrics to my normalize(lyrics of theTrack)
    if theQuery is in theLyrics then
      set match to (artist of theTrack & " - " & name of theTrack)
      exit repeat
    end if
  end repeat
  
  if match is not "" then
    play theTrack
    get match
  else
    get "No match found"
  end if
end tell

You’ll notice that it runs through your entire library in alphabetical order. Unfortunately, if the song you’re looking for is by ZZ Top the search is going to be a hell of a lot slower than if it were by ABBA.

Also, lyrical clichés like “oh baby” or “tell me why” are likely to produce a match earlier than you expect so try to search for longer or less common phrases.¹

If anyone has suggestions for improvements please let me know. I like the simplicity of the script so don’t plan to produce a playlist of search results or anything like that but feel free to use the Applescript as a starting point for your own script!

It’s actually pretty fun to guess at lyrics and see what songs they appear in. If a search for “hands in the air” or “in da club” return in less than 10 seconds your iTunes may be due a clear-out. ↩

Dynamic Regular Expressions

2013-05-03T19:47:00+01:00

I faced an interesting challenge while developing Sprint.ly for Alfred recently; how to provide a preview of a story title as the user typed it. A story is a concept from Agile software development that encapsulates the who, what and why of a feature.

As a site owner, I want a contact form so that visitors can get in touch.

First off, I created a Story class to hold the components of a story and a title method to get them out as a formatted string:

class Story
  attr_accessor :who, :what, :why

  def title
    #declare our separators
    prefixes = {
      who: "As a",
      what: "I want",
      why: "so that"
    }

    #go all grammar nazi
    prefixes[:who] << "n" if @who && ["a","e","i","o"].include?(@who[0,1])

    #format the story into a string
    "#{prefixes[:who]} #{@who}, #{prefixes[:what]} #{@what} #{prefixes[:why]} #{@why}"
  end
end

The tricky bit would be taking a string as input and parsing it into those attributes. I needed the title broken up to submit the parts separately to the Sprint.ly API as well as generate the preview on the fly.

I wanted the preview to start out as “As a __, I want __ so that __“, with the blanks being filled in as the user typed. I also wanted to give the option of a aa iw st shorthand to speed up entry, and to allow the blanks to be filled in any order.

Unable to write a standard regex that would cut it, I ended up with this system of appending to a regex as matches were found:

def parse_title(title)
  #default values
  @who = "__"
  @what = "__"
  @why = "__"

  #define our capture triggers
  captures = {
    "who" => "as an?|aa",
    "what" => " i want| iw",
    "why" => " so that| st"
  }

  #get things started
  regex_str = '^\s*'

  #if the prefix is present, append a named capture group to the regex
  captures.each do |key,val|
    prefix = '(?:'+val+')\s+'
    if title.match(Regexp.new(prefix, true))
      regex_str << prefix+'(?<'+key+'>.+)'
    end
  end

  #apply the final regex built from the string
  matches = title.match(Regexp.new(regex_str, true))

  if matches
    matches.names.each do |name| 
      value = matches[name].strip
      #strip out any trailing comma from the who
      value.sub!(/,$/, "") if name == "who"
      #store each component in the instance variables
      self.send(name+"=", value)
    end
  end
end

The solution greedily matches everything after a trigger phrase until another trigger is encountered and then breaks the string down.

With that done, the last thing was to trigger parsing by calling a setter method on every keystroke:

def title=(value)
  self.parse_title(value)
end

And it works pretty well!

Download Sprint.ly for Alfred to give it a spin. If you know a smarter way of doing this, I’d be really interested to hear it on Twitter or via email.