German Pancakes

When I was young, one of my favorite breakfast items was something we called German pancakes.  For the whole family, we used two glass pans full.  In college, I mangled the recipe into something about equal parts eggs, milk, and flour, mixed in a blender until slightly thick. Then, after marrying a vegetarian and living for a few years without eggs in the house, I forgot about them.

A cookbook recently given to one of our children has a recipe for something it calls a Dutch baby pancake with buttery apples.  I’m in charge of breakfast, and generally make some kind of pancakes or waffles every Saturday, so I decided one day that it sounded like fun.  As the batter came together, I suddenly recognized what I was doing, and got very excited.

Licensing a Project

I’ve been hitting certain limitations in a tool I use almost daily.  The things I want to add might not be that hard, except that it’s a proprietary program and I don’t have the source.  Even worse, it’s an old version of the program, my support contract lasted only one year, and the newer versions are an order of magnitude more expensive.  It’s time to move on.

There’s another commercial tool with a limited-time demo that improves in some areas and regresses in others, but it’s even more expensive.  There are at least three open-source applications in the problem space, but I haven’t convinced any of them to work properly on my machine, and one doesn’t even compile.  The functionality I use most doesn’t seem too hard to implement myself, given my experience with most of the back-end issues, so I’ve decided to write a new one.

I don’t expect to compete effectively against two big names, so I might as well make my program open source.  I don’t really expect that many contributions from the community, but I still owe more than I’ve given back, and my work might benefit somebody.  If it’s good enough, it might even get picked up by my Linux distribution.  To enable that, I need to choose license terms, preferably without drafting my own.  Fortunately, the Open Source Initiative has compiled a convenient list of approved licenses, with the more common ones at the top.

Soft-pedaling the Truth

Where do you get your information?  Given that you’re reading this, I’m going to assume that you collect quite a bit of knowledge from the internet.  I also expect that you’re smarter than average, and probably have a technological bent.  You are probably conversant with the major theories of physics, chemistry, biology, and astronomy, having learned many of them at school.

Curiously, there are many who refuse to believe some of the things you take for granted.  My own grandfather, for example, despite a subscription to Popular Science, still denies the plausibility of a Big Bang.  Indeed, for centuries, it was thought that the universe was essentially static, with stars circling around each other in perpetuity.  For millennia before that, it was common to think that the Earth was the center of the universe.

Most of that time was before the age of scientific rigor, though; how can people still disbelieve?  A significant part of the answer may lie in a deep flaw of the scientific community: It doesn’t advertise well.

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.