This year, I noticed part of the form that hadn’t applied before now:

No. of children on 6c who [...] did not live with you due to divorce or separation (see instructions)

Unfortunately, the instructions are more concerned with defining divorce or separation than with clarifying what the statement means. Pop quiz: Which is more appropriate?

1. Number of children who lived with you, but not due to divorce or separation; or
2. Number of children who did not live with you, but would have had it not been for a divorce or separation.

I’m fairly certain that the first answer I came up with was wrong. Certain enough to have scoured instructions and re-read the form until I realized my mistake.

The worst part is that someone probably spent serious time trying to make that line as precise as possible while still fitting in the space available for it.  My confusion is exactly the kind of thing that is cleared up almost automatically in verbal communication, through small cues of emphasis or through questions, but legal language has to be understandable in written form, preferably without any external help.

Perhaps I would have made a good patent lawyer, but I doubt it would have been as enjoyable as programming.  The bugs are so much harder to fix.

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.

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.

That said, I came up with a simple commit hook to count the lines added or changed by a commit, format it in the style of a Beeminder line, and append it to a file.  I have actually used that file to see what I was working on during a given time period. It uses the repository’s directory name as a convenient project tag; I could have had it look at .git/description, but that file has an unfortunate tendency to keep its default “Unnamed repository” message. Removed lines are ignored, because they don’t usually represent real work on my part. It also has an unfortunate tendency to duplicate rebased commits, but those can be spotted by having a date entirely out of order.

#!/bin/sh
#
# Count the number of lines changed,
# writing them out in Beeminder format.

cd "`dirname $0`/../.."
repo="`basename $PWD`"

git show --numstat --date=short | \
  perl -w -e '$date = ""; $lines = 0; $comment = "";' \
  -e 'while (<>) { /^Date: +([-\d]+)/ and $date = $1 and $date =~ y/-/ /; $comment or /^ +(.*)/ and $comment = $1; /^(\d+)/ and $lines += $1; }' \
  -e 'print qq($date $lines "'"$repo"': $comment"\n);' \
  >> ~/Documents/commit-lines.log

A graph of my work for the last six months shows the real problem:

Yes, there are three commits worth over twenty thousand lines each.  One was an upgrade of a third-party component, one included a large number of static assets from another team, and the third merged the branch that included the second commit.  Removing those three gives the graph a bit more texture, but there are still a few large outliers.

Maybe I can salvage something from it, perhaps by taking a logarithm, but it really hasn’t been important enough.  Nevertheless, it might be interesting to someone.

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…

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.

from itertools import product

def iperms(iterable, r):
    r'''Permutation generator.
        Differs from itertools.permutations() in that it accepts infinite iterables;
        that also causes it to return results in a different order, and require r.

        >>> ' '.join(map(''.join, iperms('ABCD', 2)))
        'AB BA AC BC CA CB AD BD CD DA DB DC'

        >>> from itertools import count, imap, islice
        >>> ' '.join(map(''.join, islice(iperms(imap(str, count(3)), 2), 20)))
        '34 43 35 45 53 54 36 46 56 63 64 65 37 47 57 67 73 74 75 76'

        >>> from itertools import count, imap, islice
        >>> ' '.join(map(''.join, islice(iperms(imap(str, count(3)), 3), 18)))
        '345 354 435 453 534 543 346 356 364 365 436 456 463 465 536 546 563 564'
    '''#"""#'''
    n = 0
    pool = []
    for item in iterable:
        pool.append(item)
        n += 1
        for indices in product(range(n), repeat=r):
            iset = set(indices)
            if len(iset) == r and n-1 in iset:
                yield tuple(pool[i] for i in indices)

Yes, it could be optimized; there are a whole lot of product() results that are simply thrown out.  If I were using it for something important, I would work on it some more, but I just don’t care enough right now.  The two-item case in particular displays a pattern that looks easily optimizable, but the addition of more elements seems to defeat that.

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.

Similar could be said for other licensed activities.  Several professions, for example; doctors in particular could get people killed without the proper training, and have been impersonated by quacks and charlatans for centuries.  A bogus lawyer, engineer, or even car mechanic could get you into deeper trouble than you started with; each has a licensing body in various principalities, but may be unregulated in others.  Schools and universities, or their individual programs, can be accredited by various standards organizations; failure to do so can lead to leaving alumni without job potential.

