Then, I figured I’d try the same command from the host machine. It worked flawlessly. Then, I remembered that there might be performance problems with Virtual Box’s shared folders. Indeed, this article describes the problem and suggests using nfs.

My share_folder command looks something like this in my Vagrantfile.

Vagrant::Config.run do |config|
  config.vm.share_folder "v-www", "/www", "/Users/jamiely/Documents/code/", :nfs => true
end

Initially, I had problems with this because the path I was sharing was a symbolic link. I didn’t realize this would be a problem and it took some manual experimentation with the NFS setup to determine what the issue was.

Here’s the sample npm output in case it’s helpful to anyone:

Issue 1: npm install hangs

vagrant@oneric32:/www/bgc/bgc-api$ npm install
npm http GET https://registry.npmjs.org/express/2.5.8
npm http GET https://registry.npmjs.org/underscore/1.3.3
npm http GET https://registry.npmjs.org/jade
npm http GET https://registry.npmjs.org/hiredis/0.1.14
npm http GET https://registry.npmjs.org/socket.io/0.8.6
npm http GET https://registry.npmjs.org/redis/0.7.2
npm http GET https://registry.npmjs.org/socket.io-client/0.8.6
HANGING

This is somewhat resolved by creating the directory from the host
machine (or before installing)

Issue 2: npm cannot access/find files:

npm http GET https://registry.npmjs.org/express/2.5.8
npm http GET https://registry.npmjs.org/underscore/1.3.3
npm http GET https://registry.npmjs.org/jade
npm http GET https://registry.npmjs.org/hiredis/0.1.14
npm http GET https://registry.npmjs.org/socket.io/0.8.6
npm http GET https://registry.npmjs.org/redis/0.7.2
npm http GET https://registry.npmjs.org/socket.io-client/0.8.6
npm http GET https://registry.npmjs.org/coffee-script/1.3.1
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___underscore.npm
npm ERR! error installing underscore@1.3.3
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___express.npm
npm ERR! error installing express@2.5.8
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___socket.io.npm
npm ERR! error installing socket.io@0.8.6
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___coffee-script.npm
npm ERR! error installing coffee-script@1.3.1
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___socket.io-client.npm
npm ERR! error installing socket.io-client@0.8.6
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___hiredis.npm
npm ERR! error installing hiredis@0.1.14
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___jade.npm
npm ERR! error installing jade@0.25.0
npm ERR! Could not create
/www/bgc/bgc-api/node_modules/___redis.npm
npm ERR! error installing redis@0.7.2

npm ERR! Error: UNKNOWN, unknown error
'/www/bgc/bgc-api/node_modules'
npm ERR! You may report this log at:
npm ERR!     <http://github.com/isaacs/npm/issues>
npm ERR! or email it to:
npm ERR!     <npm-@googlegroups.com>
npm ERR!
npm ERR! System Linux 3.0.0-12-generic
npm ERR! command "node" "/usr/local/bin/npm" "install"
npm ERR! cwd /www/bgc/bgc-api
npm ERR! node -v v0.6.11
npm ERR! npm -v 1.1.2
npm ERR! path /www/bgc/bgc-api/node_modules
npm ERR! code UNKNOWN
npm ERR! message UNKNOWN, unknown error
'/www/bgc/bgc-api/node_modules'
npm ERR! errno {}
npm ERR!
npm ERR! Additional logging details can be found in:
npm ERR!     /www/bgc/bgc-api/npm-debug.log
npm not ok

My first night with the Arduino and cart was very productive. I started experimenting with just the Arduino connected via USB to my MacBook Air. I made the light blink and had it spit back some output over the serial connection.

Next, I wanted to try to get the wheels spinning on the motorized cart. Our TA sent me a lab from a different class discussing the motorized carts. It gave a sample of some Arduino code to drive the cart, and where to connect the pins. Although I was confused at first about how to connect the cart to the Arduino, it soon became obvious. I hooked things up and ran the code and soon had one of the wheels rotating back and forth.

Although we wanted to setup communication with the Arduino through an XBee device, our TA feared it would be too complicated. He gave me an ethernet shield for the Arduino and said to try to get that working first. So, I stuck the ethernet shield over the Arduino and loaded a sample program that would print the device’s DHCP-assigned IP over the serial connection. That only took a few tries to get working.

