Bytes of Pi

Brandr Open Sourced

Mon, 25 Feb 2013 22:05:00 -0500

I have no reason to call this “intellectual property” anymore. I have released the code that drives this cool little demo: http://landr.co/brandr/ This project was about 2 weeks of coding, testing, and understanding—having late nights, and a lot of white-boarding to figure out the best way to extract colors from brands. Notice, I say “brands”. It’s not just colors from an image, it’s the human interpretation of a gestalt; and that’s why it is a tough problem. Click on the title above, or here for the Github repo.

Installing suPHP with Plesk 11 on Media Temple DV4

Mon, 25 Feb 2013 01:13:00 -0500

I ran into major dependency issues trying to follow this tutorial provided in the Media Temple knowledge-base. Normally it is recommended to install suPHP by compiling it from source (as mentioned in the tutorial), but mainly because of the mode that suPHP is put into during the installation. The reckoning for suPHP is well-put here, with the three modes of operation being:

owner: Run scripts with owner UID/GID
force: Run scripts with UID/GID specified in Apache configuration
paranoid: Run scripts with owner UID/GID but also check if they match the UID/GID specified in the Apache configuration

The advantage of compiling from source is that suPHP can run in paranoid mode—however, as the previous link states: Although suPHP states that the default mode is “paranoid”, the libapache2-mod-suphp is installed in “owner” mode by default. When suPHP is installed in “owner” mode, the directive suPHP_UserGroup is not recognized which is required for “force” or “paranoid” mode.

Running suPHP in owner mode doesn’t seem all-that-bad, considering it is in fact the default for some installations. However, the comment about not having access to the “suPHP_UserGroup” within your configuration file is true, and if you try to restart Apache with it in there (as the Media Temple tutorial suggests), it will result in an error, and possibly crash your server.

My workaround is to remove any of the lines that include “suPHP_UserGroup”, and simply use yum to install suPHP, which lets you skip steps 1-4 in the tutorial.

yum install mod_suphp

SlipPay: An Online Receipt Marketplace

Sat, 16 Feb 2013 15:33:00 -0500

SlipPay: An Online Receipt Marketplace:

I couldn’t understand why cash-based receipts have not been exploited. It is so seemingly simple to return your “used” stuff, if only you had that magic receipt. Let me know what you think!

Why I can Judge Your Design Work

Fri, 01 Feb 2013 11:09:00 -0500

I write code. I love logic. And I still know what beautiful is.

Of course, there is no true judge of artful things. However, artists still have a tendency to believe their eyes are not only different, but a better judge of artistic character, aesthetic presence, and visual impact. This is wrong, and I’ll tell you why.

I may not be a wonderful chef, but I know when my steak is under-cooked, or over-seasoned. I am not on any New York Times best-seller list, but I can tell who is a good novelist after a couple chapters. I can’t paint, but it is easy to see when someone has a grasp on lighting, shapes, and colors. I don’t have many music abilities, but I could spot the difference between a high school band, and a renowned symphony orchestra.

Being a good creator has no affect on your ability to consume, and no affect on your ability to judge– it may only affect your historical knowledge or appreciation of the subject matter. When you compose a piece of art, whether it be digital or mechanical, on canvas or on film, you must accept the interpretation of the consumer.

If you can bring new perspective to your artwork by telling a story, or bringing forth some element of enlightenment in those who consume it, you are truly a great artist. But if you think that because someone doesn’t see it your way, or find something more or less beautiful than you, do not blame it on their experience, their lifestyle, their career, or your ignorant predispositions about their ability to artistically, aesthetically, or visually intake something– blame it on your shitty art.

Creating Rows with ExpressionEngine and a Grid

Fri, 01 Feb 2013 11:07:00 -0500

Below is an image from my digital library that I developed to help me organize my research for an upcoming book. It uses a responsive grid, and I’ll show you how to create it using Bootstrap and methods available within ExpressionEngine (no modulo!).

