Thursday, June 23, 2016

Cutting the electronic cord: Setting up a fully paper TODO list tracking strategy

A few months back I started a new TODO list strategy. Rather than having a master task list in the Cloud and creating a daily TODO list in a paper notebook, I maintained both an electronic and paper master task list. The electronic version was tracked in git + emacs + org-mode and the paper version was on index cards.

While git + emacs + org-mode was certainly functional, I never had cause to do anything particular sexy with the setup. In fact, I was hoping this experience would convert me from a fan of subversion to a fan of git, but alas, it only reinforced my appreciation for the simplicity of subversion.

The index cards, on the other hand, were a joy to use. I love that each project is represented by a single card, and that spreading out the cards gives me an overview of all possible tasks to work on:

My daily ritual has become this: brew a cup of tea, spread out the cards, and review where I'm at. I then choose a sequence of tasks to tackle for the day, and stack the cards accordingly:

As I complete tasks, I cross out the line item in question. Switching projects means putting the card on top at the back of the deck, and giving my full attention to newly visible card.

The 10 lines of a 3x5 index card are perfect for keeping tabs on active tasks on a project. If all goes well, project cards become a crossed out mess. No biggie, these cards get recycled (for example: as drawing canvases), and I create a fresh card for the project. The turn over in cards helps keep both physical and metal clutter to a mininum.

I have three recurring activities that I like to fit into my day: scrubbing my work e-mail, scrubbing my personal e-mail and blogging. I wrapped these cards in packing tape, to make them more durable. As a bonus, they serve as tiny whiteboards. These special cards get integrated into the daily stack like any other project.

A few weeks back I splurged on a set of colored pens, and the result is that I can now color code information on the cards with ease.

There's no doubt that part of what I enjoy about this system is that the physical actions on the card reinforce my mental goals. For example, when I sequence the cards for the day, put them in a stack, and attach a mini-binder clip, I'm reinforcing the change-over from thinking big picture to thinking only about a specific task.

So the setup works. Of late, however, the drag of maintaining tasks both electronically and in paper form was getting to me. Yes, updating a task in both places takes just a few seconds, but still, all those seconds add up. So it was time to cut the cord and either go all electronic or all paper. Given the benefits of the paper strategy, I decided to go that route.

Before switching strictly to paper, however, I needed to account for the two main benefits that the electronic system was providing. These include: the always-available always-backed-up nature of storing a text file in git, and the quick linking capabilities offered by emacs + org-mode.

I have pretty strict rule about my task list: never depend on my memory. Ever. If I were to get bonked on the head and suffer from short-term amnesia, I should be able to look at my task list and know exactly what I should work on next. So yeah, I take the integrity of my task list very seriously. Depending on a set of index cards which could be lost, forgotten in a coffee shop, run through the washing machine or destroyed in a freak tea spilling, is a bad idea. In short, I needed a backup strategy.

Turns out, this was an easy conundrum to solve. Every morning I spread out the cards to see what I should work on that day. The solution: I snap a photo of these spread out cards. Problem solved. The photo is backed up in the cloud and accessible everywhere. Yes, it means I have a daily backup and not the every-single-change backup that git provides, but I can live with that. As a bonus, it forces me to not get lazy and skip the planning-overview step of my process. Problem #1, solved.

The second challenge has to do with linking tasks to more information. As I said above, I don't like to depend on my memory. Another manifestation of this principle is that when I create a TODO item I like to link it back to a detailed source of informative. Consider this fake task list:

Project Xin-Gap
* Fix user login issue

When I documented this as a task, I knew exactly what "login issue" I was referring to. Two weeks later (or one big bonk on the head), I may have no clue. org-mode makes it very easy to link items in the outline to a URL. In the above case, I'd link the text "Fix user login issue" to either a bug report URL or to the URL of the e-mail message where the issue was reported. These links allow my TODO list to remain a sort of tip of the iceberg: the details, like the majority of the iceberg, are hidden from view. But they're there.

