The onboard web-based configuration software is pretty lackluster, but it does seem to do the job if you know what you’re doing and/or are curious enough (like, if you want to set up the CIFS parameters for scanning, don’t look under ‘Network Configuration’, and don’t try to find a ‘Scanner Settings’ like the ‘Fax Settings’ and ‘Printer Settings’… You have to find ‘Administrator Settings’ and the subpage ‘FTP/Network Scan Settings’ then ‘FTP/Network Scan Profile’.).

Since it’s all network-based and the onboard computer seems to be pretty smart, I can share it with all my computers easily and with Mac or Windows when I happen to be in those sort of modes.

The hardware is also good; the automatic document feeder is a big reason I got this model, and it seems to be robust and fast. Prints look very nice. I like the fact that it’s a toner system rather than an ink system, because I use my printer so seldom that inks would dry out on me between uses (though I haven’t used an inkjet in about 5 years, maybe they’re better now).

I’m not much for writing comprehensive reviews, but I just wanted to make a note for those who use Linux and were looking at this model. I’ll answer questions should any such person come around…

I love the insider’s view of things. Even if I don’t want to be an insider in a particular field, I really like to immerse myself in their views and language, when I have the time to, rather than sticking to the strictly outsider accounts (popularizations). So a library (especially a university library) is a perfect place for me: it’s mostly full of insider accounts of fields and topics within those fields. If I had to go out and spend $50-$100 per technical book, I wouldn’t be able to frequently dip my nose in a field for a few dozen or few hundred pages and then put it aside again.

I ran across an unexpectedly interesting book in the ISU library today. I did a search for “domain specific language” in the catalog. Since their computing collection is a little slow to catch up to the outside world, they didn’t have any of the several books on domain-specific computer languages published in the last few years. But they did have one on “Domain-specific English”, which turns out to be pretty cool for reasons that I won’t really go into too deeply here. Go find it at your library if you want to know more about that…

There’s a bit in here that was particularly relevant to me:

I remember one winter afternoon, mothers chirping in a corner of the playground as they waited for the bell to announce the schoolday’s end. Their talk focussed on homework – a subject of daily comments – but the conversation sounded more lively than usual. The topic of discussion, and of much stigmatizing, was the reading assignment for that day. Since my own child was in the class, I was aware that the purpose of the assignment had been to encourage children to read for global comprehension and to guess what unfamiliar words could mean. To my surprise, most mothers had missed this point entirely and were indignant. In their opinion, the assignment featured too many difficult words. Some complained about having to consult the dictionary to help clarify the precise meaning of the new words: wasn’t it too early to face such vocabulary? How surprising from an experienced teacher like our maestra!

(And yeah, I know it’s pretty meta to be quoting that in this context.)

I was lucky enough to have parents that would have been among the dissenters in that conversation. They never acted like or told me that some particular text might be ‘too hard’ for me, and they never would have recoiled in shock that some assignment had caused me to use a dictionary. I don’t know that they ever positively subscribed to a pedagogic theory that included the idea of reading for global comprehension and guessing, but the fact that they didn’t discourage it allowed me to develop my own unconscious theory of learning along those lines. If I had to guess, I’d say that children tend to want to explore the world according to those principles, and only discouraging them would stop that short.

Anyway, what was I saying? Oh, yeah: I had fun at the library today. That’s all.

I guess that’s a variation on something I’ve been thinking about, that I should get paid for the value I bring, rather than for the value that my advertisers bring. Or my ability to get people to look at little come-ons that give them the perception that there is some value elsewhere, to be more precise.

‘course, setting aside the absurd logic and perverse incentives, I’m glad that somehow ads occasionally work out such that people make good content and also make money from it.

There is one inherent fact about insurance that seeds the complexity: you’re trying to predict complicated and rare events. The more predictable an event is, actually, the less likely it’s going to be insurable, or insurable at a rate you’re willing to pay. I mean, if you can predict an event with some certainty, you should be using a bank account instead of an insurance policy.

There’s also the psychological twist that these are events that you just plain don’t want to happen. That probably tends to make you undervalue the little information you do have that helps you make your predictions, and causes you to want to just hurry up and get done making the decisions.

On top of all that is, I’m pretty sure, a general tendency for insurance companies to purposely make it harder to buy their products. A great tension exists between the generally communal idea of insurance (we all pool our money together to help whoever needs it) and the capitalist imperative to profit. Basically, insurance companies can only profit to the degree that they hide their actuarial knowledge from their customers.

I was looking at health insurance tonight and was presented with a painful interface to choose a policy. I specified a few parameters in very general terms, and they presented me with dozens of possible policies to choose from, with a ‘comparison’ feature that did little to enlighten me about the differences. It kind of reminds me of that game Black Box where you’re trying to discern what’s in the box by shooting a tiny number of rays into the darkness, though this particular game of black box is probably 80-dimensional instead of 2D. My choices would still not be easy even if I had a full view of the model(s) they use to design these policies, but…

• someone mismerged my code because they merged based on files rather than revisions
• had to decide whether to merge someone else’s code because mine was dependent on it, but they hadn’t merged theirs
• had to decide when to merge my code, which was part of a larger feature and was not a complete feature in itself: do it now and possibly introduce instability, do it later and possibly have it get delayed in the shuffle
• stuff I’d merged disappeared because the branch was remade after I merged
• conflict while merging my code because the branch was based on a way older revision than I was informed (so other changes I’d made previously were not there to merge against)
• not knowing whether my changes were to be merged because it wasn’t decided when the feature was to be released
• a special case of the previous situation, when it was first decided the feature was for later, then it was moved earlier
• work for a future feature ended up causing a conflict when trying to merge a current feature because the two changes were made in the other order on the same code