Let’s take a look at how Bootstrap implements their grid (knowing other grid systems are similar), and in particular, a 4-column grid.

<div class="row">
  <div class="span3"></div>
  <div class="span3"></div>
  <div class="span3"></div>
  <div class="span3"></div>
</div>

The only complexity within ExpressionEngine you face is that you have repeating elements for the “span3” class, but the rows also need to repeat as the page continues! The switch statement comes to the rescue in a somewhat unexpected way.

<div class="row">
  {exp:channel:entries channel="books" orderby="title" sort="asc" dynamic="no"}
    <div class="span3"></div>
    <div class="span3"></div>
    <div class="span3"></div>
    <div class="span3"></div>
    {switch='|||</div><div class="row">'}
  {/exp:channel:entries}
</div>

Why is this a little tricky? Well, even though the entire EE channel loop appears to be wrapped by a row element, it’s not. The closing (and opening) of the first, and all subsequent rows, is handled in the switch statement. The last and final closing “</div>” is actually closing a row that came from the switch statement.

If you are used to hardcoding this type of stuff in PHP, your mind may instantly jump to using some type of modulo plugin to do this, but fortunately you can scratch that complexity right out. Here is what my entire page looks like, using Assets for the image.

{embed="partials/_head"}

<h2>Books</h2>

<div class="row">
  {exp:channel:entries channel="books" orderby="title" sort="asc" dynamic="no" disable="custom_ﬁelds|member_data|pagination|trackbacks"}
    {if no_results}
      <div class="span12"><p>No entries yet.</p></div>
    {/if}
    <div class="span3">
      {research_cover}
        <a href="{path='book/entry/{url_title}'}"><img class="img-polaroid img-rounded" src="{url:tall}" alt="{alt_text}"/></a>
      {/research_cover}
      <h5><a href="{path='book/entry/{url_title}'}">{title}</a></h5>
      <p class="center"><small>{if book_bought}&#x2713; you own this{/if}</small></p>
    </div>
    {switch='|||</div><div class="row">'}
  {/exp:channel:entries}
</div>

{embed="partials/_foot"}

Timebomb.it is a Time-sensitive Short Link for Passwords

Tue, 29 Jan 2013 17:43:00 -0500

I built timebomb.it a long time ago and gave it a quick refresh this afternoon. I still see this problem popup all over the place– people sending passwords in emails. Worse yet, starting the email with, “here is the password”. All it takes is access to someones email account to retrieve all these passwords, or bank account numbers, or social security numbers.

