Finished my first batch of knotweed dye, dyed a cotton shirt.  Doesn’t look great, thought not bat for a first attempt I guess:

Made my first commit to @eikeon’s hu repository, also not great, but also not bad for a first attempt, I guess.

Thought more about how to keep better track of things we’re making, came up with the idea of keeping a “log” on the “web” and maybe calling it a “web log” or just a “blog” for short.  I think this last idea may be the one that makes me millions.

Children seem to have this innate sense of the sweet spot between practicality and abstraction which is well suited to mathematical thinking.

Given the Roman number II, the integer 2, the real number 2.0, the word pair, children seem to understand the relationship between them.  Children seem to know how two chairs and two people are the same.  In the bath last night, my two-year-old asked for one of her “guys” and when I gave it to her she pointed at the other one and said “two guys.”  Then she pointed at herself and said, “I’m two!”

What is the sameness between those two guys and the two years she’s lived and the two fingers she holds up proudly each time she uses that word?  Where does that sameness break down?

If I give her three sticks and she counts them, she counts to three.  If I break one of the sticks in half, she understands I haven’t added or subtracted any substance from her stick pile, but she also understands that predicates are needed when we talk about the four sticks we now have: two whole sticks and two half sticks.  If I ask “how many sticks are there?” she could answer a bunch of different ways: 4, 3, 2, or some other answer I haven’t thought of.  In order to settle on the same answer, we have to have a conversation about what we mean by “stick” – just a whole stick?  any part of a stick?  the number of sticks before one was divided?

Mathematical logic in children seems to be something that develops early and is surprisingly capable without too much intervention.  Wonder what it is that we do to change that?

Indefinite pronouns got me thinking about concurrency patterns a bit more:

• any
• all
• some
• none
• one
• few
• fewer
• many
• more
• neither
• most
• such

That’s not all of them, but it’s a good start.  Indefinite pronouns, roughly speaking, are what allows us in English to signify operations on a list somewhat less… definitely… than otherwise.

These are the parallel equivalents of the Boolean operators we all know and love.  And, or, not, so, xor, nand, nor, etc.  Of course many of the Boolean operators operate most naturally on a list of two items, and the indefinite operators work well on lists of indeterminate length (in some cases, literally indeterminate, in that they could work on a list that hasn’t been counted at all).

Now, the difficulty here is that with software, indefinite logic requires us to do a bit more bookkeeping than straight Boolean logic.  For instance, when I do something like “a and b” with Boolean logic, I just evaluate a.  If a returns true, I evaluate b.  If b returns true, the whole statement is true.  Everything can be done sequentially, and programmers know to rely on the short-circuiting nature of the operation.

On the other hand, if I say “all a, b” I kick off concurrent evaluations of both at the same time (even if under the covers the machinery that takes care of this runs sequentially, or optimizes to run the faster one first or the more likely to fail one earlier).  If b immediately returns false, I need some way to tell a to stop evaluating, which might save considerable time and effort.

The Go programming language has some nice primitives built in for both operations (e.g. kicking off parallel computations, and for communicating between the various sub-processes).  The “go” term indicates parallel execution, and the <- operator on a channel indicates communications back.

Of course with a thousand nested parallel calls, interspersed with plain old Boolean logic, there may be quite a bit of this going on, but it also may happen that most the calls get shut down before doing much.

The code might look something like this:

and(a, b, c, all(c, d, any(e, f, g)), some(h, i))

Here, the term and indicates sequential execution, the term all can be thought of as a parallel short-circuiting and, the any can be thought of as a parallel short-circuiting or, and the term some can be thought of as another variety of parallel or, which maybe doesn’t short-circuit as quickly.

I think programmers would grok this if it were presented in a reasonable fashion.

