clipboarded

partial application in Javascript part 3

2011-09-29T07:50:00.000-05:00

Here is the last part of the videos on partial application. We improve the code from previous videos and make it handle a variable number of parameters.

In the video, I mention that n is the number of times we will have to apply partial application before the underlying function is called. That is misleading. The situation is actually a little better than that. n is really the number of parameters the underlying function cares about. After n parameters are passed in, the original function will be called. Whether or not we pass in the parameters all at once (a, b, c) or one at a time.

Here is the final code:

 1 <html>
 2     <body>
 3         <script language="javascript">
 4 
 5             Function.prototype.partial = function(n){
 6                 var original_function = this;
 7                 var args = [];
 8 
 9                 var recursive_partial = function(){
10                     args = args.concat([].slice.apply(arguments));
11                     if (args.length >= n){
12                         return original_function.apply(null, args);
13                     }
14                     return recursive_partial;
15                 };
16                 return recursive_partial;
17             }
18 
19             function addTwoNumbers(a,b){return a+b;}
20             function addThreeNumbers(a,b,c){return a+b+c;}
21 
22         </script>
23 
24         Partial application #3
25 
26     </body>
27 </html>

partial application in Javascript part 2

2011-09-26T09:08:00.000-05:00

Here is part 2 of the videos on partial application in Javascript. We take the initial prototype and make it handle three parameters.

Here is the code:

 1 <html>
 2     <body>
 3         <script language="javascript">
 4 
 5             Function.prototype.partial3 = function(){
 6                 var original_function = this;
 7 
 8                 var args1 = [].slice.apply(arguments);
 9                 return function(){
10                     var args2 = [].slice.apply(arguments);
11                     return function(){
12                         var args3 = [].slice.apply(arguments);
13                         return original_function.apply(null, args1.concat(args2).concat(args3));
14                     }
15                 };
16             };
17 
18             function addThreeNumbers(a,b,c){return a+b+c;}
19 
20         </script>
21 
22         Partial application #2
23 
24     </body>
25 </html>
26

partial application in Javascript part 1

2011-09-23T01:10:00.001-05:00

I recently recorded a few videos on partial application in JavaScript. In part 1, I explain what it is and I provide a short code snippet as a first draft. I will build upon the code snippet in the subsequent videos.

Here is the code that I am using:

<html>
    <body>
        <script language="javascript">

            Function.prototype.partial = function(){
                var original_function = this;
                var args1 = [].slice.apply(arguments);

                return function(){
                    var args2 = [].slice.call(arguments);
                    return original_function.apply(null, args1.concat(args2));
                };
            };

            function addTwoNumbers(a,b){return a+b;}

        </script>

        Partial application #1

    </body>
</html>

browser testing - looking back

2011-09-20T12:25:00.001-05:00

My last project involved quite a bit of browser testing. Here is a recap video describing lessons learned.

Lessons learned

1- Avoid browser testing: it's too expensive
   .do unit testing
   .do integration testing
   .do view testing (including JavaScript testing)
   .do controller testing
   .build your confidence so you don't have to test using a browser

2- Only test high-level critical bits
   .emulate the user
   .test complete user journeys

3- Manual testing is still needed
   .to test UX
   .to test with multiple browsers
   .to do exploratory testing

4- Non-technical people probably won't be able to write tests w/o help
   .programmers are needed to implements steps interacting with new features
   .that's okay - we like having a job

Secondary lessons (more technical)

1- Forgiving assertions are useful
   .do not fail the test right away if you can avoid it
   .forgiving assertions provide more coverage and still fail the test if assertion failed

2- Do not test for absence of stuff
   .hard to be sure the assertion is written correctly if the outcome is negative

3- Anchors help with timing issues
   .when the content is dynamic - use anchors
   .wait for something you know to be there before going for the dynamic elements

4- Semantic HTML helps
   .when the HTML is meaningful - the tests are more robust
   .semantic HTML helps avoid brittle xpath expressions