Yet there are other important activities that aren’t commonly licensed.  I have a license to be a parent, complete with mandatory training, but we let almost anybody raise their own children as long as they aren’t obviously horrible at it.  Some poor children end up with lasting damage from poor parenting, while others simply emerge completely unprepared for the realities of life.  Would it be better to offer, or even require, training for every new or potential parent?  Would it be just?  Could we at least offer community-sponsored child care by highly trained, well paid tutors?  Or at least legally recognize that proper childcare is not an unskilled labor?

We could go even earlier, to sex itself.  Some form of sex education is routinely offered in this country, but only with consent of a legal guardian.  Even at that, it usually misses a few critical components, such as identification of a bad relationship before it gets to that point, or what a woman really needs out of it.  Some programs even omit descriptions of contraceptive measures, much less their limitations, leading the unlearned teens toward the route of maximum panic: reckless abortion.  How many fewer children would be conceived if people were led through the hard decisions beforehand?

In some cases, even that activity has an earlier stage: alcohol consumption.  This one is perhaps the worst of all for a form of regulation that can lead to abuse.  You’re not allowed to touch the stuff until a certain age, at which point it’s suddenly no holds barred.  This gets compounded by certain religious groups who espouse abstinence without explanation, leaving children with no example of responsible drinking, while television and advertising frequently play up appealing aspects.  Is it any wonder, then, that a certain number of college students kill themselves by binging?  What if one needed a license to purchase alcohol, with its own training classes?

At some point, yes, the number of licenses could get ridiculous.  They really could be tied into one card, though, as long as relevant agencies had connections to a state database that stored who is licensed for what.  That would also allow for quick and easy revocations when one gets abused, and with stored photos can also serve as an anti-counterfeiting measure.  For bonus points, it lets non-drivers use their identification card without the odd looks; only police, dealerships, and vehicle rental agencies even need to know, so it doesn’t need to be printed on the card.  I wouldn’t even have needed a second card when I finally got around to taking the written test; an updated computer entry would have sufficed.

Maple

An early course in my Physics program was centered entirely around learning Maple.  There were some physics lessons thrown in here and there, but they were mostly supplemental, having been covered in more depth by the course we were supposed to be taking at the same time.  Naturally, I found it ridiculously easy, and ended up supervising a section in later years.  The program itself was useful throughout my time at the university, particularly given that most physics professors would accept Maple printouts for homework.  Since then, I’ve rarely missed it, though I still remember it fondly.

PHP

An online game in which I participated mentioned having a problem with part of the site, so I offered to help.  When they sent the source, I recognized something that looked like Perl, so I dashed off some quick code without bothering to install an environment.  It didn’t work.  Since then, I’ve learned quite a bit of the language, though I still have to check the website frequently for parameter order and a few other things.  It’s a perfect language for a small dynamic web page; unfortunately, it ends up getting used a bit beyond that sweet spot.  The site I maintain for work, for example, keeps bumping its boundaries; I’ve lost track of the number of lame hacks we wish weren’t necessary.

SQL

PHP works almost hand-in-hand with MySQL, so that’s the database flavor I find myself using most often.  At one point, my employer paid for me to attend a MySQL conference, which has paid off tremendously for both of us.  The key takeaway: Think in terms of sets, joining them both to limit and to collect related data.

Matlab

Where Maple excels at symbolic processing, Matlab works wonders with numeric data.  These courses involved something resembling real experiments, though they were still as much about the program as about the physics.  If I were actually into numeric experimentation, I might still be using it.

Haskell

I made an honest attempt to use Haskell for a major hobby project, and utterly failed.  I also attempted to enter a weekend competition almost designed for functional languages, and failed.  Yes, there’s something elegant about functional programming, but it’s certainly not the usability aspect.  Perhaps the worst part was having been denied the ability to print debugging statements, before having learned about unit testing.

Bash

