Here’s a quick update about what’s been going on in my life and in my head.
I’ve started a few brainstorming blog posts, but failed to get anywhere so I didn’t post them.
The first is the fall of taxonomy, explaining the copious problems with organizing a large volume of modules by hierarchical, taxonomic namespace, and a solution I have in mind involving a type of version control that doesn’t yet exist (a DVCS which blurs the distinction between separate projects).
The second is semantics of computational complexity, wherein I rant about the necessity of thinking operationally (after defining what it means to think operationally) to reason about computational complexity. I hoped to make some headway toward a more local solution, a “computational complexity type system”, but didn’t really get anywhere meaningful.
The FRP as attribute grammar algorithm flopped, and my confidence has been lowered that my goal is actually achievable at all. To be clear, my goal is an efficient, lazy implementation of the Fran semantics. The kicker was the following snippet:
kicker startEvent input someKey = pure 0 `until` do k <- someKey return $ if k == 'a' then a else b where a = pure 0 `until` (integral input `snapshot_` startEvent) b = pure 0 `until` (integral ((2*) <$> input) `snapshot_` startEvent)
The main idea for the algorithm was that it took a list of times to compute the main result and propagated that list into lists of times to compute for its constituents. But in this example, we do not have the luxury of knowing what constituent we are talking about until after someKey, but the integral depends on values of input from before startKey, and not in any way that is transparent to the implementation. I’ve been roughly developing a principle of FRP which is something like “information locality” which is necessary for efficient implementations, and this example looks like it violates it. My next goal is to formalize this principle and show how the Fran semantics do not conform, thus giving some mathematical indication why implementations are so elusive. I hope this will guide me to the most flexible semantics which do obey the principle.
Meanwhile, I’m idly hacking on a text adventure CU GameDev is making in python. It has been such a long time since I did imperative programming, it’s hard to get back into. So hard, in fact, that I did not. My contribution was a purely functional parser combinator library in the style of ReadP, for dynamically building sentence parsers based on context. Python’s essential support for functional idioms is not bad, actually, it’s just the syntax which makes it kind of a pain.
I haven’t been doing much music lately. Of course I am still improvising daily, but I don’t have a band going at the moment (mostly because I have been unsure whether I’m leaving the country). On Friday there is a big jam session with about 9 musicians scheduled. That will be a challenge, but if done well by all parties involved, it could be really cool. Unfortunately my recording gear does not work with Vista, so there will be no high-quality recording (Nolan will use his portable room mic instead).
And I might have a date with Karen on Saturday. By which I mean we’re going out to dinner together. I have no idea whether she considers it a date. I’m attempting to let it go and not worry about what it’s called or what it implies in the future. I can’t help being unreasonably excited, however. And you know what Obama says: “the bubble sort would be the wrong way to go”.