One of the examples included showed how to setup a telnet server. I figured this would be the easiest way to send commands to the device over ethernet, so I experimented a bit with it. It seemed to work just fine. Next, I merged some of the servo-driving code into the telnet server. I made it so you could type certain characters, and they would each control a wheel, and movement forward and backward. It was very straightforward to setup, and I think we’re ready to move onto the XBees.

Piping and Grep

# Pipe stderr
command 2>&1 >/dev/null | command

# Grep stderr
command 2>&1 >/dev/null | grep 'pattern'

# Colorize output
command | grep --color 'pattern'

# Grep and colorize stderr
command 2>&1 >/dev/null | grep --color 'pattern'

C Programming

# Define a macro at compile time with definition = 1
cc -Dmacro_name program.c

# gprof, profiles the time spent in each function of your c program
cc -g -pg -o program program.c #generates gmon.out
gprof program gmon.out > gprof.out

# Includes a table like:
# Each sample counts as 0.01 seconds.
#   %   cumulative   self              self     total
#  time   seconds   seconds    calls  ns/call  ns/call  name
#  78.15     44.28    44.28 200000000   221.40   221.40  get
#   9.64     49.74     5.46 400000000    13.65    13.65  generate_point
#   7.74     54.12     4.38 200000000    21.93    21.93  hash_key
#   2.52     55.55     1.43 200000000     7.15   251.50  calculate_distance
#   1.59     56.45     0.90                             main
#   0.20     56.57     0.12 14514500     7.92     7.92  radians
#   0.16     56.66     0.09  2902900    31.00    31.00  put
#   0.00     56.66     0.00        1     0.00     0.00  hashtable_init
#   0.00     56.66     0.00        1     0.00     0.00  hashtable_init_list

SVN Issues on OSX

I got an error when trying to operate on an SVN repo over samba:

svn: Can’t move ‘.svn/tmp/entries’ to ‘.svn/entries’: Operation not permitted

sudo chflags -R nouchg . # unset the OSX immutable flag

Creating empty directories

I needed to create a bunch of placeholder directories in a repo for logging.

# Lists the numbers 1 to 31, zero padded to length 2
seq -f "%02g" 1 31

# Creates directories logs01 to logs31
for i in $(seq -f "%02g" 1 31); do mkdir logs$i; done;

# Create an empty directory in a git repo, add the following gitignore to the directory
cat > .gitignore
# Ignore everything in this directory
*
# Except this file
!.gitignore
# END WITH CTRL+d

# Copy the .gitignore into each directory
for i in $(seq -f "%02g" 1 31); do cp .gitignore logs$i; done;

# Remove the original .gitignore
rm .gitignore

References

• http://stackoverflow.com/questions/2342826/how-to-pipe-stderr-and-not-stdout
• http://gcc.gnu.org/onlinedocs/gcc/Preprocessor-Options.html
• http://www.zsh.org/mla/users/2005/msg00215.html
• http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html#SEC2
• http://gaggle.systemsbiology.net/wiki/doku.php?id=svn
• http://stackoverflow.com/questions/115983/how-do-i-add-an-empty-directory-to-a-git-repository

I met a coworker, Hector, there and had some coffee and breakfast. We didn’t really get started until at least quarter of ten, a bit late. Organizers passed out Post-It notes for us to write down ideas. Various people involved in city government and other civic organizations took turns presenting their ideas of projects to work on. I took notes as best I could and when they were done, we discussed which seemed most interesting to work on. People were encouraged to stick the ideas written down onto a whiteboard at the front of the room. Half of the participants helped to group the ideas by topic.

Hector and I talked again about what to work on. Organizers meanwhile passed out colored dot stickers to use in voting for ideas. Once the herd thinned out, we voted as well. Once the voting was complete, 8 main topics/ideas were selected and participants self-selected into those different groups. We considered working on a project to make lobbyist information accessible, but decided to work on a project to publicize statistics about the plight of the more downtrodden areas of the city.

Originally, the concept was to take statistics about the city such as crime and poverty rates, and relate them to a person through their neighborhood. Someone would enter either their zipcode or various other statistics about themselves (perhaps highschool class size), and the site would use that information to give them a statistic like:

If you lived in Philadelphia, only 58 of the 100 students in your class would’ve graduated.

or

If you lived in Philadelphia, 3 of your 200 neighbors would’ve been the victim of violent crime.