I had used Bash from the command line on several computers, but not until installing LFS did I truly use it as a programming language.  I’m now much quicker to cut a quick script out of any repetitive set of commands, and even use for loops on the command line.  The height of my ability must have been I took up David A. Wheeler’s challenge to create a reasonable GLOBIGNORE pattern that ignores files with leading dashes, leading dots, and control characters.  A few years later, I was honestly surprised to see my name when I came across the article again.

Verilog

At one point, I thought I would follow my father’s footsteps into the hardware realm.  I’ve designed one computer chip and manufactured another, but Verilog simulations are the closest I’ve come to see a design come to life.  Software results are just so much more immediately accessible that I haven’t yet looked back.  Perhaps someday I will; perhaps memristors will make hardware more interesting than software.

Python

I have sung Python’s praises before, and complained about its flaws, both because it remains my favorite language of all.  It supports object-oriented programming or functional programming without being anal about it, it actively encourages clean and readable code, and it has libraries for just about everything under the sun.  I reach for it automatically for almost anything more complicated than a Bash script, unless the language is mandated by use case or company policy.

JavaScript

After several years of despising JavaScript on principles of security and accessibility, and perhaps a bit on having used eLinks as a primary browser, I finally started using it myself.  It has many of Python’s strengths, combined with a few of its own, but also has some annoying quirks.  What has truly made the difference for me is the availability of libraries like Prototype and jQuery, though I can still do a few interesting things without them.

ActionScript

Our company needs to use Flash for a feature that still doesn’t exist in HTML 5, and at one point decided to make an entire application in Flex.  I was mostly tasked with the back end, but still had to reach into the front just to get the two talking to each other.  Since completion, maintenance has fallen to me while the rest of the team moved on to the next product.  There have been several surprises along the way, and I’m coming to despise both the time of compilation and the type declarations, but it’s not a bad a language overall.

Java

Certain programming courses were taught using Java, perhaps due to its rising status in industry significance at the time.  It was generally simpler and safer than C++, though even more annoyingly verbose at times.  It also felt slow, and its graphical widgets, though easy to use, were universally ugly.  I understand that its warts have been alleviated over the years, but that doesn’t make me want to go back any time soon.

HTML

So it isn’t technically a programming language, but HTML is an important markup language that had been very useful over time, both for website production and for data collection.  Unfortunately, I’ve tried to force several things into it that really should have been left to programs designed for producing printable documents.  I’ve also written screen scrapers using regular expressions in Perl.  I’d like to think that I’ve learned better, but I’m probably still abusing it somehow.  I’ve certainly been abusing the related XML, partly due to learning about JSON just a tad too late.

Visual Basic

Through some odd sequence of events that I no longer care to remember, I ended up using Visual Basic as a glue language from within Excel, launching a program to run a series of tests on a product that doesn’t seem to have entered the mainstream market, collecting the results, and producing pretty graphs.  It also came in handy a couple of other times while I still used Windows on a regular basis, though the Excel connection is still my primary use case for it.

Vim Script

It’s amazing these days to think that I programmed before learning Vim.  It’s equally amazing to think that people do so without extensive customization.  My .vim directory sports over ninety files, many of them specific to one of a few dozen languages and text formats.  True, most of them contain nothing more than settings, variable definitions, and key mappings, and half of the rest is taken from Vim tips and scripts or adapted from the runtime, but there are at least a few examples of real programming in there.

CCScript

While one online game was down for an extended period of time, I was introduced to VGA Planets.  Naturally, I discovered the most complicated way to play it, wasting hours on scripts to save me a few minutes of tedium per turn.  That was made possible by PCC, the most powerful client program available, which seemed to give me an edge in the game that never finished.  Sadly, I haven’t played since.  This language is interesting in the way it guesses what a bare equal sign means, with := and == operators to force the issue when necessary.

INTERCAL

The specification for the Compiler Language With No Pronounceable Acronym should be required reading for any budding Linux hacker.  If nothing else, it displays an interesting perspective on the issues of its day.  The difference between EBCDIC and ASCII, for example, or the limitations of punch cards and teletypes, or the finicky nature of all compilers.  Granted, I haven’t even attempted to write anything significant in it; simply wrapping my head around the operators has been tricky enough.

Befunge