5- Minimize business logic
   .do not test for sorting or any other kind of calculations
   .do not test for things that should be unit-tested

getting things done

2011-09-04T19:16:00.003-05:00

For a few weeks now I've been using some sort of GTD system to manage my todos. The GTD -- Getting Things Done -- system is simple but I guess it's got a few things to it so there's a book about it.

To me, it boils down to how to manage a bunch of todo lists. I have a handful of todo lists, one for each "project" that I want to get done. And I tag individual todos with labels like @next, @soon, @waiting, or @reference. I try to always write down a todo for everything I want to achieve and I sort it into one of the projects.

When I go into planning mode, I tag lots of todos as @next. A quick search for that label will give me my current consolidated todo list. As I get those todos done, I delete them or remove the label and tag some more... Ring around the rosie.

The GTD workflow is easily understood from the following diagram:

The GTD workflow - copyright David Allen

A lot of software options are available to implement some sort of GTD workflow. But I have settled on the Springpad Android app. It's got bugs but it's very powerful and it does everything I need for GTD-style management. Hopefully they'll sort out the bugs soon enough.

Springpad's home view

When I am really totally obsessed about getting things done, I sometimes use the Pomodoro technique. This one also has a book but frankly, it probably does not deserve that much literature. It's too simple: set a timer for 25 minutes and that's the time you have to get something done. Then take a five-minute break. Rinse and repeat. Everything else is fluff. There is an Android app for that too.

mjpeg

2011-08-30T19:23:00.000-05:00

I recently discovered iTunes U where one can listen to lectures on a variety of topics. Most files that I downloaded from there worked fine on my linux box and on my phone but some of the files failed to play correctly. The specific error message said Too many audio packets in the buffer.

Here's a pseudo-solution.

The files were .m4b files. Which is a container format -- a variant of mp4. They are usually encoded using an mjpeg encoder where each frame is basically a jpeg image.

So the first step is to extract the audio track as an mp3:

> ffmpeg -i input_file.m4b -acodec libmp3lame -ab 192000 out.mp3

Which is a good start. We can now listen to the lecture but we're missing the slides. So we need to extract the jpeg images using the following command line:

> ffmpeg -i input_file.m4b -r 1 frame_%05d.jpg

This will result in a slew of images, one for every second of the lecture. To get rid of the duplicates, I use the following ruby script. It's gross but it mostly works:

 1 #!/usr/bin/env ruby
 2 
 3 Dir.new('.').entries.inject(Hash.new) {|hash, f|
 4 
 5   if File.file? f
 6     puts "removing #{f}"; File.delete(f) if hash[File.size? f]
 7     hash[File.size? f] = f
 8   end
 9   hash
10 }

Run this in the directory where the frames are and you should be on your way. Careful, that script will delete stuff.

ruby warrior

2011-08-05T18:54:00.002-05:00

There is a fun little project on github called ruby warrior. It's an interactive way to learn ruby where you guide a warrior through levels by implementing a simple function that gets called at every turn. I didn't try to achieve the secondary objectives or anything fancy but here's my solution:

 1 class Player
 2   @@ALL_DIRECTIONS = [:forward, :left, :right, :backward]
 3 
 4   def play_turn(warrior)
 5     @warrior = warrior
 6 
 7     begin
 8       rest_if_safe_to_do_so
 9       bind_enemies_if_too_many
