Galapagos Photo Processing

The really enjoyable part of Galapagos and taking photos is over. Now I'm faced with the daunting task of processing these photos:

Lightroom

That's about 120GB total of mostly Canon 7D raw photos (usually about 20MB each) plus some stills and videos from my Panasonic Lumix DMC-TS2 point-and-shoot. This isn't that unusual for me - I sometimes shoot 30GB of photos on a single night of a football game. Still, there's complexity here as I want to find the "best of show" shots of particular animals while retaining enough of a time series to capture the flow of the overall trip.

My workflow involves aggressively deleting photos that are non-keepers. I'll go through each day's photos in Adobe Lightroom and use single-key shortcuts to mark photos as keep or purge. This first pass is meant to discard photos that shouldn't be kept regardless of my later editing - poor exposure, blurry, etc. Sometimes I'll shoot off a series of photos of a bird in flight and there's an obvious keeper out of multiple shots - no need to keep the 12 inferior ones. Note that purging at this stage means forever deletion - I don't keep these photos around. I'll probably prune from 6000-ish to about 200-300 or so.

After this pass I'll do another round of review involving rating photos (usually 3, 4, or 5 stars). From there I can purge the lower-rated photos and start to arrive at a solid set for editing and publishing. At this state purging doesn't mean forever deletion. I just take them out of my working group for the trip.

Next I'll do group and individual photo editing. We will likely do a photo book and video from the keepers, and there will be a few that I'll want to process even more for wall hanging. Here I might bring Photoshop and some other tools like Topaz Adjust to play to produce the highest quality output I can.

To Galapagos

Soon we depart for our first big family trip since our Europe trip almost exactly three years ago. A year ago we were set on heading to Greece for spring break 2011 but Julie and I decided we'd rather hit the islands there when the weather was warmer. Julie did some exploring and offered up Galapagos as an option -- how could I say no?

This trip Julie did all the legwork, choosing Columbus Travel after researching a number of options. Travel to the islands is very constrained - while you can get to the island on your own, moving around the islands is best done on a full-featured cruise. After much discussion amongst ourselves and travel companions Dave and Lisa we settled on the Athala. The catamaran style should keep it more stable (and sea-sickness free, mostly) in the open water, and the itinerary hits the key spots we want to see.

Athala

I'm certainly not ready to give an endorsement to Columbus Travel or the Athala yet - that can wait until after the trip.

Here is our schedule:

  • Day 1 - fly to Quito, Ecuador via Houston. Not a significant time zone change but the trip will take most of the day. We will stay at the Swissotel for both stops in Quito.
  • Day 2 - explore Quito, primarily via some excellent self-guided tours we found at the tourism office.
  • Day 3 - fly to Baltra, Galapagos via Guyaquil. Board the Athala for an eight day cruise around the islands.
  • Day 9 - fly back to Quito with just a half day to finish some local touring.
  • Day 10 - return to Portland via Houston

itin

I've got the photog gear packed, movies loaded on iPad, books on the Kindle. See you on the other side.

SuperQuest and Willamette Programming Contest

TechStart, a non-profit that I've been helping run for 6+ years now, held its annual SuperQuest Spring Conference and Willamette University - TechStart Programming Contest down in Salem, OR on Saturday March 12.

20110312-Spring Conference-27

At our spring conference we trained nearly 40 Oregon and Washington K-12 teachers in various topics related to technology and computer science: Scratch programming for elementary students, robotics, video production for instruction, and discrete mathematics. The instructors for these training sessions are teachers that have a proven track record in the classroom - they exude credibility.

Don Domes showing video capture

One of the highlights for me was seeing fellow TechStart board member Don Domes teach how to create video captures for instruction on a tight budget. He uses Khan Academy as his model.

Programming team

While the teachers are being trained, over a dozen high school computer programming teams were hard at work on the state high school programming competition run by Fritz Ruehr of Willamette University. This was my fourth or fifth year attending the event, and the second time watching my own son Jacob compete as part of the Sherwood High School team. Teams work on 14 different computer science problems (in the style of the ACM programming contest, problem set from 2010) and score points for successful completion as well as bonus points for finishing problems before other teams.

Here's a sample of one of the easier problems of the day:

Bracket Balancing

Programmers know how annoying it can be when parentheses, brackets, and braces get out of balance in their code. You are working on a programmers' editor and need to write a utility which will highlight selected portions of the code in red if any of the bracketing characters within are out of balance. Your code will check the selection for "round" parentheses (), square brackets [], curly braces {} and even angle brackets <>. Furthermore, you should check a "no crossings" rule, so that different shapes of brackets don't get mixed up. For example, a string like " < () [ { ] } >" is not allowed: even though the curly braces and the square brackets come in matched pairs, they cross each other in between. Finally, your program should ignore any non-bracket characters, so that other bits of code (perhaps variable names, numbers, and keywords) can be intermixed. As output, you should write out the word "OK" (if everything balances, with no crossings) or "BAD" if something goes wrong. (If you are using a GUI, you may even highlight the code in green or red to indicate OK and BAD strings... just make sure that it's clear when your check is finished!)

Some examples:

Input: foo(bar[i].{}<<>>[baz]123)    Output:  OK
Input: oof{}[<<quux>> 17 ] ( {}      Output:  BAD
Input: [17] () 23 .. < [ > foo >     Output:  BAD

I had some free time towards the end of the contest and worked through a solution on my own using Ruby:

VALID_OPEN = "([<{"
VALID_CLOSE = ")]>}"

def open_token(char)
  return VALID_OPEN.index(char)
end

def close_token(char)
  return VALID_CLOSE.index(char)
end

def matches_open(open, close)
  VALID_OPEN.index(open) == VALID_CLOSE.index(close)
end

def bracket_balance(input)
  token_stack = []
  input.chars.each do |char|
    if open_token(char)
      token_stack.push char
    elsif close_token(char)
      return false if !matches_open(token_stack.pop, char)
    end
  end
  token_stack.length == 0
end

while expression = gets
  if bracket_balance(expression)
    puts "OK"
  else
    puts "BAD"
  end
end

I think test-driven development is a great methodology for approaching problems like this, and I plan to do some mentoring of Jacob and his team members as they approach next year's contest. Here are some samples of tests I wrote as I worked on the problem (these would look even cleaner if I used Cucumber or FIT-style scenario tables):

class TestBracketBalancing < Test::Unit::TestCase
  def test_empty_string
    assert bracket_balance('')
  end

  def test_single_paren
    assert !bracket_balance('(')
  end

  def test_double_paren
    assert bracket_balance('()')
  end

  def test_1
    assert bracket_balance('foo(bar[i].{}<<>>[baz]123)')
  end

  def test_2
    assert !bracket_balance('oof{}[<<quux>> 17 ] ( {}')
  end
end

Jacob's team had a solid teamwork model - he and one team member focused on implementation and programming and took on some of the easier problems on their own, while their senior team member worked ahead on paper in pseudo-code on some of the more challenging items. They did very well, finishing second overall and just a hair behind the winning team (both teams solved 8 of the 14 problems).

Varsity 2nd Place

Notes and Text Files with DropBox

A while back I wrote about my current Mac OS X ecosystem. Part of this ecosystem has evolved quite a bit - I'm no longer using Notational Velocity or SimpleNote. The main reason is that DropBox is the begin and the end of my synchronization needs - SimpleNote adds an unnecessary level of complexity to my world and at times would step on DropBox's toes and cause problems.

DropBox support has become ubiquitous on iPad applications. The DropBox app itself is more than adequate for viewing text files, but I prefer to use the fantastic Nebulous Notes as it excels for both viewing and writing text files.

DropBox for Text Files

Nebbulous by default will attach itself to a particular DropBox folder which matches perfectly how I manage all my plaintext notes on my desktop with TextMate. I can create and edit content on any of my devices and everything will stay in synch easily through DropBox.

There are several decent text editors available on the iPad with decent DropBox support - I've tried many of them. I prefer Nebulous because of the text macro bar support which makes it dead simple for me to compose in MultiMarkdown. The iPhone app is just as good.

Finally, on the Mac desktop I've become proficient enough with TextMate to obviate the need for a tool like Notational Velocity. If you don't have TextMate then certainly considering using this tool (but use the nvAlt fork, not the original).