So how do I replicate these links in an index card environment? This one took a little longer to figure out. Possible ideas included: NFC stickers and QR Codes. Ultimately, I realized what I needed was to leverage a URL shortener.

For example, if I wanted to link to a bug report over at:, I could drop that URL into and get out something like I could then note 28UgMwR on the index card. To access the bug report, I reverse the process: use the code to form a link, which in turn will take me to the bug report. The problem is, manually running these steps for was too time consuming and out of the question.

After experimenting a bit with YOURLS, I finally settled on an even simpler approach. I already have a URL shortener setup for my Google Apps account. It was a Google Labs Project back in the day, and somewhat shockingly, it still runs without issue. I access it via: I found that I if visit the URL:

I'm taken to this page:

I can then write Z23 on my Index Card and hit Add Short Link on the above screen, and I'm all set. Google's URL shotener even comes with a Firefox Protocol Handler which means that I can type: goto:z23 and the browser will expand the URL and visit the correct page.

To streamline this process I created a bookmarklet that does almost all of this for me:

(function() {
  function c() {
    var dict = ['A','B','C','D','E','F','H','J','K','L','M','N',
    return dict[Math.floor(Math.random() * dict.length)];
  }'' +
              'url='+encodeURIComponent(location.href) + '&' +
              'path=' + c() + c() + c(), '_blank');

With one click on my toolbar, I get a browser tab opened to the add-short-link page where there's a random 3 digit code (minus any ambiguous characters like l vs 1 or 0 vs O). I note the 3 digit code on paper, click Add Short Link and close the tab. When I want to visit a task's linked item, I just enter the URL goto:ZZZ where ZZZ is the 3 digit code that I've noted.

Of course, if you want to pursue this, you'll need to setup your own link shortener. And for the life of me, I can't find any indication as to how you'd setup the Google Labs URL shortener I'm making use. But you'll figure it out, I'm sure. The bottom line is, you can combine a URL Shotener and a bookmarklet to make paper linking relatively painless.

With my two challenges solved, I went ahead and cut the electronic cord. It feels strange to depend solely on a stack of cards that I could trivially lose. But my daily photo backup gives me confidence, and the daily handling of cards reminds me that there's real power in working with physical materials.

Besides, it's only a matter of time before I refine my system again. As long as I have TODO items, I'll be on the lookout for a better way of organizing them.

Wednesday, June 22, 2016

Lessons from a very tiny Ring Pop

The most surprisingly impressive video I've seen this week has to be: DIY American Girl Doll Ring Pops. Yes, you read that right. It's a tutorial for creating itty bitty (fake) Ring Pops to go on your American Girl doll.

Perhaps it was the seemingly ridiculous nature of the video that got me to watch it. Turns out, you should watch it too:

That's amazing, isn't it?

I mean, you're sharpening your observation skills, hacking various materials, getting creative with a tiny crafting techniques and practicing the art of reverse-engineering, all in the hopes of creating a believable model.

What an excellent reminder that problem solving and engineering lessons aren't just found in coding exercises or canned lab experiments. Just embrace what you already love, and you'll get those benefits. You just have to dig deep enough.

Hurray for play!

Tuesday, June 21, 2016

Shut up Lewis, it's a free house

Continuing on the theme of sneaky neighborhood improvements, I give you this randomly placed bird house in Clarendon:

Like the impromptu garden near our home, I applaud the creative soul who decided to dress up our urban landscape for all to benefit.

That said, I couldn't help chuckle at the scene as I recalled Demetri Martin's bird-house schtick. Give it a listen:

Monday, June 20, 2016

The Guerrilla Garden Next Door

I was walking down our street and this rock caught my eye:

Looking around, I realized that someone had cleared a small section of the tiny Arlington View Park, planted some native species, and neatly labeled them. How wonderful!

While this "park" has benches, a sandbox and turtle statue for kids to climb on, it looks really worn out. I love the addition of a mini garden, which adds some life and fresh value to this green space.

This leads me to all sorts of questions: First off, was this an official park effort? Or was this Guerrilla Gardening in action? I checked, and there's no indication that this was any sort of official program. I'm so pulling for this to be guerrilla effort.

But more importantly, it gives me ideas for the massive eye-sore that's across the street from the park. Behold:

That's an overgrown yard with a condemned property on it. The For-Sale sign is long since defunct, with both the website and phone number no longer being operational. Heck, it's even behind on its taxes. Part of me was thinking it was time to kvetch to the county about this monstrosity, but maybe it would be more fun to take the work started in the Arlington View park and spread it there.

Seems like it wouldn't be that hard to clear part of the "lawn" and throw in some plants, making something beautiful and educational where detritus currently stands.

I'd love to figure out who did the improvements at Arlington View Park and then coax them into tackling the mess next door. I'd make a great Jr. Assistant Gardener, as what I lack in skills I make up for in passion and curiosity.

Who's in?

Friday, June 17, 2016

It's a Plane! It's a Bird! It's a Helicopter! It's more Planes!

ArlNow reported that at noon today the Coast Guard would do a flyover, celebrating 100 years of aviation. According to the public route, The flyby would pass directly over the Air Force memorial, which is right near our house. Way too close to pass up the photo op. I figured I'd duck out at 11:50am and catch the action.

As I walked out my door, this guy flew by:

I figured, that's it, I'd missed the show. Still, I made my way to the memorial. When I arrived, there were a gaggle of folks, cameras still poised for action. The good news: I hadn't missed the airplanes. The bad news: the flyby had been pushed back to 1pm.

You might think that waiting around for an hour was annoying. Not so in the least.

For one thing, I noticed an unusual airliner take off in the distance. It was clearly a passenger plane, but it was not from DCA. Check it out:

I do believe that's Air Force One! How cool is that?

Of course, you don't need a fancy flyover to see interesting aircraft over DC. This sort of sight is actually quite common:

Even Mother Nature got in on the action, with what appeared to be a Bald Eagle and some sort of hawk flying overhead. Their speed and agility almost mocks our attempts at flight:

I even had time to shoot a few hyperlapses. Check it out:

In the last few seconds of the third timelapse you can actually see the fly over occur.

The most interesting part of waiting was chatting it up with some old timers, one of which is an active member of the Civil Air Patrol. I explained that in my head, I always associated the Civil Air Patrol is a 1950's, much like Ham Radio and fallout shelters. He set me straight, explaining that they play an active role today, particularly in the emergency services department. I had no idea.

We got on the topic of the (to me) mystery Orange Helicopter's that we're always seeing flying around DC. He explained to me that's Blackjack, a Coast Guard helicopter that enforces the no-fly zone around DC. Apparently the local Civil Air Patrol helps with training by acting as simulated airspace violators, testing Blackjack's response time. It's all explained in this news clip from 2011. Amazing stuff, actually.

Finally, the fly over did actually occur. See:

Fun times! Definitely an hour well spent!

Update: Check out this video from the Manassas Airport, where the planes departed from. Impressive stuff!

Thursday, June 16, 2016

Got Data? Adventures in Virtual Crystal Ball Creation

There's two ways to look at this recent Programming Praxis exercise: implementing a beginner level statistics function or creating a magical crystal ball that can predict past, present and future! I chose to approach this problem with the mindset of the latter. Let's make some magic!

The algorithm we're tackling is linear regression. I managed to skip statistics in college (what a shame!), so I don't recall ever being formally taught this technique. Very roughly, if you have the right set of data, you can plot a line through it. You can then use this line to predict values not in the data set.

The exercise gave us this tiny, manufactured, data set:

x    y
60   3.1
61   3.6
62   3.8
63   4.0
65   4.1

With linear regression you can answer questions like: what will be the associated value for say, 64, 66 or 1024 be? Here's my implementation in action:

A few words about the screenshot above. You'll notice that I'm converting my data from a simple list to a generator. A generator in this case is a function that will return a single element in the data set, and returns '() when all the data has been exhausted. I chose to use a generator over a simple list because I wanted to allow this solution to scale to large data sets.

Below you'll see a data set that's stored in a file and leverages a file based generator to access its contents. So far, I haven't throw a large data set at this program, but I believe it should scale without issue.

The call to make-crystal-ball performs the linear-regression and returns back a function that when provided x returns a guess prediction for y. What? I'm trying to have a bit of fun here.

Looking around on web I found this example that uses a small, but real data set. In this case, it compares High School and College GPA. Using linear-regression we're able to predict how a High School student with a 2.7, 3.0 or 3.5 GPA is going to do in college. Here's the code:

(define (gpa-sat-test)
  (define data (file->generator "gpa-sat-data.scm"
                                (lambda (high-gpa math-sat verb-sat comp-gpa univ-gpa)
                                  (list high-gpa univ-gpa))))
  (let ((ball (make-crystal-ball data)))
    (show "2.7 => " (ball 2.7))
    (show "3.0 => " (ball 3))
    (show "3.5 => " (ball 3.5))))

And the answer is: 2.91, 3.12 and 3.45 respectively. So yeah, that's good news if you were dragging in High School, you're GPA should climb a bit. But High School overachievers should beware, your GPA is most likely to dip. D'oh.

Below is my implementation of this solution. You can also find it on github. As usual I find myself preaching the benefits of Scheme. The code below was written on my Galaxy Note 5 using Termux, emacs and Tinyscheme. With relative ease I was able to implement a generator framework that works for both lists and data files. I'm also able to leverage the Scheme reader so that the data file format is trivial to operate on. Finally, I wrote a generic sigma function that walks through my data set once, but performs all the various summations I'll need to calculate the necessary values. In other words, I feel like I've got an elegant solution using little more than lists, lambda functions and sexprs. It's beautiful and should be memory efficient.

Here's the code:


(define (show . args)
  (for-each (lambda (arg)
       (display arg)
       (display " "))

(define (as-list x)
  (if (list? x) x (list x)))

(define (g list index)
  (list-ref list index))

(define (make-list n seed)
  (if (= n 0) '()
      (cons seed (make-list (- n 1) seed))))

(define (list->generator lst)
  (let ((remaining lst))
    (lambda ()
      (cond ((null? remaining) '())
      (let ((x (car remaining)))
        (set! remaining (cdr remaining))

(define (file->generator path scrubber)
  (let ((port (open-input-file path)))
    (lambda ()
      (let ((next (read port)))
        (if (eof-object? next) '() (apply scrubber next))))))

(define (sigma generator . fns)
  (define (update fns sums data)
    (let loop ((fns fns)
        (sums sums)
        (results '()))
      (cond ((null? fns) (reverse results))
      (let ((fn (car fns))
     (a  (car sums)))
        (loop (cdr fns)
       (cdr sums)
       (cons (+ a (apply fn (as-list data)))

    (let loop ((data (generator))
        (sums (make-list (length fns) 0)))
    (if (null? data) sums
 (loop (generator)
       (update fns sums data)))))

;; Magic happens here:
;; m = (n × Σxy − Σx × Σy) ÷ (n × Σx2 − (Σx)2)
;; b = (Σy − m × Σx) ÷ n
(define (linear-regression data)
  (let ((sums (sigma data
        (lambda (x y) (* x y))
        (lambda (x y) x)
        (lambda (x y) y)
        (lambda (x y) (* x x))
        (lambda (x y) 1))))
    (let* ((Sxy (g sums 0))
    (Sx  (g sums 1))
    (Sy  (g sums 2))
    (Sxx (g sums 3))
    (n   (g sums 4)))
      (let* ((m (/ (- (* n Sxy) (* Sx Sy))
     (- (* n Sxx) (* Sx Sx))))
      (b (/ (- Sy (* m Sx)) n)))
 (cons m b)))))

(define (make-crystal-ball data)
  (let* ((lr (linear-regression data))
         (m  (car lr))
         (b  (cdr lr)))
    (lambda (x)
      (+ (* m x) b))))

;; Playtime
(define (test)
  (define data (list->generator '((60   3.1)
      (61   3.6)
      (62   3.8)
      (63   4.0)
      (65   4.1))))
  (let ((ball (make-crystal-ball data)))
    (show (ball 64))
    (show (ball 66))
    (show (ball 1024))))

;; From:
(define (gpa-sat-test)
  (define data (file->generator "gpa-sat-data.scm"
                                (lambda (high-gpa math-sat verb-sat comp-gpa univ-gpa)
                                  (list high-gpa univ-gpa))))
  (let ((ball (make-crystal-ball data)))
    (show "2.7 => " (ball 2.7))
    (show "3.0 => " (ball 3))
    (show "3.5 => " (ball 3.5))))


Wednesday, June 15, 2016

Review: Shooters by Erik Trautmann, Jerwa Brandon and Steven Lieber

Shooters, by Erik Trautmann, Jerwa Brandon and Steven Lieber, is a graphic novel (read: comic book) that follows the life and times of an Iraq War soldier. It captures the War Is Hell side of a modern conflict, where an individual's struggle is often lost in the noise of every-day life.

The Civil War had brother fighting brother and battlefield surgeons using carpenter tools to perform field amputations. World War I had gruesome trench warfare and gas attacks. World War II had the beaches of Normandy and the nuclear detonations over Japan. Vietnam had young men being drafted and images of napam being used in the jungle. But in Iraq and Afghanistan the horror is on a different scale, one that's easy for the non-military citizen to miss. I see Shooters as a book attempting to shine a light on this experience.

As a graphic novel, I found that the artwork added to the storytelling and generally helped pull me in. It certainly adds a unique feel to the book and probably helped me stick with it. Which leads to my biggest criticism of Shooters: it's just too dang cliche.

The story arc felt like the author was trying to check every box; and perhaps he was. Without going into detail, everything that can go wrong in a soldier's life seems to. I felt myself flipping pages in the book thinking, yep, of course that just happened. I wish the book had more surprises.

Ultimately though, I'll cut the author some slack. The fact that topics like PTSD, for example, have become cliche is actually a good thing. That means that the repercussions of modern warfare are seeping into the consciousness of those who have never been on the battlefield. So yeah, there isn't a lot new here. But better to read this story and find it a bit tedious than simply wave your hat at the ballgame when they mention veterans, or tear up watching a YouTube video of a school child embrace a parent they haven't seen in months, and may never have seen again.

War Is Hell is a cliche worth repeating.

Tuesday, June 14, 2016

Happy Birthday to This Guy

To my Drinking Buddy, Fishing Guru, teacher of countless life lessons and the provider of half my DNA, Happy Birthday!

L'Chaim! To many more!

On the frustration of trying to learn a new skill

Thanks in part to the Teoh Yi Chie's YouTube channel, I've been on a bit of a drawing kick. Whenever I have a few minutes, I'll grab a blank index card, a pen, and draw away. The results are horrendous.

I was on the Potmac River last week and thought, hey, I should draw the scene. Again, the results were downright cringe-worthy. The drawing to the left was made on site, the drawing to the right was made the next day from a photo.

One phrase keeps going through my mind as I engage in this practice:

To become good at something, you need to be bad at it first.

Rationally, I know that with enough practice I'll get there. But man, is this learning thing tricky business!

Friday, June 10, 2016

A Black-Crowned Night-Heron and his fishing buddy

Who doesn't love seeing a Black-crowned Night-Heron? At first glance, they look a plump seagull. But upon closer inspection, they're definitely a heron. My first sighting was back in 2014.

I captured this photo last night at around 8:00pm, so this guy was living up to his name. Looks to me like he was out for some dinner:

A few minutes later I captured this blurry photo:

You can see the heron fairly clearly, and to the left, perched on a rock, is a racoon. Definitely feeding time for our night loving friends; and time for me to get back to the car.


Related Posts with Thumbnails