This mobile-friendly website allows you to make confidential information available for only 1 hour, 1 day, or 1 week. When the time is up, so is the data, and it is erased forever. Everything runs under an SSL certificate (HTTPS) so everything transmitted is encrypted, and secure. Also, every link comes in a clean, sendable format (eg. “https://timebomb.it/637jv8gfmd”). Give it a try, and save yourself (and your clients!) from a security catastrophe down the road.

I added an ultra low-profile sliding table top (on an angle!) to...

Mon, 28 Jan 2013 19:20:00 -0500

I added an ultra low-profile sliding table top (on an angle!) to my desk this weekend. It collapses just enough so my cup of water always has a spot on a nice felt pad. It has an 18” throw which is perfect for a laptop, some books, or bundles of papers. It slides, it floats, it’s simple, and only cost $28 worth of parts at Home Depot. Even with that fancy chair from Target I am still sub-$200 on this desk (see my first post about this).

Git Video - Supplementing Github Commits with Video!

Wed, 23 Jan 2013 16:45:00 -0500

Special thanks to the team over at Nimbb for sponsoring this project with some free video space. A company willing to go out of the way for independent developers deserves a look— so check them out!

Ever come back to a project and completely forget how all the pieces fit together? Supplement your commits with Git Video.

That half-sentence you throw into the commit message usually does no help when you have walked away from a project for more than a day. Projects take major evolutions— architecture, ideologies, and approaches to problems are constantly changing, and documenting them becomes hard. A short video connected to each commit on Github is perfect, and lets you use gestures, inflection, and visuals to help you remember what state the project is in at that point in time.

Doing this once a day will help you battle that incessant, twenty-minute, “back into the groove” you usually have to entertain when switching between projects. It was created in a night on Rails, uses Github’s API, designed with Bootstrap, launched on Heroku, monitored with New Relic, and relies on Nimbb for the video embedding.

"Before the “lean startup methodology” made beta testing de rigeur, companies would..."

Thu, 16 Aug 2012 13:50:00 -0400

“

Before the “lean startup methodology” made beta testing de rigeur, companies would perform “pilots” with little to no feedback from the front lines. This strategy of ignorance often led to the development of technology that actually made educators less efficient.

As a teacher and one allowed into the inner sanctum of ImagineK12, I can tell you that today’s entrepreneurs are different. They care about listening to teachers and acting on insightful, productive feedback. They know that it’s not enough to be a respectful and good listener; these entrepreneurs have learned to let teachers know when they act on the feedback they’ve received.

”

- Jennie Dougherty, a teacher in Brockton, Mass., who cofounded Edupgrade and blogs at BetaClassroom.

Simple Status Ticker for API Endpoints

Thu, 09 Aug 2012 18:02:25 -0400

When you are deploying code left-and-right, even in a test-driven development cycle, sometimes you still want the piece of mind that your website is responding. In my case, this is specific to API endpoints and different API environments we run our products on.

This script allows you to leave a mini terminal window on your screen that will refresh the status of a website at an interval of your choice. I use two gems, the first is to make the text colors pretty, and the second is for making the HTTP calls- install them like so:

> gem install httparty
> gem install terminal-display-colors

Below is the code, which can also be found on this Github gist.

require 'HTTParty'
require 'terminal-display-colors'
require 'json'

# set your endpoints!
endpoints = {
  "Google" => "http://google.com",
  "Twitter" => "http://twitter.com"
}
# seconds to sleep between pings
sleep_seconds = 10

buffer = []

def diff start, finish
  ((finish-start) * 1000.0).round(2)
end

def print_flush str
  print str
  $stdout.flush
end

while(true)
  # clear terminal
  buffer << "\e[H\e[2J"
  response_times = []
  # loop endpoints
  endpoints.each do |name, url|
    begin
      t1 = Time.now
      response = HTTParty.get url
      t2 = Time.now
      if response.code == 200
        response_times << diff(t1,t2)
        buffer << "#{name.upcase} : " + response.message.green + " (#{response_times.last}ms)".yellow
      else
        buffer << "#{name.upcase} : " + response.message.red
      end
    rescue => e
      buffer << "#{name.upcase} : " + 'Connection Error'.red 
    end
  end

  buffer << "\n"
  # display avg and max response times
  unless response_times.empty?
    buffer << "avg : #{(response_times.inject{ |sum, el| sum + el }.to_f / response_times.size).round(2)}ms".cyan
    buffer << "max : #{response_times.max}ms".cyan
  else
    buffer << 'No response times.'.cyan
  end
  # send buffered text to terminal
  puts buffer.join("\n")
  buffer.clear

  # sleep
  sleep_seconds.times
    sleep 1
    print_flush '.'
  end
end

To use the ticker, take the code and put it into a file named `status.rb` and run the following in terminal from the directory the file is located:

> ruby status.rb

To exit the ticker, use control+c on your keyboard.

Forcing SSL in a Sinatra App

Tue, 07 Aug 2012 22:23:48 -0400

When deploying on Heroku, you can piggy back on their SSL certificate, which allows you to have a secure connection right away without any SSL configurations of your own. I think this is a great solution for a lot of people until you need a really pretty URL. Because this is possible, you should use it, and if your building an API you should also think about forcing different environments to require SSL. Here is a simple implementation in my `app.rb` file:

class Myapi < Sinatra::Application
  ActiveRecord::Base.default_timezone = :utc

  configure :development, :test do
    set :host, 'localhost:9999'
    set :force_ssl, false
  end
  configure :staging do
    set :host, 'my-api-staging.herokuapp.com'
    set :force_ssl, true
  end
  configure :production do
    set :host, 'my-api.herokuapp.com'
    set :force_ssl, true
  end

  before do
    content_type :json
    ssl_whitelist = ['/calendar.ics']
    if settings.force_ssl && !request.secure? && !ssl_whitelist.include?(request.path_info)
      halt json_status 400, "Please use SSL at https://#{settings.host}"
    end
  end
end

require_relative 'application/helpers/init'
require_relative 'application/routes/init'
require_relative 'application/models/init'
require_relative 'application/core_extensions/init'

I have left some of my app-specific code in there as well, but I am sure you can dig around that to see how SSL is forced. Notice that because downloading `.ics` files shouldn’t require SSL, or in other words, it shouldn’t fail if the user uses `http`, it is included in a whitelist array.

Multi-environment post_build_hook using tddium, Heroku, and Ruby Sinatra

Tue, 07 Aug 2012 22:05:25 -0400

We have been using tddium as a deployment tool for our Ruby Sinatra API for some time now. It has been working great and now manages deployment for 7 of our API environments. We have ran into a few small issues, but there are some sharp engineers on support, so issues get fixed fast. The most recent develop in our system is to implement a post build hook to run migrations after the app is deployed on Heroku.

One of the straight-forward adjustments I had to make to their gist is to dynamically set the app name based on the branch that was pushed to Github. In our case, each Heroku app (“environment”) has a git branch, and this is also how tddium sets up test suites, so everything jives.

The portion that required some support was apparently due to some dependency issues with my gems and the way the git repo was being pushed from tddium. The first step was to add the heroku gem to my gemfile, and from there, it was to modify the tddium post_build_hook a little bit. Here is the full version:

namespace :tddium do
  desc "post_build_hook"
  task :post_build_hook do
    return unless ENV["TDDIUM_MODE"] == "ci"
    return unless ENV["TDDIUM_BUILD_STATUS"] == "passed"

    dir = File.expand_path("~/.heroku/")
    heroku_email = ENV["HEROKU_EMAIL"]
    heroku_api_key = ENV["HEROKU_API_KEY"]
    current_branch = `git symbolic-ref HEAD 2>/dev/null | cut -d"/" -f 3-`.strip
    abort "invalid current branch" unless current_branch
    puts "Current Branch: #{current_branch}"

    case current_branch
      when 'integration'
        app_name = 'matts-api-integration'
      when 'staging'
        app_name = 'matts-api-staging'
      when 'production'
        app_name = 'matts-api'
      when 'demo'
        app_name = 'matts-api-demo'
      when 'demo-staging'
        app_name = 'matts-api-demo-staging'
      when 'pilot'
        app_name = 'matts-api-pilot'
      when 'pilot-staging'
        app_name = 'matts-api-pilot-staging'
    end

    return unless defined? app_name

    puts "App Name: #{app_name}"
    push_sha = `git rev-parse HEAD`
    push_target = "git@heroku.com:#{app_name}.git"

    abort "invalid current branch" unless current_branch

    FileUtils.mkdir_p(dir) or abort "Could not create #{dir}"

    puts "Writing Heroku Credentials"
    File.open(File.join(dir, "credentials"), "w") do |f|
      f.write([heroku_email, heroku_api_key].join("\n"))
      f.write("\n")
    end

    File.open(File.expand_path("~/.netrc"), "a+") do |f|
      ['api', 'code'].each do |host|
        f.puts "machine #{host}.heroku.com"
        f.puts "  login #{heroku_email}"
        f.puts "  password #{heroku_api_key}"
      end
    end
    
    puts "Pushing to Heroku: #{push_target}..."
    cmd "git push #{push_target} HEAD:master --force" or abort "could not push to #{push_target}"

    puts "Running Heroku Migrations..."
    cmd "heroku run rake db:migrate --app #{app_name}" or abort "aborted migrations"

    puts "Restarting Heroku..."
    cmd "bundle exec heroku restart --app #{app_name}" or abort "aborted heroku restart" 

    puts "Post Build Complete!"
  end
end

A new workspace from a $150 Ikea trip. The lights can be set to...

Sun, 05 Aug 2012 17:38:00 -0400

A new workspace from a $150 Ikea trip. The lights can be set to different colors, which can signal to others that you are busy or free to chat (“wired in”, you might say). The lights can also gently fade through the color spectrum, which is relaxing. View the Facebook album of my workspaces.

Lazy Levenshtein: Using Abbreviations and Spellchecked Inputs in Ruby

Fri, 20 Jul 2012 15:07:00 -0400

I have been spending a lot of time writing Ruby programs that take in data through the terminal. One of the problems is that mis-spelling something can cause the program to crash, and I want to be as quick as possible when doing data entry.

One of my programs asks which server environment I would like to use before I start messing with any data (development, integration, staging, production). It would be great if all of the following abbreviations or misspellings would choose the development environment, and keep the program rolling:

dev
development
devel
deevleopmnt

You get the idea- abbreviations and spellchecking from known inputs. To accomplish this I leverage the Levenshtein distance algorithm, more commonly known as “edit distance”. This algorithm compares two strings and returns an integer that is equal to the amount of edits needed to transform the first string into the second.

Here is the Github Gist for Lazy Levenshtein, with the sample code below so we can dig through it.

# test by running:
# ruby lazy.rb
# use control+c to exit
require 'amatch'
include Amatch

def lazy input, matches, abbreviations=true
  # setup the Levenshtein comparator
  distances = {}
  m = Levenshtein.new(input)
  matches.reverse.each do |match|
    # get the edit distance
    tests = []
    tests << m.match(match)
    tests << m.match(match[0..3]) if abbreviations
    
    # lowest score gets placed
    distances[tests.min] = match
  end
  # return input, returns original if matches is empty
  input = distances.empty? ? input : distances.min.last
end

environments = %w(development integration staging production)
while true
  puts "\nenvironments #{environments.join(', ')}"  
  print "choose environment: "
  input = gets.chomp
  puts "match: #{lazy(input, environments)}"
end

The three parameters are the input itself, an array of possible matches, and a boolean that tells the method whether or not you want to match abbreviations. The method sets up a Levenshtein comparison for each potential match (using the Ruby Amatch library), and scores the comparison. We are playing golf here, because the lowest score wins the game!

The method also reverses the array in the main loop, which puts priority to the first items in the array if there happens to be a tie between matches. Unlike typical “spellcheck”, this method will never return “not found”, it will always return a match, and if the “matches” array is empty, it simply returns the provided input.

This has helped me make inputting much faster with smarter defaults, and given me the piece of mind that my misspellings will always turn into known/safe values.

Article Analysis: Matching People's Names to Email Addresses

Fri, 13 Jul 2012 07:36:00 -0400

*code examples are based in ruby

The problem

Consider you are scraping web articles building a list of contacts for a PR company. Getting email addresses is as simple as a regular expression.

string = 'John Smith can be contacted at john.smith@gmail.com'
emails = []
string.scan(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}/i).each {|x| emails << x}