Actually, I don’t really wonder. I don’t care, because I’m not having to deal with such right now. Java/Python/Flex interop, yeah. Passin’ them AMF packets around like a wild man…

I manage my mail in Thunderbird by the simple rule of: if it’s something I need to respond to or reread soon, it stays in the inbox. If it’s junk, junk it, if it’s totally ephemeral, trash it, otherwise it goes to the ‘old’ folder. There are already keyboard shortcuts for junk and trash, but I was still dragging and dropping to put stuff in the old folder. Until I installed keyconfig (and yeah, that link is as close as there is to a project page for the thing, unless you count the author’s homepage). I then installed a script on O that says
MsgMoveMessage(“mailbox://nobody@Local%20Folders/old”)

No more drag-n-drop to manage my email. Nice.

In this case, in the full context we just call it the ’slicer’, but that one word hides a lot of complexity. What the slicer does is: given a document in XML format A and a set of start points and offsets of selected regions of formatted text (both specified by character counts as the user sees the document), extract the given regions from the document in XML format C, rebuilding any necessary start/end tags and preserving internal formatting. Another process does the translation from format A to B to C. (These translation layers can add extra characters that are not part of the document as the user sees it.)

I’d like to be able to claim that that gives you a more robust solution, but of course, if you require two clouds to be operational in order for your app to work, you’re less robust. Both EC2 and GAE have been OK, but not great, in terms of uptime. I expect both to get better over time, though.

Have fun, but there are no guarantees that this won’t run tasks you didn’t really want to run or somesuch.

Dumb script

Each bar plot below represents the number of occurrences of a digit in the decimal expansion of pi. The y-axis is an index, and the frequency x is counted over the range of digits y*20 to y*20+400. I thought 400 would be a long enough length to make these graphs pretty flat. Higher lengths make it flatter, of course, but still not to the degree that seems ‘right’ to me.

I guess I could calibrate my perception by using a uniformly distributed sequence of digits…

Pi digit frequencies

Update: huh. I guess it is just me. Here’s the same sort of graph but with uniformly random digits (at least, assuming that RAND’s book, which I lazily selected as my source, is indeed uniform). Looks equally bumpy to me. Ah well, I’ll leave the post up as a reminder of my folly…

Random digit frequencies

def decompress(fc):
    fc2 = fc.splitlines(True)
    fc3 = "".join(fc2[1:]) # could verify that it's asc-gzip here if we wanted to...
    unb64 = base64.standard_b64decode(fc3)

    ctr = 0
    ret = []
    while 1:
        if ctr == len(unb64): break

        ccltop = ord(unb64[ctr])
        ctr += 1
        cclbottom = ord(unb64[ctr])
        ctr += 1
        compressedchunklen = ccltop * 256 + cclbottom

        cltop = ord(unb64[ctr])
        ctr += 1
        clbottom = ord(unb64[ctr])
        ctr += 1
        chunklen = cltop * 256 + clbottom
        #~ print compressedchunklen, chunklen

        compressedchunk = unb64[ctr:ctr+compressedchunklen]
        ctr += compressedchunklen

        chunk = zlib.decompress(compressedchunk)
        assert(len(chunk) ==  chunklen)
        ret.append(chunk)

    return "".join(ret)

It occurred to me today that document conversion is an interesting niche wherein a ‘pure functional’ paradigm is useful. I still can’t see myself using a pure functional approach in many other areas, but I do have to deal with document conversion often enough that I’m glad XSLT exists.

I find the tree-transformation model of computation is an interesting mind-bender, though when I think about it, it’s really only mind-bending in combination with the functional approach. And thinking further, I’d suppose that a functional program of any size would tend toward the nature of a tree transformation… Hmmm, something to ponder some more.

Running a Bacula restore job as I type this…

That, of course, is the flip side of the ‘easier to clean’ thing, because they’ll give up their dirt to the sweeper, vacuum and dry mop more easily, too. I guess you could say it’s a more open relationship between me and housedirt. Weirder analogies are sitting in my brain, but aren’t going to get out.

This thread gave me pointers to figure this out; Bryan was just a little off because he was using a gzip library rather than a zlib one.

# compress according to wacky XFDL compression scheme
def compress(fc):
    CHUNK_SIZE = 60000
    out = ''
    for i in range(0, len(fc), CHUNK_SIZE):
        chunk = fc[i:i + CHUNK_SIZE]
        chunklen = len(chunk)
        compressedchunk = zlib.compress(chunk)
        compressedchunklen = len(compressedchunk)
        out += chr(compressedchunklen / 256)
        out += chr(compressedchunklen % 256)
        out += chr(chunklen / 256)
        out += chr(chunklen % 256)
        out += compressedchunk

    f = StringIO.StringIO()
    f.write('application/x-xfdl;content-encoding="asc-gzip"\n')
    b64 = base64.standard_b64encode(out)

    for i in range(0, len(b64), 76):
        f.write(b64[i:i+76])
        f.write('\r\n')
    ret = f.getvalue()
    f.close()
    return ret

In computer science, the terms ‘tree’, ‘parent’ and ‘child’ were taken to talk about a certain way of structuring data, presumably because when you draw diagrams of this structure, it looks similar to a diagram of a family tree you might draw in genealogy. But often, when implementing this, it’s sensible for the node to have a ‘parent’ property rather than just the parent having a ‘children’ property. In those cases, it’s more natural, then, to English a line of code like “A.parent = B;” as “node A is parented to node B”, rather than “node A is made a child of node B”. They mean the same thing in the computer science nomenclature, but you’d probably never hear someone saying “Joe is parented to Jane” in genealogical terms.