We discussed this concept with other people, and someone suggested this type of site might make someone glad they didn’t live in Philadelphia rather than promote civic engagement. This helped to lead to the concept that we eventually ran with. We decided that we should use people’s friends to illustrate the statistics.

So, we went to work implementing Facebook authentication, querying the Graph API, designing the site views, and writing code. I mostly paired with Hector and focused with him on the Graph API. We needed to retrieve friend names and profile pictures. We worked on various other pieces such as sampling friends for the statistics, wiring up the views, and pushing to Heroku.

We had some last minute difficulties shortly before our demo, including:

• Heroku having limited functionality for the free-app tier
• Problems connecting the site on Heroku with the Facebook app
• Wireless network issues

In case you’re wondering, the project that won first price was http://lobbying.ph/, the site that provides information about Philadelphia’s registered lobbyists. Technically Philly has a writeup about the event. You can find our presentation on Viddler.

Since I didn’t have long to work, I decided to try to complete the algorithm problem with the highest value. I chose to work on Count Strings (closed now). Given a regular expression, and a string length N, count the number of distinct strings of length N which the regular expression can match.

I looked at the sample test case, spent some time thinking about the problem and decided to try it. Although bounds for test cases were provided, I gave them only a cursory glance. This would turn out to be a mistake.

In my daily work, I typically focus on getting things working rather than spending time on determining the optimal way to do things. It is with this mindset that I decided that I would actually enumerate every string that a regular expression could produce, and then count them. I failed even before I began.

The regular expression language was limited to the alphabet {a, b}, with operators star, union, and concatenation.

I decided to use Haskell, which has the terseness of Ruby or Python, but the performance and type checking of a compiled language. I created a data type to represent the regular expressions. Recursive data types made this representation very straightforward.

data RegularExpression = Symbol Char
  | Concat RegularExpression RegularExpression
  | Union RegularExpression RegularExpression
  | Star RegularExpression
  deriving (Show, Eq)

I had the enumeration part complete fairly quickly. Pattern matching makes everything really intuitive and readable. The star operation required the most code.

listPossibilities (Symbol c) limit
  | limit > 0 = [c]
  | otherwise = []

listPossibilities (Concat r1 r2) limit = combos where
  o1 = listPossibilities r1 limit
  o2 = listPossibilities r2 limit
  combos = [ a ++ b | a <- o1, b <- o2, length (a++b) <= limit ]

listPossibilities (Union r1 r2) limit = possibilities where
  o1 = listPossibilities r1 limit
  o2 = listPossibilities r2 limit
  possibilities = o1 ++ o2

listPossibilities (Star _) 0 = [""]
listPossibilities (Star r1) limit = possibilities where
  opt = listPossibilities r1 limit
  possibilities = "": whileLimit opt limit optSet
  optSet = Set.fromList opt 

  -- | Uses nub right now, really inefficient. probably should use some sort of memoization
  whileLimit :: [String] -> Int -> [String] -> [String]
  whileLimit base lim acc = pos where
    new = List.nub [a++b | a <- base, b <- acc, length (a++b) <= lim]
    pos = if null new || length new < length acc then acc
          else whileLimit base lim (List.nub $ acc ++ new)

The next component I needed was a parser to convert input into these regular expression objects. I used the Parsec parser module to construct the parser. This part actually took a bit longer, as I tried to refine the parser to accept deeply nested expressions.

The regular expression union parser below parses a parenthesized expression or symbol, followed by a pipe, and another parenthesized expression or symbol, returning a RegularExpression object.

reUnion :: GenParser Char st RegularExpression
reUnion = do
  re1 <- pexpr <|> reSymbol
  char '|'
  re2 <- pexpr <|> reSymbol
  return (Union re1 re2)

Once I got the parser working, I glued it together with the enumeration portion, and submitted it to the contest. It immediately failed to compiled due to a dependency on Test.HUnit I had in my code. I reorganized the code so that I could easily remove this dependency, and resubmitted.

This time, it took, but when I went back after a few minutes to check the submission status, it had failed all but 1 of the test cases. It had taken too much time! I went back to the submission guidelines and noted that there was a time limit of 5 minutes.

Originally, I had used an algorithm which enumerated by checking distinctness using a List type. I knew at the time that this was very inefficient, but I focused on finishing the implementation at the time. I went back to this part and used a Set instead. I was optimistic that this would fix my problems and I would be able to knockout at least another test case.