10       attack_enemies_if_any
11       attack_captives_if_present
12       move_towards_stairs
13     rescue
14       raise if $!.message != "end of turn"
15     end
16   end
17 
18   def rest_if_safe_to_do_so
19     rest if safe_to_rest? and @warrior.health < 20
20   end
21 
22   def bind_enemies_if_too_many
23     directions_with_enemies = @@ALL_DIRECTIONS.select {|d| @warrior.feel(d).enemy? }
24     bind directions_with_enemies.first if directions_with_enemies.size > 1
25   end
26 
27   def safe_to_rest?
28     @@ALL_DIRECTIONS.all? do |direction|
29       !@warrior.feel(direction).enemy?
30     end
31   end
32 
33   def attack_enemies_if_any
34       @@ALL_DIRECTIONS.each do |direction|
35         space = @warrior.feel direction
36         attack(direction) if space.enemy?
37       end
38   end
39 
40   def attack_captives_if_present
41     directions_with_captives = @@ALL_DIRECTIONS.select {|d| @warrior.feel(d).captive? }
42     attack directions_with_captives.first if !directions_with_captives.empty?
43   end
44 
45   def move_towards_stairs
46       walk @warrior.direction_of_stairs
47   end
48 
49   def attack direction
50     @warrior.attack! direction
51     raise "end of turn"
52   end
53 
54   def walk direction
55     @warrior.walk! direction
56     raise "end of turn"
57   end
58 
59   def rest
60     @warrior.rest!
61     raise "end of turn"
62   end
63 
64   def bind direction
65     @warrior.bind! direction
66     raise "end of turn"
67   end
68 
69 end

Octopus News goes live

2011-07-18T23:51:00.016-05:00

Hello dear comrades!

I have recently published a new website into the public sphere. The name is Octopus News. Read on to know more...

" what news? "

The Goal
The objective is simple: I want to build a small community of avid readers so that we can discuss current affairs and political issues. The website allows you to share online articles and comment on them. Whatever you share with the rest of the group will be voted up according to its merit, and your articles might bubble up to the top -- or not.

To get a feel of what kind of articles you should submit, just look at the ones that are already there. Anything related to international politics is welcome.

For you web-savvy people, the site is very similar in concept to Digg, or Reddit, except the emphasis is on discussion rather than fake karma points.

How to Contribute
Easy. Sign up to Octopus News and comment on the articles. Vote up the articles that you find the most interesting by clicking the arrow pointing upwards. This will help other people understand what articles are most interesting.

Voting up

You can also go to the submit page and submit a story that you want to discuss. To make your life easier, you can drag this bookmarklet to your bookmarks toolbar and click on it if you want to submit the article you are currently reading.

Submitting a story

Give me feedback!
Please let me know what you think of the website. Comment on this post, ping me on IM, or buy me a beer.

I know a lot of you read about current affairs and I know it's hard to get into the habit of sharing the good stuff you read so if you have a great idea on how to make submissions to Octopus News easier, let me know.

Where does the funny name come from?
Good question. The name implies that Octopus News will help you reach out to the world a little more. Using all eight arms... It's also unique and hopefully makes people want to know more about it. Not to mention that the domain name was available. And octopi are funny animals. We'll find a better story once the site makes it big, all right?

How to Contribute as a Developer
If you like the website but you think it could use a couple of new features. Well, you are right. Feel free to clone the codebase and request a pull. There is a TODO file at the top level if you need inspiration.

toggle confirmable on and off

2011-04-13T20:54:00.005-05:00

We are using the devise gem for the authentication of users in Socialite. The gem makes it ridiculously easy to manage our users.

One issue we had to solve was a way to toggle on and off the confirmable ability for our user model. Usually, to make the users confirmable or not, you would just add or remove the :confirmable symbol from the list of devise capabilities:

class User < ActiveRecord::Base
  devise :database_authenticatable, :registerable, :confirmable,
         :recoverable, :rememberable, :trackable, :validatable
  ...
end

This works well usually but we need a way to toggle that capability at runtime. The solution is simple. We created an #after_initialize hook in which we initialized the confirmed_at attribute:


 1 class User < ActiveRecord::Base
 2   devise :database_authenticatable, :registerable, :confirmable,
 3          :recoverable, :rememberable, :trackable, :validatable
 4 
5   def setup_default_values
6     self[:confirmed_at] ||= Time.now if !AppSettings.confirm_email_on_registration
7   end
8 end

ajax post, sign in, post, redirect, get

2011-03-27T16:54:00.000-05:00

