Language Ambiguity

As a programmer, physicist, and engineer, I’m used to words with precise meanings in certain contexts.  Surprisingly, that skill has also helped me learn to skim legal documents.  Sure, I use that skill most often for software license statements, but it has also come in handy for patent terms, buying a house, and taxes.

Git Velocity

After playing around with the number of lines in my recent git commits, I’ve found something that makes my work look roughly linear.  The key is to take the logarithm of the number of lines per commit, before adding them together.  That changes the graph from a completely useless set of stairs:

To a much more gradual slope:

Vacations and slow times are highly visible against a background of steady progress with occasional spurts.  The huge cliffs are now well integrated into slopes of a few commits each; yes, the graph is a bit steeper in those areas, but it’s not clearly dominated by a small set of points.

In this particular case, the value added to the total by each commit is ROUND(LN(LINES+2)*10), where LINES is the number of lines added or changed.  The 2 is necessary for zero-line commits, since zero itself is undefined for logarithms.  It could be 1, causing such commits to contribute nothing at all, but I like the extra punch that the second fake line gives you.  The rounding is simply to yield integers, in case I want to store the results in a text file sometime, and the 10 is a convenient scaling factor to avoid nasty truncations at lower line counts.

The trend line shows a velocity of just over 80 points a day, or 112 points per weekday.  Those points are more or less meaningless as indications of work, but at least say that I’ve been doing something.  To make my quota for a single day would take 16 zero-line commits, 8 two-liners, 4 commits of 14 lines each, 2 of 256 lines, or a single commit of almost seventy thousand lines.  The three huge ones above top out at 104 points each.

That these counts encourage smaller commits is probably a good thing.  Small changes are easy to verify, and make it easier to see the purpose for a given line.  Massive commits are more likely to have unintended consequences, particularly when they’re caused by accidentally committing everything at once, instead of just the piece you were most recently working on.

It’s still possible to game the system, of course, by running through loads of nearly meaningless changes, or even by breaking up one logical changeset into single lines, because it counts only quantity, not quality.  It’s probably best that you leave it for personal use.  On the other hand, if Github or someone wanted to pick it up as an alternative metric, I would not be opposed.

Beeminding Git

After trying out Beeminder to get me to write more, I considered having it make sure I was getting actual work done at work.  Nearly everything we do is in a repository, lately git, so it made sense to base a graph on commits.  Sure, I could base it on time spent, but that’s even harder; I have utterly failed to get accurate counts of the time I spend on anything.  Besides, the results are more important than the process.

With that decided, there are two key metrics that commits give you: The number of commits, or the number of lines changed.  If you do anything resembling a large amount of work on a single commit, the former is grossly understated.  With any amount of copy-and-paste or other trivial changes, the latter is grossly overstated.  Together, they can give you some sort sense of what was happening, but for graphing, they’re probably more lies than reality.  They can also be easily gamed, so never, ever, use this as the basis of any sort of payroll or employment decision.

Akrasial Motivation

My significant other just started a productivity blog as a motivational tool.  It’s been helping us both get things done around the house, almost by virtue of being there.  Part of that may be that it’s being read by family members who want to know more about our life and kids.

This one isn’t, as far as I know.  In fact, it’s read by almost nobody.  I’ve considered submitting it, or at least certain of its categories, to an aggregator or two, but that’s not really its point.  The point is that I need to write.

But I’m a procrastinator, so I spent a couple of years posting only here and there, until I read a post on self-binding by Daniel Reeves.  I signed up for the Beeminder service it described, and was greeted with the happy news that a bot could even fill out the graph for me, from my blog’s feed.  It took a bit to get things rolling, but I eventually got into a habit of posting once a week.  Granted, my procrastination led me to habitually let the graph touch the bottom of the yellow brick road before posting, but I was more or less on track.