However, an email address is only so powerful, it would be really great if we could match a name to that email address. The problem statement is pretty simple- match email addresses in the article to the names in the article.

Finding names

So if you are thinking that finding names in text can’t be that hard, lets take a stroll down that dark alley really quick. Maybe just a regular expression that matches two capitalized strings in a row could do the trick.

/([A-Z]+[a-zA-Z]*)\s+([A-Z]+[a-zA-Z]*)/

Well, that’s cool, but what if there is a middle name, or even worse, an abbreviated name? So now, we add an optional third string to the regular expression, and allow for abbreviations.

/([A-Z]+[a-zA-Z.]*)\s+([A-Z]+[a-zA-Z.]*)+(\s+([A-Z]+[a-zA-Z]*))?/

This is looking great, and then you hit a name like Michael D’hunt, or De’Angelo Munez. Okay, so now we allow some apostrophes.

/([A-Z']+[a-zA-Z'.]+)\s+([A-Z]+[a-zA-Z'.]*)+(\s+([A-Z']+[a-zA-Z']*))?/

So right now, you run this against a list of 10,000 common names, and a boatload of Lorum Ipsum, and you have some great accuracy. However, in the real world you get a sentence like this, “And Will Smith was not alone, he included his wife Jada on his trip to San Francisco, where they stayed at Hotel Palomar”. Your regular expression just got roasted in so many ways.

Natural Language Processing (NPL)

To parse out things like names, places, dates, and going into things like differentiating languages within text, we have to get a little more fancy. Natural language processing concerns itself with the study of linguistics, using a mixture of machine learning, statistics, and artificial intelligence to provide a meaningful analysis of human languages. For all intensive purposes, we can say that it breaks apart sentences so we can interpret them better using a computer.

This is the crucial link between knowing if ‘San Francisco’ is a person’s name, or a physical place. The Stanford Natural Language Processing Group has a set of core open-source tools that can take care of some of this by implementing known language patterns, and using massive libraries of common naming schemes for people, places, and things.

Finding names, the right way

By implementing the Stanford CoreNLP Toolset, we can essentially throw some text at it, and with a couple filters we can have a list of names contained within the text. So from the sentence above, we may get a result like this.

[  
  {
    :name => "Will",
    :start => 4,
    :end => 8
  },
  {
    :name => "Smith",
    :start => 9,
    :end => 14
  },
  {
    :name => "Jada",
    :start => 51,
    :end => 55
  }
]

The ‘start’ and ‘end’ numbers refer to the string position of the name itself, and with a little magic it is possible to concatenate names if they appear together, giving a final result as follows.

["Will Smith", "Jada"]

Names to emails

This matching problem is quite problematic considering the format that an article or piece of text might come in. In a perfect world, a person’s name would appear right next to their email address.

'John Smith can be contacted at john.smith@gmail.com, and Jill Ruth can be contacted at jill.ruth@gmail.com.'

If we know the position of the name, and know the position of the email address, this is no problem- we just write a routine to find the closest email to the persons name. However this breaks down pretty quickly.

'John Smith and Jill Ruth can be contacted respectively at john.smith@gmail.com, and jill.ruth@gmail.com.'

Or even worse…

'Article written by Edward Jones

... article body ...

Contact the writer at ejones@gmail.com'

The article body itself could also contain important names and email addresses as well, scattered as they please, so this calls for some more advanced parsing techniques.

The Levenshtein distance

My take on this problem is that we can throw name-position vs. email-position out the window; it is not reliable. The one thing we can rely on is that, in most professional situations, a person’s email has some reference to their name.

This is where the Levenshtein distance algorithm comes in- it calculates the numbers of edits needed to transform one string into another. In our case, we are comparing a persons name to their email. It quickly becomes apparent that the email extension and any numbers can be removed from the email address, and normalizing the case is helpful before making the comparisons. Let’s looks at some results for John Smith (or more specifically in lower case, “john smith”).

john.smith@gmail.com -> john.smith : 1 edit
j.smith123@gmail.com -> j.smith : 4 edits
john.walker.smith@gmail.com -> john.walker.smith : 8 edits
jwsmith@gmail.com -> jwsmith : 4 edits
jws3319@gmail.com -> jws : 8 edits

So that is pretty neat, and the next step to the problem is pretty clear- we need to test a bunch of common email address patterns against the persons name, and use the best score. So instead of making comparisons with just “john smith”, we can abstract the name into some common formats.

person = "John Smith"
email = "jsmith44@gmail.com"

# remove the email extension and everything besides characters
m = Levenshtein.new(email.split('@').first.downcase.scan(/[a-z]/).join(''))

# run a standard set of tests against the persons name
tests = []
tests << m.match(person.downcase.scan(/[a-z]/).join('')) 
tests << m.match("#{person.split(' ').first.downcase[0]}#{person.split(' ').last.downcase[0]}")
tests << m.match(person.split(' ').first.downcase)
tests << m.match(person.split(' ').last.downcase)
...

best_result = tests.min

If this is run for every person and every email address found in an article, it will provide the best score for each person vs. email address.

Scores into results

With any type of artificial intelligence, there is rarely a concept of “passing a test”, there are only various levels of failure. The goal is to simply minimize failure in the best way possible, and developing with any other intention can be a destructive process. Using our scores from the previous step, we attempt to award all the emails we found to the person most deserving. Consider the following sample set.

people = ["Matt Gaidica", "Brad Birdsall", "John Smith", "Grant Olidapo", "Minh Nguyen"]
emails = ["mattyg@gmail.com", "bradbirdman17@gmail.com", "grant.olidapo@gmail.com", "mn1@gmail.com"]

The scores we produced account for every name vs. every email, or 20 (5x4) unique values. We look to some sort of complexity reduction algorithm to reduce this set of 20 data points, to only 4, which directly relate names to emails, leaving one of our people email-less. After about 20 lines of magic, our algorithm spits out the results.

{
  "Matt Gaidica" => "mattg@gmail.com",
  "Brad Birdsall" => "bradbirdman17@gmail.com",
  "Grant Olidapo" => "grant.olidapo@gmail.com",
  "Minh Nguyen" => "mn1@gmail.com"
}

Tip of the iceberg

I look at this as just one of the ways to accomplish this goal. This process can be heavily supplemented with machine learning techniques to produce better name recognition, and further develop common email address patterns for your specific type of article, document, or data set.

I have opened a library on Github called Textract, which includes the code for this entire process. My goal is to keep the problems simple, and the solutions simpler.

A Ruby wrapper for the (new) Basecamp API

Thu, 12 Jul 2012 16:14:00 -0400

A Ruby wrapper for the (new) Basecamp API:

This is about as structurally simple as it could get to interact with the new Basecamp API (using HTTParty for the RESTful stuff). Very few endpoints are supported right now, but this might help you get going.

Exporting to CSV on Mac's Excel using PHP's fgetcsv

Thu, 12 Jul 2012 01:31:00 -0400

PHP has a nice way of working with CSV files using the fgetcsv function. One of the downfalls in using the CSV format is dealing with what character is used for new lines, which is how nearly all CSV files determine the separation of rows.

If you are using excel on Mac and do not want to set your own newline character in PHP (or don’t have access to it!), when you save the file, choose Windows Comma Seperated (.csv) as the file type.

The Stanford Natural Language Processing Group

Wed, 11 Jul 2012 05:30:00 -0400

The Stanford Natural Language Processing Group

String to Boolean in Ruby

Fri, 06 Jul 2012 22:59:00 -0400

String to Boolean in Ruby:

A great couple of lines that add a `to_bool` method to the Ruby String class. This is really helpful when passing in boolean values from a query string (like in an API). Just put this in a file and require it!

rspec_helper.rb for Rspec in Ruby

Tue, 19 Jun 2012 21:22:00 -0400

require File.join(File.dirname(__FILE__), '..', 'app.rb')
require 'rack/test'

set :environment, :test
set :run, false
set :raise_errors, true
set :logging, false

def access_token
  "xxxxx"
end

def api_token
  "xxxxx"
end

def app
  Sinatra::Application
end

RSpec.configure do |config|
  config.include Rack::Test::Methods
end

#no database debug messages
ActiveRecord::Base.logger.level = Logger::INFO