If INTERCAL was designed to be unique, that must have been taken as a challenge.  A Befunge program looks more like a cross between a roguelike and a word search than something that should be executed.  This is where Vim’s mode division truly shines, with liberal use of the hjkl keys and r operator.

BF

I must have been hooked on esoteric languages by this point, because there is only one other reason to learn brainfuck: To prove that some other language or program is Turing-complete.  Then again, with only eight instructions, it’s almost impossible to forget.

Wierd

Meant to be the ultimate answer to minimalism of instruction set size, it cheats a bit by using relative location.  Of all the (relatively) useless esoterics, this one has been the most fun to write for.  At one point, I even started a graphical editor for it, but never convinced it to stretch the wires properly.  I’ve also written an interpreter for a modest extension of the language, which I might even release sometime.

REBOL

I honestly tried to use REBOL as a serious language.  I even fiddled with a Vim syntax file for it.  There’s something alluring about the promise of natural language as input, and easy graphics with fun colored widgets.  I never really found a reason to stick with it, though, and have forgotten everything I once knew.

To be continued…

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

BASIC

In third grade, we were introduced to programming by copying arithmetical expressions and other minor statements into old green and black computers.  I’m not sure how much sank in, but I’ve actually learned a bit of the language since then.  It’s completely obsolete now.

Pascal

The family computer lived in my room for some time while growing up.  Included in its paraphernalia was a set of Pascal manuals.  Dad tried to teach me once, but I was still too young to completely understand.  Still, I somehow learned the basic syntax, and even remember the distinction between procedures and functions.  Mostly, though, it has come up in the context of converting strings between C format (nul-terminated) and Pascal format (length-prefixed) when using Macintosh system calls.

HyperTalk

Junior High had a “programming” class that turned out to be entirely on HyperCard.  The first few lessons were more about the interface than about the script.  I’m not sure how much everyone else learned, but I breezed through every lesson and tried to explore the limits of what could be done.  The teacher wasn’t nearly as impressed as I thought he would be with my final project, but at least two others would later enjoy what I could accomplish with the program.

Redcode

How I came to have a copy of Core War for the old Macintosh is beyond me, but I managed to spend quite a bit of time on it.  My only remotely good warrior abused an instruction that doesn’t even exist in current versions, as well as the relative spacing between the two competitors.  I didn’t think of it as an introduction to assembly language, but it probably helped me later on.

RPL

Where most students in my high school had TI calculators, I had the HP 48G.  I was also frequently bored in math class.  That led to lots of time playing around to see what I could do, which included a password protection scheme, a couple of games, and early work on listing Pythagorean triples.

C

High school let me study a real language in a sort of supervised independent study program, with two other students.  I don’t recall how exactly we settled on C, but it became useful for both console and graphical programs.  I highly recommend learning it simply to understand a computer’s memory model.  Sadly, the only remaining copies of my work from this era are on a password-protected zip disk that I can no longer access.  Since then, I’ve continued using it for minor programs and open-source patches, some of which are still relevant.

C++

To be honest, I first learned C++ as a sort of C with objects.  The more it breaks from this model, the less I like it, even if certain features can make some things easier.  I hear that Qt makes it nice to work with, though.

Excel 4 macros

At one point, I abused Excel as a database of sorts, programming it to do a few useful things for me.  The language was interesting because it was typed in a spreadsheet column, using the cells to the left and right as storage and parameters.  I was a bit sad to see that future Excel versions no longer support the language, even if the new one is more powerful.

Perl

My first job was an internship with a major computer company, who somehow had failed to procure a workstation by my start date.  So my first week was spent with the camel book.  Basically all I did was a simpler command-line interface to a complex command-line simulation program, setting parameters for each night and parsing the results.  I still occasionally use Perl for tasks slightly too complex for grep, sed, and cut, but it’s been several years since I was fluent.

QuickBasic

Organizing a silent auction left my family with first pick of the unsold items, including an old laptop.  It came with Windows 3.1 and a copy of QuickBasic, complete with example programs.  For some reason, it was on that machine that I first experimented with cryptography.  After it died, I’ve only seen the language used in one other context, to enhance the output of another program.  The next version of that program included similar functionality, so even that use is probably dead now.

To be continued…