I resubmitted and I failed 10 tests again. Then, I reread the problem, and looks at the boundaries for N. N could be up to 100,000 (IIRC)! Of course enumeration (especially the way I was doing it which would enumerate many strings of less than length N) would fail–I had taken a totally incorrect approach to this problem. I did not need to enumerate–I only needed to give a number of potential strings. This could’ve been done without enumeration. For example, given the expression a*, and a number N, there is only 1 possibility. Given . For example, one of the test cases was , which has 32 possibilities. Another of the expressions was . Since b can only appear once, the possible strings include strings of   a’s and a single b. There are N such combinations (the number of positions b can be in, in an N length string): baa…, aba…, aab…, … . This is the approach I should’ve taken.

I left the solution there, and acknowledged my defeat. Source here: https://github.com/jamiely/count-strings

Before I knew it, I was working through the tutorial. The API was simple, straight-forward, and intuitive, and I was soon done. Still, I wanted to use it for my own project. Unfortunately, the holidays were winding down, and Spring term classes will start soon, so time is very limited.

As a prepubescent child, I played a shareware game where balloons would rise on the screen. You’d use your mouse to draw a bowstring, flying an arrow horizontally through the balloon field, timing the ascent of a balloon. It’s this game that immediately came to mind when I tried to think of simple games. The satisfaction of that balloon popping noise made me long to play. (A satisfaction only outpaced by the sound of popping bubble-wrap.)

So, I decided to work on a game like that other game, and started on making balloons float up. I went to http://openclipart.org and found a great balloon-popping sound at http://soundbible.com. I started out by using CCActions, a CCSequence composed of CCMoveUp and CCCallFuncND to perform cleanup. The balloons would randomly spawn at a certain interval below the screen, and rise to a height above the screen, out of the viewport, and be removed from the layer.

Somewhere along the line, I decided that an bow and arrow would be unnecessary, and that touching a balloon would be enough to pop it. At the same time, I’d target the game at children. I implemented procedures to detect a balloon touch, show a particle effect upon touch, play the popping noise, and remove the balloon from the layer immediately.

Play-testing confirmed this mechanic was a little boring in of itself. I figured that popping balloons should release things stored inside, so you should be able to earn points for popping balloons and touching a “treasure item” dropped from the balloon, things like: diamonds, coins, and treasure boxes. I also added clouds in the background, a timer, and score display, the concept of rounds, and a game over state.

I got this working, but it didn’t seem especially targeted towards children. Lisa, my wife, tried it and confirmed as much. We talked about marking each balloon with a letter, and using the balloons to spell words or elsewise learn about words.

After thinking for a bit, I decided that balloons marked with a letter would release a word starting with that letter. When you touched the word dropped by a balloon, that word would be spoken aloud. I downloaded Audacity, and had Lisa recite a list of words. I spliced them and loaded them into my project Resources folder. Once I got the code working, so that the word sound would play when the word was touched, the audio seemed to low, like it had not been normalized. Even after reducing the volume of the background music and popping sound, the words weren’t loud enough. We’ll have to redo the word sounds at some point.

At this point, I’m mostly done, but may add some more graphics and clean up the code. This project has been a great introduction to Cocos2D and Objective-C programming, in general.

Check out game footage below and the complete source code, including assets, on Github: http://github.com/jamiely/ios-balloon-burst

The project source is located at: https://github.com/jamiely/poetry-parser.

The project involved using the CMU Pronouncing Dictionary found here, creating parsers for the dictionary, and base parsers that could be combined for various forms.

For example, we implemented a parser for syllables that allows us to create a haiku parser.

-- | Parses a Haiku
haiku :: PoemParser RhymeMap
haiku = do
  ns 5
  ns 7
  ns 5
  return Map.empty where
  ns = nSyllables

and a rhyming scheme parser that allowed us to recognize limericks:

aabba :: PoemParser RhymeMap
aabba = rhymeScheme "aabba" Map.empty 

-- | The stress pattern of a limerick
-- note: syllable requirement is implicit
limerickStress :: PoemParser RhymeMap
limerickStress = do
  stressLine [D,U, D,D,U, D,D,U]
  stressLine [D,U, D,D,U, D,D,U]
  stressLine [D,U, D,D,U]
  stressLine [D,U, D,D,U]
  stressLine [D,U, D,D,U, D,D,U] 

limerick :: PoemParser RhymeMap
limerick = limerickStress <&> aabba

For example, we can determine the type of the following poem:

An old silent pond…
A frog jumps into the pond,
splash! Silence again.
- Basho

by running the program thusly:

> ./Main < extra/basho.haiku

with the result:

Opened file
Poem:
An old silent pond...
A frog jumps into the pond,
splash! Silence again.

Dictionary: 

A  AH0
AGAIN  AH0 G EH1 N
AN  AE1 N
FROG  F R AA1 G
INTO  IH0 N T UW1
JUMPS  JH AH1 M P S
OLD  OW1 L D
POND  P AA1 N D
POND'S  P AA1 N D Z
SILENCE  S AY1 L AH0 N S
SILENT  S AY1 L AH0 N T
SPLASH  S P L AE1 SH
THE  DH AH0

Type: Haiku

And the following poem:

something something fox
apple jacks
word here pox

by running the program thusly:

> ./Main < extra/fox.rhyming

with the result:

Opened file
Poem:
something something fox
apple jacks
word here pox

Dictionary: 

APPLE  AE1 P AH0 L
FOX  F AA1 K S
HERE  HH IY1 R
JACKS  JH AE1 K S
POX  P AA1 K S
SOMETHING  S AH1 M TH IH0 NG
WORD  W ER1 D

Type: Rhyming poem: aba

This old blog post from 2005 helped me this time around: http://inquirylabs.com/blog2005/?p=21 to nail down the requirements. Instead of following the installation instructions here, I used Homebrew to set things up.

One of the key requirements is rubysdl, ruby bindings for the SDL multimedia library, and the rsdl gem. The following Gist is a rubysdl Homebrew formula that will help install the required packages: https://gist.github.com/1394440. The SGE formula is not part of the included formulas. I forked the following Gist to provide SGE: https://gist.github.com/1394414/.

# install the sge graphics lib
wget https://gist.github.com/raw/1394414/4a6bfa4a8bab179ebe263b1d044a4322c7628f60/sge.rb
brew install sge

# install rubysdl ruby sdl bindings
wget https://raw.github.com/gist/1394440/8a71160306ad277f08fbad3eaf028b2e8700f2f1/rubysdl.rb
brew install rubysdl

# install the required gem
gem install rsdl
gem install rubygame

Afterwards, most of the rubygame samples ran fine, but the ones requiring opengl had issues. I installed ruby 1.9.2 using rbenv, compiled a new dynamic library libruby.dylib, based on the 1.9.2 source. Then, I cloned this repo providing an upgraded ruby-opengl gem: https://github.com/theymaybecoders/ruby-opengl.

# clone the repo
git clone https://github.com/theymaybecoders/ruby-opengl
cd ruby-opengl

# make sure that the libruby.1.9.1.dylib compiled from the
# ruby 1.9.2 source is present in the gcc class path. For
# me, it was ~/.rbenv/versions/1.9.2-p290/lib/libruby.dylib
# use build option --enable-shared

rake

# build the gem
rake gem

# install the gem
gem install pkg/ruby-opengl-0.60.1.gem

Afterwards, the rubygame opengl samples compiled fine.

Not necessarily a functional feature, pattern matching in Haskell is an incredible feature that has really come to make a lot of sense to me. Given a type constructor with two definitions:

-- Given the type below
data Shape = Rectangle Float Float Float Float | Circle Float Float Float

area :: Shape -> Float
-- We can pattern match below, to change the defn depending on the constructor
area (Rectangle x1 y1 x2 y2) = (y1 - y2) * (x1 - x2) :: Float
-- Use _ to discard matches
area (Circle _ _ radius) = pi * radius * radius

In Haskell, tuples are a basic data type. You can pattern match to unpack a tuple, like this:

tmp = (1, (2, (3, 4)))

unpackTmp1 :: (Int, (Int, (Int, Int)))
unpackTmp1 (_, (_, rtn)) = rtn
unpackTmp1 tmp
-- rtn = (3,4)

unpackTmp2 :: (Int, (Int, (Int, Int)))
unpackTmp2 (_, (_, (_, rtn))) = rtn
unpackTmp2 tmp
-- rtn = 4

So, pattern is something really new to me that I haven’t seen in other languages before. It makes dealing with tuples easy, and you can also use it with lists:

x = [1..10]
secondItem (_:i:_) = i
secondItem x
-- returns 2

thirdItem (_:_:i:_) = i
thirdItem x
-- return 3

tail' (_:rest) = rest
tail' x
-- returns [2..10]