However, sometime during this process, the post-processing bot stopped filling things out.  By that time, I had the graph in my head, so my posting schedule kept on track, but my page on the site has flatlined.  Worse, I think I’ve missed a week or two, so I’m probably below the yellow brick road for real.

Therefore, I’m hereby making a new commitment.  I will post once per week for this whole year.  More specifically, I will maintain a rate of at least one post per full seven days from this date.  If I slip from that schedule, I will donate USD$500 toward development of beeminder.com, to Beeminder LLC.  That’s enough that the manager of my money will freak out, but not so much that we’ll be in serious trouble of missing a bill payment.

I think I can do it, but it will probably still be tough sometimes.  One of these days, it may be important to admit that I have money riding on it, but I hope to avoid that fate.  I haven’t even admitted yet that I have a blog of my own…

 

French Peas

This recipe has been a family tradition from my mother’s family, but I had never done it myself until this year. (My siblings and I had specialized responsibilities, but the one who normally does peas was visiting in-laws this year.) Now I get to decide whether to continue the tradition.

Ingredients

• 4 slices bacon
• 4 green onions, chopped
• 1 cup finely shredded lettuce
• 1 Tbsp flour
• 1 cube chicken bullion
• ½ cup water
• 16 oz. peas
• 1 small can water chestnuts
• ¼ tsp salt

Directions

Fry the bacon in a large skillet over high heat until browned on edges. Drain the excess fat. Add the green onions, lettuce, and flour; cook over medium-high heat until some of the lettuce turns transparent, stirring frequently. Add bullion and water, and cook until thick. Add peas, water chestnuts, and salt; cook until peas are tender.

Makes 5-6 servings.

Comments

For six adults and three children, we doubled the recipe and had plenty left over. My spouse finds it a bit soggy, so it might be largely nostalgia for me. Nevertheless, I might experiment with less water and possibly different kinds of lettuce. Given that a co-worker has recently sung the praises of kale, that could be a good place to start.

Infinitely Iterable Permutations

For some crazy reason that didn’t end up needing it, I decided to write a permutation generator that could accept an infinite sequence.  After a bit of experimentation, I managed something based on the second sample permutations() implementation in the itertools documentation.  It will still chew up unbounded amounts of memory and time, but always spits out as many permutations as it can before collecting a new element from the input sequence.

Licensing the Ubiquitous

In local culture, everyone is expected to drive.  Nothing highlighted that more than when I let my license lapse for a couple of years.  (I had moved from another state, and had no car, but the licensing process as documented seemed to require a driving test in my own vehicle.  That it didn’t was a welcome surprise.)  Using any other form of documentation invites even more suspicion and odd looks than the simple fact of not owning a car.

Fortunately, we also expect all drivers to have had proper training.  Far too many people are killed by vehicles as it is; I shudder to think what would happen if we just let everyone behind the wheel as soon as they were legally old enough.  Yet somehow, we do just that for several other dangerous activities.  Perhaps the difference is the number of innocent bystanders who could get hurt.  A new driver, after all, is less likely to kill himself than the child he didn’t notice playing in the street.

Languages I’ve Learned: Professional Development

After a short time of playing with esoteric programming languages, I’ve found myself learning relatively few outside of a real use case.  Most of this next batch were directly inspired by school, hobby, or work projects.  I actively use at least half of them; more than the first two sets combined.  However, this set also covers more time than the first two, nearly reaching a decade.

Languages I’ve Learned: Experimental Phase

Somehow, I had learned at least ten programming languages before attending college.  However, some of them were very limited in scope, and not all of them have endured.  That’s even more true of the next batch, all learned within my first two years at a major university.

Languages I’ve Learned: The Early Years

Somehow, it has failed to surprise me to learn a new programming language in a week.  Once the fact was pointed out, I figured it might have been from the sheer number of languages I’ve seen.  I won’t claim to be able to program in all of them, particularly not without a manual, nor do I still use many, but I’m familiar with over thirty.

These are, as nearly as I can recall, the first ten that I learned, listed in roughly chronological order.