While working on socialite, we ran against the following problem.
The users can vote up submissions by clicking the up arrow next to the submissions:

The way this usually works is through an ajax request that posts the vote to the server. The Rails view that handles that reads like so:

 1 - if current_user.nil? or current_user.can_vote_for(submission)
 2   = link_to vote_up_path(:id => submission.id), :method => :post, :remote => true, :class => "vote-up", :id => "voting-booth-#{submission.id}", :title => 'vote up' do
 3     != icon 'circle-arrow-n'
 4 
 5 %span
 6   %span{:class => 'score-bracket'}= "["
 7   %span{:class => 'score', :id => "score-for-submission-#{submission.id}"}>= submission.score.to_i
 8   %span{:class => 'score-bracket'}= "]"
 9 
10 :javascript
11   $(document).ready(function(){
12     $('#voting-booth-#{submission.id}').bind('ajax:success', function(obj, data){
13       data = eval("(" + data + ")");
14       $('#score-for-submission-' + data['id']).text(data['score']);
15       $('#voting-booth-' + data['id']).addClass('invisible');
16     });
17   });

Everything works fine with this setup, except when the user is not signed in. In that case, we could hide the up arrow but that's not very user-friendly. We really want to show things like that so the users understand what they are allowed or expected to do.

Usually, when a user that is not registered clicks a link that would require him to be registered; the server will remember that link, show a sign in page, and then redirect to that link. We cannot do that in our case because the link is a post. Further, it's an ajax post so the rendered content makes no sense outside of its usual page.

So the solution we came up with is to remember the current page as the user clicks the arrow and also to remember the post request -- both pieces of information are stored in the session. Then, after the user signs in or signs up, we artificially execute the post before redirecting to the original page -- the one where they triggered the post request.

The first thing we have to do is remember the post request when the user is not signed in. We do that by adding the following to our application controller:

 1 class ApplicationController < ActionController::Base
 2 
 3   # this before filter will save an attempted post request for later execution after the user is authenticated
 4   def save_post_before_authenticating
 5     if request.env['warden'].unauthenticated? and request.post?
 6       logger.info "Will save the POST request for later execution"
 7       session[:pre_sign_in_post] = {:controller => controller_name, :action => action_name, :params => params.dup}
 8     end
 9 
10     authenticate_user!
11   end
12 
13 end

Here we are using warden, the underlying library behind the devise gem.

The save_post_before_authenticating method is added as a before filter to the vote_up action:

  before_filter :save_post_before_authenticating, :only => [:vote_up]

Next, we have to handle the 401 response sent back from the server when a vote takes place for a user that is not signed in. The javascript code reads like that:

  $(document).ready(function(){
    $(document.body).bind('ajax:error', function(status, xhr, err){
      if(xhr.status == 401){
        window.location = '/sign_in_then_redirect?current_url=' + escape(window.location)
      }
    });
  });

The URL we are now reaching out to (sign_in_then_redirect) will remember the current page and redirect to the sign in page:

 1 class ApplicationController < ActionController::Base
 2 
 3   def sign_in_then_redirect
 4     flash[:alert] = "Please sign in first."
 5     session[:last_get_url] = params[:current_url]
 6     redirect_to new_session_url(:user)
 7   end
 8 
 9 end

At this point, the user will sign in and we will need to execute the saved post request and redirect them to their previous location. We have all the information we need but artificially executing the post request is tricky. We need to hack together a few things. First off, the after_sign_in_path_for is a method from the devise gem that is executed when trying to figure out where to redirect the users after they sign in. So we hook into that method and do some request processing. We instantiate the controller that would have been created by the post request and we call its action method. Before we call the action method though, we have to make sure that params and request actually point to the old post params and request.

As a bonus, we replace the flash notice with whatever is in flash[:pre_sign_in_notice] so the vote up action can reassure the user that their vote was taken into account.