[one wee little edit: if you're reading this on the front page, read the version with comments, which are worth a couple posts by themselves]

When I started college, there were a series of peer counselling sessions, structured to gently introduce the (possibly sheltered) 17- and 18-year-olds to some of the more jarring differences between a (possibly sheltered) high school classroom, and life at college.  The session I remember most vividly was run by what is now called the Queer Students and Allies (QSA).

It was next door too our suite, in the RA’s living room, and twelve or fifteen of us sat around in a circle on the floor with a couple older students leading a discussion group on a pretty wide range of topics.  Each of the topics seemed tailored to gently prod some of the more heteronormative ideals of the first-years.  Perhaps the most thought-provoking point in the discussion was when the peer counselors asked us to go around in a circle and say, “Hi I’m so-and-so, and I’m gay.”

I think the idea was to provide a safe environment where two things could happen: people who wanted to say it in the worst way could say so in a context that felt pretty safe (after all, everyone’s doing it…); and people who didn’t want to say it could see what it felt like anyway.  We duly went around the room, until one kid just wouldn’t say it.  Instead he said, “Hi, I’m David, and I’m not going to say that.”

He was the only one.

He was me.

I’ve thought about that day a lot of times since then.  That summer I went home and smugly told the story to a friend at church, reveling in my steadfastness and righteousness.  Like a Pharisee.

Hi, I’m David, and I’m gay.

I’m sorry I didn’t say it that day.  I’m sorry I subsequently bragged about it.  And I’m especially sorry to have made it harder to say for the people who really needed to.  I’m older now, and I suppose the stakes are lower: I’m not worried that some of the people reading this will only read that one sentence:

Hi, I’m David, and I’m gay.

After going around in a circle, the peer counselors asked, “What did that feel like?”  Almost twenty years later, I’m proud to say, I felt like an ass.  I felt like an ass when I didn’t say it, and I felt like an ass when I bragged about it, and I feel like an ass admitting that I thought it made me a good Christian.  So, in addition to saying

Hi I’m David and I’m gay.

I have one more thing to say: if you believe in God, and you’re gay, well, God loves your gay self, too.  And we’re not talking about a love-the-sinner-hate-the-sin kind of love, we’re talking about loving part and parcel.  And you know what, everyone (gay or straight or neither or both) who believes in God finds that last part hard to take sometimes, so just get over yourself.

Yeah, I said it, God loves you.  And I’m sorry it’s so controversial.

Emergence is a way to understand,
When hierarchy fails to lend a hand.
It’s not to the exclusion of the rest,
A complement’ry use of it is best.
A single data point cannot be used,
Emergence is when two or more are fused.
Imagine that a line’s emerged from points,
Imagine that an elbow comes from joints.
A forest can emerge from stands of trees,
A hive emerges from a swarm of bees.
Meter comes from syllabaries said,
With emphasis on tail or on head.
Rhyming also cannot be incurred,
Without the use of more than just one word.
Emergence is a way to help address,
That order can arise from such a mess,
That cosmos from the chaos can arise,
And this should not be such a great surprise.

I do not like the phrase, “eating your own dog food.”

This metaphor, colloquially shortened to “dogfooding” is one that some software developers use to describe becoming a user of one’s own software.

I don’t like it, because I don’t like eating dog food.  It’s not made for me, it’s made for dogs.  If I eat it, I’ll inevitably do one of two things: I’ll make it taste good for me instead of for the dog, or I’ll barf.

I don’t like it implies we should endure something odious by using something we made.

If I’m going to make software for which I am one of the users, it should surprise and delight both me, and everyone else who uses it.  If I’m going to make software that isn’t for me, I should focus on making sure it will surprise and delight someone else.  If I can find someone whom I genuinely like and trust, and make it surprise and delight that person, it can be a wonderful start to things.

The metaphor I like for this is family meal.  At a restaurant when a chef cooks up a meal for the line cooks and the wait staff and the dishwashers, it’s called a family meal.  It might not be exactly what’s on the menu that night, but it’s something close, and it’s damned fine food.

When programmers do work for other programmers, it should be like a family meal.  Not like eating dog food.

Rushing around in a flurry,
Easy enough to forget,
In the bustle and the hurry,
There is a calm, yet,
Before the storm’s begun,
But with just enough,
Time to get everything done,
Scurrying around, doing stuff,
It’s after the storm, loud,
That I first notice the calm,
Sky devoid of cloud,
For the spirit, a balm.
I think, stretch, yawn.
Fuck you Irene.  I’m glad you’re gone.

Much of my intuition is wrong, or at least wrong at first.  Over time, I try to discard un-interesting or unhelpful intuition, and improve the fun stuff.

One area where my intuition consistently breaks down is the transition from a single item to a large set.  Evolution itself is a great example of this- it doesn’t make any sense to think about evolution in the context of a single organism.  Evolution is an emergent property of a massively-parallel system of organisms.  Simply put, individuals do not evolve, but massively parallel systems of individuals do.

That’s weird, right?

The same is true of bell curves.  It doesn’t make sense to think about an individual having a mean or a standard deviation.  Those are properties of a population, and only useful in thinking about a population (truth be told, they’re not even useful then).

I think maybe there’s a similar problem at play with code.  I think about control structures and return values, but those are traits of individual functions or closures.  Massively parallel computations have different characteristics.

For instance, it probably doesn’t make much sense to count CPU cycles in massively parallel computations.  Not that one couldn’t do that, but it just wouldn’t say much, I think.  It may not make sense to think about which way is faster at all- perhaps we should always try all the ways and just take whatever result comes back first.  There are other disconnects that I’m not getting yet, but my code is going to change when I start to.

Maybe the right way to think about parallel programming is to let a thousand flowers bloom and see what color the meadow is at the end.