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.

I don’t usually tell people this, but I have a degree in sociology.

I am a sociologist.

My main reason for not telling people is this.  When people learn I’m a “computer guy” they always ask me for computer help.  I would hate for someone to hear I’m a “sociology guy” and ask me to fix their society.

That being said, the high holy graph of sociology is a bell shaped curve, which sociologists call the “Standard Normal Distribution.”  It’s not only a graph, but also a presumption about the distribution of characteristics in a population.  Additionally, it’s a way of talking in extreme shorthand about potentially large data sets.

This particular bell curve has two salient characteristsics: mean and standard deviation.  If I say “The mean is ninety-one and the standard deviation is six,” that means the middle of my bell curve is at ninety-one, sixty-eight percent of the area under the curve is between eighty-five and ninety-seven, ninety-five percent of the area under the curve is between seventy-nine and one-oh-three, etc.

And I can say all that in one short sentence: ”The mean is ninety-one and the standard deviation is six.”

It’s cool, but it’s also totally fake.  Of course, any data that can be averaged can be shoved under a bell curve.  But in most cases, the only reason to do so is so that you can use the shorthand I described up above- it doesn’t mean the curve is a very good fit for the data.

For instance, the distribution of IQ in the human population is often shoved under a bell curve, thus proving that most of us are very, very average, and very few of us are genuinely stupid or crazy-smart.

Which is total bullshit.

In fact, what I would like to offer is a bell curve of my own, which is a bell curve of how awesome it is to use a bell curve to describe any given data set:

Which is to say that the vast majority of the time, it tells you nothing.  But sometimes, it’s awesome.  Other times, it kind of sucks.

That is all.

Winter Squash came early. Plant it later: some time in mid-June, maybe. As nice as it was to have winter squash in late July, it would be nicer to have it in late October.

Tomato staking didn’t work for me, mostly because in our climate, we can leave four or five branches on the indeterminates, and that’s too many to tie to a single stake. On the other hand, I wasn’t really satisfied with how they trellised last year using leftover fence- we had a higher yield, but it took a lot of time. Next year, maybe we’ll try try an overhead support with twine coming down, and some tomato clips.

Hot spring meant early-bolting greens and unhappy sugar peas. I’m not sure what to do differently. Maybe hope for fewer ninety-degree days in May ;) This year we could have planted sugar peas in late February, I bet, but that definitely wouldn’t have worked last year, when we got a frost on May 11. I don’t think it frosted once in April this year.

We let our kale bolt in the spring, which was an interesting experiment. The birds loved it. They parked in the kale branches for a solid month, and wound up distributing kale around the garden and beyond. Every single seed must have sprouted, which included a carpet of kale in that planting box, which pretty much rendered it unusable for anything else, other than hot-summer-baby-kale, which is not much of a treat. Not sure if it was a feature or a bug overall.

Planted the peanuts too close together, should have done it in the patch, not in a box. They sure are pretty, though.

Loved the beets, will probably plant more and more varieties next year.

Peppers did great, but they need to be supported.

Don’t love spaghetti squash. Love acorn and butternut. Hubbard is doing great, lots of them, don’t know if we like to eat it yet. All the squash needed way more space than we gave it. We had squash borers, but half the squash seemed to ignore them and keep growing, while the other half abruptly died.

All the squash and melons need way more space than we gave them. And on that topic, melons are awesome around here. Watermelons, cantaloupe, and we should try some more. No pests bothered them, and they were prolific, and they tasted great. More, please!

Cucumbers only last six or seven weeks, but it’s enough to get three or four cucumbers from each plant. They appear to always get the wilt that seems to be pretty ubiquitous around here.

Deer ate every one of my beans and tried their best to kill the sweet potatoes, but seem to have failed (they’ve been eaten back to the stems twice, but just keep putting out new leaves and growing bigger. Maybe that’s okay?

Loved having flowers interplanted. Loved having annual herbs interplanted.

Volunteer squash suck- none of them were edible, though some of them were pretty, but they totally took over wherever they came up. On the other hand, I pretty much loved all our volunteer tomatoes.

Planting onions from seed didn’t work in the spring, because the plants got overgrown with weeds that we couldn’t pull because it always pulled up the onions that were next to it. We’re going to try that again in the fall.

Herbs all did great, especially the lavender that Susan planted, and I learned a lot about babying those particular beauties along. Sage, rosemary, basil, thyme, chives, all seem not to need too much babying.

I think the rhubarb would be happier with a little less sun. Maybe we should move some into the orchard under apple trees? Near the house?

Asparagus is going gangbusters, we should eat some next year.

Sunflowers are totally fun, wish we’d planted them earlier. Same goes for corn.

We need to take better care of our strawberries, and I think we need to switch to a June-bearer around here. Summer is just too hot for those puppies. Maybe they’d do okay next to the house as well?

In general, I suppose we need to focus on getting the high-maintenance stuff going in boxes, the low-maintenance stuff in the patches, the sun-shy stuff out of the sun, and a better supporting method for everything that needs to be supported. Maybe we should try a couple methods next year.

I suppose we’ll increase the size of the garden patch, leave the boxes about where they are, get a water feature running for the critters, let fewer vines grow between boxes, make it easy on ourselves to mow the spaces between boxes, which will in turn leave fewer weeds in the boxes.

These are just the things I remember right off the top of my head- our spring harvest was lovely, and I wish I remembered a few more details from it or had written down some thoughts then.

@eikeon and I keep talking about term oriented programming and circling ever closer to something that doesn’t completely fall apart the first time someone touches it… we’ve landed on a few conventions that I’m document here primarily for the purpose of remembering them, and in order to let him comment on whether I remember them correctly.

A grammar is a list of simple named graphs called parts of speech. Each part of speech consists of a label and a list of neighboring parts of speech. One refers to a part of speech by its label. A label may be used more than once, leading to a somewhat confusing ambiguity when you’re not careful.

A lexicon is a list of terms. Each term consists of a label, a part of speech (e.g. a named graph) and a definition. The definition of a term is an ordered list of one or more terms, which we’ll call a sentence. For the sake of bootstrapping, a term whose definition is identical to its label can be considered a terminal graph node: no sub-parsing is required.

A sentence is an ordered list of terms to be parsed. It is considered parsed when each term in the sentence is assigned a part of speech and formed into a graph where each term is a node and there are no dangling vertices. That last assumption of no dangling vertices is one that may be relaxed in the future, but for now it means that if a verb in our grammar is defined as being connected to two nouns, and a noun in our grammar is defined as being connected to one verb, that two nouns and a verb can make a completely parsed sentence.

Parsing begins with the first term in a sentence. The term is looked up in the lexicon, which provides its part of speech. The part of speech is looked up in the grammar which provides its neighbors. This is stored in memory as an incompletely parsed sentence. On the next term, the process is repeated, and the two incompletely parsed sentences are attempted to be joined following the rules set out by the part of speech (e.g. the neighborhoods have to be correct). This is done until the end of the sentence is reached, at which point if there is a complete graph found, it gets parsed, and otherwise it fails to parse.

Obviously, the naive approach will only work with carefully constrained lexicon, grammar, and sentences. It is that which I suppose we’ll begin with.

Oh, and left-to-right parsing is arbitrary.