The code for these two methods is as follows:

 1 class ApplicationController < ActionController::Base
 2 
 3   def after_sign_in_path_for resource_or_scope
 4     last_get_url = session[:last_get_url]
 5     if last_get_url.nil?
 6       return super
 7     end
 8 
 9     # if a post request was saved in the session then we execute it -- see #save_post_before_authenticating
10     execute_saved_post_request if session[:pre_sign_in_post]
11 
12     last_get_url
13   end
14 
15   def execute_saved_post_request
16     logger.info "Executing the saved POST request before redirecting"
17 
18     begin
19       class_name = session[:pre_sign_in_post][:controller].capitalize + "Controller"
20       controller_instance = class_name.constantize.new
21 
22       current_request = request
23       saved_params = session[:pre_sign_in_post][:params]
24       metaclass = (class << controller_instance; self; end)
25 
26       metaclass.send(:define_method, :request) { return current_request }
27       metaclass.send(:define_method, :params) { return saved_params }
28 
29       controller_instance.send(session[:pre_sign_in_post][:action])
30       flash[:notice] = flash[:pre_sign_in_notice] if flash[:pre_sign_in_notice]
31     rescue
32       logger.error "An error occurred trying to execute the saved POST request: #{$!}"
33       flash[:alert] = $!.message
34     ensure
35       session[:pre_sign_in_post] = nil
36     end
37   end
38 end

The above solution is far from generic but it works well for socialite. Among other things, if the action method from the saved post request calls out to render, this solution will not work. At the very least, the render call would have to be stubbed.

Feel free to have a better look at the code through the github page. And let me know if you have suggestions to improve this solution.

socialite

2011-03-05T21:45:00.000-06:00

We just started working on a CMS for social news websites. I will post more about it later but here's the link to the github project: Socialite.

smart shuffle for pana

2011-01-25T20:00:00.000-06:00

I wrote a script some time ago to shuffle a playlist not only by randomizing the order of the songs but also by spreading out songs from the same artist.
The script was written for Amarok but I now use a forked version of it called Pana. Here is the new script recompiled for Pana.

Our Kickstarter project just launched!

2010-11-26T22:47:00.001-06:00

Our documentary project moves forward. We just published our Kickstarter trailer and launched our project page! You can back us up on Kickstarter.

making a movie

2010-11-02T13:19:00.000-05:00

These days I'm spending most of my time shooting a documentary with my brother. It's about natural wine in California.

Some short samples of interviews are already available on our vimeo page.

As well as some pictures on our flickr page!

crowd funding

2010-08-21T08:58:00.000-05:00

fundable.com died a controversial death but a couple of new websites have sprung up around the same concept:

The concept is simple: each project sets a deadline and a dollar amount to raise by that deadline. Other users then pledge to donate to that project and if the goal is reached, money changes hands and the hip entrepreneurs get all the money. If the goal is not reached, the backers keep their dollars.

Each project will post a list of rewards that they promise to give to a backer depending on how much is donated. For instance, 5 bucks might get you a mention in the credits at the end of a documentary. 30 bucks might get you an online link to download the movie.

You could start by looking at Sparrow Songs or Below New York

skip any rake dependency

2010-04-22T10:04:00.004-05:00

Here is an easy way to skip a rake dependency:

rake skip[taskname] othertask

The following code makes that possible:

desc 'Skip task in parameter if it is found to be a dependency'
task :skip, :task do |t, args|
  task_name = args[:task]
  Rake::Task.tasks.each do |t|
    t.prerequisites.reject!{|prerequisite| prerequisite == task_name}
  end
end

javascript: the good parts :: review

2010-01-14T14:44:00.008-06:00

I recommend Douglas Crockford's book to anyone who wants to learn more about JavaScript. It really consolidated my knowledge of the language. The book is short and enjoyable. The author comes off as really credible which is important as the book makes quite a few recommendations on proper usage and style. Here are a few notes that I took while reading the book.

The prototype chain

The prototype is only used when retrieving values. Setting a property always sets it on the receiver directly. To know if the receiver has a property without looking at the prototype, use #hasOwnProperty.

Function calls

Every function has access to two magic objects: this and arguments. This is a link to the current object and its value depends on the invocation pattern of the function. Arguments is an array-like object containing all the arguments passed in to the function.

There are four invocation patterns:

As a method: when called on a receiver object, this represents the receiver
As a function: when called without a receiver, the this pointer points to the global object
As a constructor: when invoked with the new keyword, a new object is created using the function's prototype. This points to that new object.
Using #apply: in this case, the this pointer is explicit and passed in to #apply.

Partial application in JavaScript

Here is a clever snippet from the book that allows function application.

Function.prototype.curry = function(){
  var slice = Array.prototype.slice;
  var args = slice.apply(arguments);
  var that = this;
  
  return function(){
    return that.apply(null, args.concat(slice.apply(arguments)));
  };
};

You can then use it like this:


>>> function add(a,b) {return a + b;}
>>> add.curry(1)(2)
3

Recommendations and gotchas

JavaScript does not have block scope
Avoid the use of 'new'
Always pass in the radix parameter to #parseInt
Always use === and !==, not == or !=
Avoid the use of 'with', use a local variable instead
Avoid the use of 'void'
Avoid the use of typed wrappers like new Boolean, new String, or new Number
All characeters are 16-bits wide

textonyms

2010-01-10T17:10:00.002-06:00

I was interested in textonyms -- words that can be represented by the same digits when texting. Rotating through the list of possible words for a certain input, a phone will turn lips into kiss. Or good into home. Book becomes cool.

So I wrote the following script to extract textonyms from a list of words. It should be used on a text file containing one word per line.


#!/usr/bin/env ruby 

def populate dictfile
  digits2words = Hash.new {|hash, key| hash[key] = []}

  File::open(dictfile){|file|
    file.each do |line|
      digits = line.chomp!.split(//).map do |char| CHAR_TO_DIGIT[char.downcase.to_sym] end
      digits2words[digits.to_s] << line
    end
  }

  digits2words.each do |key, values|
    puts "#{key}\t#{values.size}\t#{values.join ' '}"
  end
end

CHAR_TO_DIGIT = {
  :a => 2,
  :b => 2,
  :c => 2,
  :d => 3,
  :e => 3,
  :f => 3,
  :g => 4,
  :h => 4,
  :i => 4,
  :j => 5,
  :k => 5,
  :l => 5,
  :m => 6,
  :n => 6,
  :o => 6,
  :p => 7,
  :q => 7,
  :r => 7,
  :s => 7,
  :t => 8,
  :u => 8,
  :v => 8,
  :w => 9,
  :x => 9,
  :y => 9,
  :z => 9
}

if __FILE__ == $0
  if !ARGV.empty?
    populate(ARGV[0])
  else
    puts "specify a file name"
  end
end

urban dictionary's greatest hits

2009-12-02T21:22:00.011-06:00

I was curious about what words were the most popular on urbandictionary.com. So I scraped the popular section for each letter in the alphabet and came up with the following table where the ranking is based on the number of upvotes. I didn't want to have my blog associated with any of the words below and I didn't want to give backlinks to the urban dictionary so here's an image of my results.

Here is the code I used to get to the information. It scrapes all the links provided in the popular section for each letter and writes a dump of all entries. The dumps can later be used to study the data.

require 'rubygems'
require 'hpricot'
require 'open-uri'
require 'entry'
require 'net/http'
require 'json'

def retrieve_votes(doc)
  # in-browser, votes are retrieved through an ajax call after the web page is loaded
  (doc/"td.tools").each do |tools|
    id = tools[:id]
    uncacheable_id = id.scan(/\d+/)[0]

    json_response = Net::HTTP.post_form(URI.parse('http://www.urbandictionary.com/uncacheable.php'), {'ids'=> uncacheable_id})
    thumbs = JSON.parse(json_response.body)['thumbs'][0]
    return [thumbs['thumbs_up'], thumbs['thumbs_down']]
  end
end

def retrieve_links letter
  anchors = []

  doc = Hpricot(open(letter))
  (doc/"table#columnist//tr").each do |row|
    (row/"td").each do |cell|
      (cell/"ul"/"li").each do |li|
        (li/"a").each do |anchor|
          anchors <<  anchor.get_attribute(:href)
        end
      end
    end
  end

  anchors
end

def build_entry(doc)
    word = "no words found"
    definition = "no definitions found"

    up, down = retrieve_votes(doc)
    (doc/"td.word").each do |wrd|
      word = wrd.to_plain_text
      break
    end
    (doc/"div.definition").each do |defined|
      definition = defined.to_plain_text
      break
    end

    Entry.new(word, definition, up, down)
end

"ABCDEFGHIJKLMNOPQRSTUVWXYZ".each_char do |letter|
  links = retrieve_links("http://www.urbandictionary.com/popular.php?character=#{letter}")
  entries = []
  links.each do |link|
    sleep 5
    puts "fetching #{link}"
    doc = Hpricot(open("http://www.urbandictionary.com" + link))
    entries << build_entry(doc)
  end

  File.open("letter#{letter}.dump",'w'){|file|
    file.write(Marshal.dump(entries))
  }
end

The Entry class is defined like so.

class Entry
  attr_accessor :word, :definition, :up, :down
  def initialize word, definition, up, down
    @word = word
    @definition = definition
    @up = up
    @down = down
  end

  def <=>(other)
    (other.up - other.down) - (@up - @down)
  end

  def to_s
    "#{word} (#{up} up, #{down} down): #{definition}"
  end
end

In order to get some kind of greatest hits, I used the following script. I had to filter out entries with too many down votes to get rid of the most childish entries.

require 'entry'

entries = []
Dir['letter*.dump'].sort.each do |filename|
  entries.concat(Marshal.load(File::open(filename).read))
end

entries.sort!
entries.reject! {|entry| entry.down > 1000}
html="<table>"
50.times do |i|
  i = i + 1
  html += "<tr><td><b>#{i}</b></td><td style='padding: 0 2em 0 2em;'>#{entries[i].word}</td><td><a href=\"http://www.urbandictionary.com/define.php?term=#{entries[i].word}\">read more</a></td></tr>"
end
html+="</table>"

puts html

pair programming prep

2009-11-29T23:08:00.001-06:00

What can we do before pairing to make it more effective?

Make sure both peers focus on productivity to get the ego and flowery phrases out of the way
Agree on a game plan. What problem are we solving? What type of pairing is this going to be? (ball and board or coder/navigator or ping pong)
Understand the benefits/costs of pairing
Negotiation: Roy Miller of RoleModel Software offers a suggestion:
One of the best tricks I've ever used when pairing is to start each pairing session with some 'negotiation.' I lay out what I like and don't like when I pair with someone, things I do well and things I don't do well, things I need help on, things that bug me to death. Then I listen while the other person does the same. This takes less than five minutes, usually, but the results are staggering. Both members of the pair then can use the pairing session as a time to get work done and to help the other person. I think 'pairing as negotiation' is a key concept.
Read more: Pair Programming Illuminated

change the web challenge

2009-02-28T10:02:00.000-06:00

The not-for-profit Social Actions just launched the Change the Web Challenge. The idea is to come up with the greatest application you can think of that leverages their API.

Their API allows you to search a database of social actions -- things like volunteering opportunities, fundraising events, petitions -- aggregated from contributors like kiva.org or idealist.org.

For a quick peek at what you have access to, you can try my very own search for opportunities. The code for it is available as a git repository.

test-first VS writing a test harness

2008-11-30T12:20:00.000-06:00

There is a common understanding that code written using a test-first approach (as in TDD-style) ends up being more maintainable than code that has been harnessed with tests later on. I would justify that understanding as follows:

TDD simplifies original design. This one is easy. By driving the design through small unit tests, we never write code that is unnecessary and experienced TDDers know to make the tests pass with the simplest thing that works. Further, because we gain immediately from writing testable code, the code usually ends up loosely coupled with no implicit dependencies and few explicit dependencies.
Another thing is that by writing the code that exercises the implementation, we design both sides of the API, client code and implementation at the same time. I blogged about client code as design some time ago.

The tests once failed for lack of functionality. To make sure the test is bug-free -- and actually testing the upcoming functionality -- it is imperative to make it fail before making it pass. If you're testing first, that's easy. If you're writing a test harness, you might have to comment out a bit of code to get the red bar, but then will it still compile? Will it still be coherent at runtime? A test harness is forever dubious.

TDD gives you fine-grained coverage. With very little overhead, TDD gives you fine-grained coverage since you're writing the simplest test that brings you forward, all the time. In the words of Gerard Meszaros, this gives you better Defect Localization. When writing a test harness, we usually emphasize the higher level functionality and forget about the smaller 'units' of work. These smaller units might be hard to test because they are implicit, hidden/encapsulated, or even unfathomable.

Test/Specification mismatch. The tests are the requirements for the code. The BDD people have taken this to the next level, but it remains true with TDD. Test code is the most useful documentation to a fellow developer: it's working, up to date, terse, and it serves as an example of client code. When developing TDD-style, the tests become the developers' understanding of the stories -- the ultimate reference.
If writing tests later on, we need to match the functional requirements with the actual codebase, like pieces of a puzzle. Except there will be mismatches, where the developers were not really clear about the requirements. What are we to do then? For this reason alone, test harnessing a big codebase is just really, really hard.

Interestingly, most of the benefits derived from test-first development are gone even if you write the tests right after new code.

about free culture

2008-10-26T12:53:00.000-05:00

I just finished reading The Future Of Ideas and Free Culture. I read both books avidly and I would recommend them to pretty much anyone -- programmer or not. What's more, they are both available for free online, under a creative commons license.

In both books, Lessig dissects the state and the fate of the commons in american society. The commons are to be cherished and cared for as they lead to innovation, creativity, and a free culture.

The Future Of Ideas is mostly concerned about explaining the concept of commons and the one of layers. The idea of layers is taken from Yochai Benkler and divides the network in three parts: the physical layer, the code, and the content. Lessig then explains how the balance of control at each layer affects innovation and creativity. The example stories include Napster, MP3.com, UNIX, and deCSS.

Free Culture is mostly concerned about the effects of excessive control on culture. Lessig discusses copyright law, intellectual property, and the concentration of the media. The example stories include the infamous RIAA lawsuits and the Eldred v. Ashcroft case.

A few things strike me about this free culture debate:

There is no clear stakeholder in the 'new'. The new innovators and creators that free culture helps aren't yet established. This makes the fight incredibly hard to win. It's another case of special interests violating the people.
There is no obvious way to disagree with Lessig unless you have a stake in the 'old'. Lessig explains his case rationally and is smart enough to include the whole political spectrum with his arguments.
Prolonging the term of existing copyrights is absurd. The objective of copyrights is to give an incentive to innovators. Once the innovation has seen the light of day, prolonging the term of copyrights delays their introduction in the public domain where they could give rise to even more innovation. Thus, prolonging the term of copyrights goes against their prime objective.

As a side note, another book from Lessig just came out: Remix.

skip dependencies in Rake

2008-09-15T11:58:00.002-05:00

Here is a handy rake task to skip dependencies whenever you want to:

desc 'Skip dependencies of subsequent tasks'
task :skip do
  Rake::Task.tasks.each do |t|
    t.clear_prerequisites
  end
end

pyweek 7 is over

2008-09-14T13:13:00.005-05:00

PyWeek just went by. A python programming challenge where participants have one week to make a game.

Here is our project page: google code strlen

Or you can check it out like so:

svn checkout http://strlen.googlecode.com/svn/trunk/ strlen