Idle Speculations

The sensation of causation

2009-11-16T04:29:48Z

There's a scene in the very beginning of Brutal Legend (I understand it's also in the demo) where Jack Black puts his hands on a (hellish) religiously-powered vehicle, and gets it to move by praising generic dark/S&M/goth/leather powers. There's a gimmick associated with this scene - if you stop driving the vehicle forward, Jack Black mumbles and stammers, and can't think of what to say next.

This gimmick is basically intended to create a sensation of causation. Hume argued that there is no such thing, but I think he's wrong. Our brains parse some kind of combination of "active intention" and sufficiently-immediate, highly-correlated feedback as "I caused that". Peter Watts might imagine a creature with fast enough reflexes to hijack this sensation, reading your active intention off your nerves and moving so that you think you're causing it's motion.

At work, there were two mice, and I wasn't sure which one controlled the pointer that I wanted to control. I reached out to them and, without really thinking, "felt" which one controlled the pointer that I was looking at. That is, something about the timing of the muscle-movement and the motion felt causal.

Another gimmick is the "magician's choice" - a trope in interactive fiction and games generally - two options that seem different, but lead to the same outcome. Zarf's game "Hunter, In Darkness" is always the example that I think of. There's a fork in a cavern, and in either path you (seemingly coincidentally) encounter something that prevents you from returning back to the fork. Your path onward is the same, whichever branch you took. The artistic point of doing this is to offer a particular sensation of choosing, despite the user not actually having control.

When feedback is sufficiently delayed, humans cannot lean on that (inbuilt, heuristic) sensation of causation, and have to stumble around with our (supposedly) general-purpose reasoning abilities instead. Showers, when there is a delay between turning the knob and the temperature changing, are an example. I understand the dynamics of some aircraft (gliders) are like this, too.

If you'd like to see a concrete example, Adventurous Eric, a mouse-avoider game, has some "sensation of causation" effects. Alternately, Time 4 Cat is another mouse-avoider (with a feline protagonist) which (eventually, be patient) has something like a "sensation of causation" effect.

adjusting covariance

2009-11-15T21:45:20Z

There's an excellent recipe (Poli and McPhee 2008) for bloat control of genetic programming that requires computing the covariance between fitness and size in the population.

I'm using steady-state genetic programming, so at each step, exactly one element of the population gets dropped and replaced with something else. It's straightforward to compute the new mean of the population from the old and new values, so I thought it was likely possible to compute a new covariance from the old and new fitnesses and sizes.

With a little (okay, a lot) of help from Mathematica, I created a formula for the change in the covariance. Reading it makes me think of mathemagicians ritually chanting, dancing a complicated intertwining step, in a procedure intended to invoke great numerical stability. (Note: I have no idea whether this is numerically stable in any sense).

We're changing a point (oldX, oldY) into a point (newX, newY), inside a set of size N, and we want to compute the change in the covariance of X and Y. oldmeanX and oldmeanY are the previous means of the set of Xs and the set of Ys respectively.

delta = 0.0
delta += newX * oldY;
delta -= oldY * oldX;
delta += oldX * newY;
delta -= newY * newX;
delta /= N;
delta += newY * newX;
delta -= newX * oldmeanY;
delta += oldmeanY * oldX;
delta -= oldX * oldY;
delta += oldY * oldmeanX;
delta -= oldmeanX * newY;
delta /= N;

Carefully alternate, brothers and sisters! First the square... and now the hexagon!

Teh intarwebs make me cry, but in a good way

2009-11-12T04:07:21Z

weird

stacking technologies

2009-11-01T05:06:10Z

Here is a simple stack of technologies:

1. Genetic Programming - generate (mutate, cross-over) roughly tree-shaped things.

2. Counterexample Finding - from a (roughly tree-shaped) specification, find a (possibly graph-shaped) structure that satisfies the specification. E.g. mace4, or answer set programming.

3. Control Theory and Block Diagrams - If we wanted a (pretty smooth) controller for a (pretty smooth) plant, then it is probably going to be expressible using standard block diagram primitives like integrators, scalar gain (including negative gain), sum of signals, and delay.

Maybe using these technologies to attack the standard reinforcement learning tasks (cart-pole, mountain car, acrobot) would be an appropriate final project.

The idea is that introducing a counter-example finding step in between the genetic programming and the actual controller might make crossover and mutation more sensible things to do. If the chromosome is a list of properties that the block diagram graph ought to have, then crossing it over might make some sense. Block diagrams seem like they might well be able to handle stateful controllers (that is, non-Markov environments), without having to go to finite automata or explicit read/write actions.

abstract interpreter for human procedures?

2009-10-31T00:58:47Z

Genetic programming (or simple brute-force search) can put together interesting code.

We can model some aspects of human thought with an abstract machine. For example, the working memory (seven plus or minus two) is something like a limited set of registers. Long term memory is like a pointer machine model in that pointer arithmetic isn't possible. Writes to long-term memory take much longer than reads (factor of 10?), and erases aren't really possible. Humans make errors and get distracted and have to re-find the thread of the procedure.

What would code evolved (or brute forced) this abstract machine look like? Could we create awesome techniques for, say, systematic multi-objective search? Mental quadratic programming?

And then, if this abstract machine were built and there were a procedure that you wanted inside your head, how would you put it into your head?

sculptor/sculpture unpacking

2009-10-14T22:41:05Z

This is an odd idea.

Suppose that (perhaps for compression), instead of sending a (software) sculpture somewhere, you instead sent a sculptor. The sculptor, given a standard blank piece of clay, modifies the clay (manipulation). The clay, on the other hand, modifies the sculptor (perception). This process iterates until the sculptor is done.

atheorist @ 2009-10-11T17:55:00

2009-10-11T22:08:54Z

Okay, here is a simplistic AI design idea.

1. Start with a collection of untrusted agents.
2. Give them all some "money" (just a number) and (here's the unusual bit) some "shares" (another number).
3. Each round (consisting of observation, action, reward):
3.1. Tell them all your observations.
3.2. For each of your possible actions, ask them what they think the fair price for a share WOULD be, if that action were taken.
3.3. For each of your possible actions, compute what the market-clearing price would be.
3.4. Perform the action with the highest market-clearing price.
3.5. Clear the market, moving money and shares around at the market price, to get to equilibrium.
3.6. Allocate reward to the agents, sharing it out proportional to their number of shares.

atheorist @ 2009-10-10T10:39:00

2009-10-10T15:11:36Z

Suppose that two really big numbers were being multiplied in a big exhibition hall, something like a sporting event. Really big supercomputers, the best in the world, are multiplying them, and they will be done in twenty minutes or so.

A dumb bookie comes up to you and says to you "Would you like to bet on whether the answer will be even or odd? Double your money if you're right!". You glance up at the numbers displayed on the board and see that one of them ends with the digit 4. Can you make a profit?

More generally, suppose a bookie comes up to you with a lot of different sets of the integers - for example, the evens, the odds, the primes, the composites, the powers of two, the block of numbers with between 100 million and 1 billion digits - and a lot of different listed odds. It seems reasonable that you might be able to find some blocks which are currently mispriced and bet on them.

If you're able to bet on these things, then you must have a probability distribution over the possible answers. If you run a computation (a divisibility test, say), then you might update your probability distribution. In some sense, this is very odd, because the answer is logically certain - it already exists in the realm of Platonic forms.

However, there are a lot of ways that the prime number theorem is similar to a "probability of a number being prime", and the prime number theorem is certainly useful.

It's entirely reasonable to talk about the probability that a random propositional formula (constructed with a particular stochastic process) is a tautology - google tells me the experiment's been done.

If you had a finite model of propositional logic (a small boolean algebra, say) and you checked that the random propositional formula is true on that finite model, then you would certainly increase your subjective probability that the random propositional formula is a tautology.

Combining the distribution of tautologies (parameterized by size of the formula) with the finite model has resulted in a probabilistic approximation to the truth. I'm sure things like this are useful somehow, in theorem proving and other places.

Singularity Summit

2009-10-06T12:17:37Z

Went to Singularity Summit. Was pretty awesome. Here are my extremely brief memory-cues regarding the first day speakers, for my own use.

Itamar Arel - enthusiast of AI
Ben Goertzel - enthusiast of AI
Stuart Hameroff - kook of consciousness
Michael Nielsen - basic quantum computing
Ned Seeman - builds things out of DNA the molecule
Juergen Schmidhuber - compression is important
Stephen Wolfram - naturalism of small programs is cool
David Chalmers - arguments re:self-improvement followed by unfounded speculation
Gary Drescher - deterministic choice still makes sense
Ed Boyden - scientist of neuron dynamics
Marcus Hutter - mathematician of AI
William Dickens - The Flynn Effect is caused by environment

atheorist @ 2009-09-10T14:32:00

2009-09-10T18:34:49Z

"The Book of Causes shows, when opened at the name of a factor or intervention, (i) on the left (verso) side of the opening, all the things which are known to be able to cause it, in some circumstances; and (ii) on the right (recto) side, all the things which it can cause. Since the BofC is a virtual book, you have to create these pages, using all your resources for the required literature/Internet search."
— Michael Scriven

atheorist @ 2009-09-03T23:31:00

2009-09-04T04:05:30Z

How do I actually create designs? What is my actual workflow? Well, I think I spend a lot of time wandering around a graph of ideas. Sometimes, depending on the discipline and the context, the graph is also a graph of objects (or classes or functions or tables or processes or propositions or nodes in a syntax tree ET CETERA ET CETERA). Anyway, visiting a node may cause a nearby change to the graph (a new node or two, an edge added or removed). It seems like I have to do multiple passes to get a design that is reasonably complete and thoughtful, which contradicts the systematic top-down/refinement-calculus methodologies. Often it seems helpful, after one pass of drawing circles and arrows to throw that piece of paper away and start over with another piece of paper.

How can I take this workflow description and turn it into a tool for this kind of workflow? Suppose that we forget about the graph structure of these ideas and just consider the design to be a set of ideas with descriptions, something like a pile of index cards. The verb that the tool has at its disposal is prompting the user with a pre-existing idea, and asking them to revise it or elaborate on it (that is, introduce new related ideas). Sometimes prompting the user with an idea will be productive (that is, will cause a revision or elaboration). Prompting the user with the same idea twice in a short amount of time doesn't seem like a good idea. Ideas that have been productive in the past are somewhat likely to be productive in the future, but we should expect all ideas to decay in productivity as they are used.

Is there an elegant mathematical way to model the "human cache"? I'm pretty sure that prompting the user with a recently-prompted item may be unproductive due to hitting a previously cached (and inputted) answer. However, I'm not sure how big the cache is, nor what the rules are for items moving in and out of the cache.

making your future problems look like your past successes

2009-09-02T06:43:51Z

I've played a bit over the weekend with an old combinatorial optimization problem (job shop scheduling), and surprised myself with how much progress I made. Normally, I have enthusiasm for something, initial successes, followed by setbacks, discouragement, slow progress, boredom, and then dropping the project.

I think one major difference between this task and other tasks that I've attempted is that I used a body of existing problems, inputs. Some of my other successes that surprised me also had this feature.

Possibly I can generalize this to:

JOHNICHOLAS, GENERATE TEST DATA YOU IDIOT!
Possibly there's a further generalization, which is, when attempting to improve your problem-solving processes, consider adding a "preprocessing" step to the beginning of your process, trying to adjust the problem that you're facing so that it has structural features similar to your previous successes.

Echoblog

2009-09-02T06:10:57Z

mogwai_poet said: Where Chip Delany writes: a non-euclidean hell dimension, evidently.

atheorist @ 2009-08-30T23:47:00

2009-08-31T03:50:35Z

I have read Charlie Stross's Glasshouse and it is indeed awesome.

atheorist @ 2009-08-29T22:00:00

2009-08-30T02:07:46Z

Over the last few days, I wrote a strange little tool for manually solving job-shop-scheduling problems. "What?" you say "Isn't job-shop-scheduling a family of NP-complete problems? Why would you want to solve them manually?". You're entirely correct - there are no users for this tool.

However, the task of writing such a tool was interesting as an object-oriented software design problem - something like discrete event simulation crossed with user threads. Anyway, it was a fun exercise. My focus was on solving it at all, rather than using good TDD practices, so it's pretty bad code. Maybe sometime I'll use it as a starting point of a refactoring exercise.

atheorist @ 2009-08-25T16:04:00

2009-08-25T20:03:50Z

I watched the sun rise in the purple armchair with the poodle this morning. It was pretty awesome. Like - you look across the field, and it's misty and bright, and then you sit there doing nothing for a while which is pleasant. And then BANG the sun rises over the trees and it is all glarey and the poodle sprawled across your lap looks interested.

atheorist @ 2009-08-22T11:14:00

2009-08-22T15:32:06Z

Every once in a while, I code little practice class libraries.

This was trying to create a little interpreter, for if-then-else-plus-straight-line programs. It seems like sometimes one needs to have internet protocols which allow (untrusted) remote entities to send little proxies or agents representing policies to be executed locally. Some kinds of auctions, for example.

This time, I was pleased with how the stats came out.
~8 hours coding spread over two days.
~300 lines of code excluding mocks and tests (500 including).
(So that's ~35 or ~60 loc/hour. I'd be happy with anything between 20 and 100.)
100% statement coverage.
Maximum cyclomatic complexity per method: 2
(Which means probably 100% path coverage, though I don't have a tool to measure that.)
Maximum statements per method: 9

http://www.johnicholas.com/simple_agents.tar.bz2

human algorithms

2009-08-15T22:27:30Z

I want more "the computer helps you solve what you're thinking about" applications.

For example, I can imagine one person working through an annoying "exhaustive" or "by cases" puzzle, and someone else (who doesn't know the puzzle that well) helping them, something like this:

Puzzler: Aaaah!
Helper: Okay, calm down and back up. What is the first step?
Puzzler: Well, first X makes a move, in one of nine squares.
Helper: Okay, what is the first of the squares?
Puzzler: I guess we can do the upper left corner first.
Helper: Okay, so suppose X makes a move in the upper left corner. What next?
Puzzler: Well, O makes a move in one of eight squares. No wait, this will take too long, we have to eliminate symmetries!
Helper: Okay, back to the first step - how many choices for the first step, after we eliminate symmetries?
Puzzler: Three choices, middle, corner, or side.
Helper: Suppose we look at middle first.
Puzzler: Then O can go on a side or a corner.
...

Anyway, the idea is that one person is the domain expert, concentrating on the domain, and the other is the depth-first-search expert, concentrating on the bookkeeping involved in depth-first-search. A computer could be the helper. This is different from most "the computer helps you solve puzzles" applications, because the conversation is pre-formalization. Clearly, if the puzzler could hold the problem in their head, they could write down a constraint logic program - and there are lots of very powerful solvers for that sort of thing.

Depth-first-search is not univerally applicable, of course; but you could have conversational helpers for a lot of different generic strategies.

atheorist @ 2009-07-31T02:08:00

2009-07-31T06:29:48Z

I purchased and read "Bloom" by Wil McCarthy today, and it was pretty awesome. In one part, he describes the Game of Life. I'd be curious to know what someone who hasn't played with CAs would make of that description. I can recognize-and-remember, but I'm sure that's different.

One of my "idee fixes" is that there are a lot of "secrets" in the world; experiences that can be alluded to but not actually communicated via speech or text. If a book contains a particularly beautiful, poetic allusion, it can have a powerful effect on someone who has had that experience. However, to someone who has not yet had any experience close enough, it reads like flowery nothings.

Robin Hanson has a colorful notion of a world with a vast number of emulated humans; all working for wages and paying for their own compute time, hardware, whatever. If one individual is doing very well (very profitable for their employer, perhaps) - they might replicate (or be replicated) rapidly, homogenizing the population of emulated humans. Of course, being one of these copies doesn't mean safety - you're competing against your equals. I'd love to read some fiction that explores the notion more in-depth. Maybe something like the Russ from David Marusek's "Counting Heads"?

atheorist @ 2009-07-28T14:36:00

2009-07-28T19:16:20Z

I'm convinced that too much fuss is made of absolute, white-or-black TRUTH.

An engineer, in building a useful device, also constructs (in parallel) an EXPLANATION of why the device works. My favorite such explanation, from a delightful book called "A Near Thing for Captain Najork":

"What makes it go?" asked Aunt Bundlejoy. "Jam" said Tom. "When the anti-sticky plate hits the sticky it bounces back. The spring keeps it going, the connecting-rods move up and down, the wheels go round and the frog jumps."

Aside: Many of the differences between evolved and human-designed mechanisms can be explained by the "growing" vs. "assembled" distinction, but most of the remaining differences can be attributed to the EXPLANATION-BLINDNESS of evolution.

But back to the main point. An important part of the quality of the explanation is how much it simplifies the system. That is, we sacrifice true complexity for useful approximations. Outside of particle physics, theory-building work rarely makes claims of absolute TRUTH. Mostly, it's about about searching for good, general, explanations; far more valuable than a true, yet uselessly complex understanding. In reading about philosophy of science, you might get the notion that once a theory is falsified it collapses into dust, like a vampire from Buffy. However, most theories are already known to be false!

Clearly, there is some sort of challenge-response social game going on here, but it's something more subtle than the "Buffy" philosophy of science. I should read more Lakatos; he will explain it to me!

atheorist @ 2009-07-22T11:36:00

2009-07-22T16:33:49Z

Rhyme schemes might be an excellent toy domain to play with notions like linking and scope.

There's an operation, which you might call rhyme scheme normalization, that takes a list of integers and returns a list of integers, something like this:
111, 222, 333 each become 111
112, 113, 221, 223, 331, 332 each become 112
123, 132, 312, 321, 231, 213 each become 123
et cetera

One might be interested in connecting together two rhyme schemes. One way you could do it is simply concatenating their representations (11221+11221 = 1122111221). This might correspond to programmers who use the global namespace trying to work together. Another way you could do it is by renaming to avoid clashes (11221+11221 = 1122133443). This avoids clashes, but it prevents anything from one side meshing with anything from the other side.

One possible solution is to make the "connect" operator take three things; a left side, a right side, and a binding. (11221 + 11221 + {2->1}) would be a ternary operation, binding the left 2 to the right 1, resulting in 1122122332.

What would an elegant class library capturing this nonsense look like?

cheating

2009-07-19T07:50:00Z

There's various experiences that I draw on when I write code, and I think the naive notion is that I would be drawing on various educational experiences, such as lectures, reading, homework, and projects. I do that. However, one of the interesting experiences that is not mentioned on that list is cheating at video games.

Let me give you a concrete example. There is a rounding error in computing the prices of cheap objects in Morrowind. If you buy a stack of cheap objects, and then sell individual items back, then you can make a small income. The small income can be leveraged, via the Bargaining skill, into a larger income (up to a cap). Another example: By picking up an item, and then all that you can carry of a large stack of pennies (mowgles), you can (or could) weigh an item in Batmud to four digits of precision. By precise weighing, you can sometimes identify what an item is made out of.

The interesting thing about cheating in games is that it models the requirements-capturing or problem-formulating aspect of programming. There are many goals in the game, and there is a rich structure of actions. Often it is possible to chop out and capture formally a specific sub-problem, and then solve it. But which sub-problem to chop out is fully up in the air. A good choice of sub-problem can produce a vastly easier-to-solve task, the solution of which nonetheless helps with the larger-scope goals.

I think there should be more games where "cheating" via macros and/or other coding is encouraged. There are programming games (E.g. Core Wars or Robocode, but for some reason, people don't put as much effort into creating a rich, interesting, and gradually-difficult world when they're creating programming games as when they expect humans to be playing.

GMap

2009-07-16T12:35:39Z

A charming section from a recent CS arXiv preprint (GMap: Drawing Graphs as Maps):

Americana: Somewhat surprisingly, George Orwell’s 1984 along with Animal Farm ended up in the west corner of a region populated mostly by American writers. Britain is also represented by William Golding’s The Lord of the Flies and Aldous Huxley’s Brave New World along with Anthony Burgess’s Clockwork Orange, which connect the British corner of the region to the main part dominated by 20th century American classics. Ray Bradbury’s Fahrenheit 451 and Salinger’s Catcher in the Rye provide a transition to a variety of well-known novels: Steinbeck’s Grapes of Wrath and Of Mice and Men, Ernest Hemingway’s For Whom the Bell Tolls and The Old Man and the Sea, F. Scot Fitzgerald’s Great Gatsby, Harper Lee’s To Kill a Mockingbird and Ralph Ellison’s Invisible Man, Joseph Heller’s Catch 22, Kurt Vonnegut’s Slaughterhouse Five, Ken Kesey’s One Flew Over a Cuckoo’s Nest. Some 19th century novels can also be found here: Nathaniel Hawthorne’s Scarlet Letter and Mark Twain’s Adventures of Huckleberry Finn.

Victoriana: To the southwest of Americana is a region dominated by Dickens, Austen and Bronte novels. Starting with A Tale of Two Cities, Great Expectations and Oliver Twist in the north and going through Jane Eyre, Pride and Prejudice, Sense and Sensibility and Wuthering Heights in the middle, the region ends with more Dickens’ books in the southwest (The Pickwick Papers) and George Elliot novels in the southeast (Middlemarch).

Russiana: To the north of Americana lies one of the largest countries in BookLand, dominated by Russian literature and history. The core contains classic novels by Dostoyevsky (Crime and Punishment, The Brothers Karamazov), Tolstoy (War and Peace, Anna Karenina), and Solzhenitsyn (The Gulag Archipelago, Cancer Ward). In the northern part of the region is a collection of books about Russia and Russian history: Stalin: The Court of the Red Tsar, Khrushchev: The Man and His Era and Potemkin: Catherine the Great’s Imperial Partner. In the west there is a cluster of Albert Camus books (The Stranger, The Plague, The Fall), all well connected with the Russian classics.

Graecoromania: Another large region to the west of Americana contains a diverse collection of Graeco-Roman books. History books by Thucydides, Plutarch, Livy, Suetonius, Salust share the region with philosophy by St. Augustine, Plato, Socrates, and Aristotle. Greek theater is represented by Aristophanes, Aeschylus, Euripides, Sophocles and epic poetry by Homer and Virgil.

Mythium: Close to Graecoromania, on the southwest coast, lies the the legendary land of Mythium. Aesop’s Fables, Greek Myths for Young Children and The Gods and Goddesses of Olympus are next door to D’Aulaires’ Book of Trolls, D’Aulaires’ Book of Animals and D’Aulaires’ Book of Norse Myths.

Shakespearea: Very centrally located, neighboring Victoriana, Americana, Russiana, Graecoromania, and Mythium lies the land of Shakespeare. It is not surprising that nearly all tragedies, comedies and histories are present but it is interesting to observe what non-Shakespeare books are in this region: Chaucer’s Canterbury Tales, Tennyson’s Idyls of the King, Dante’s Divine Comedy, One Thousand and One Arabian Nights, Beowulf and The Adventures of Robin Hood.

The raw data for the graph, before it was rendered as a map, was the "Customers Who Bought This Item Also Bought" data from Amazon. The map itself is here.

ridiculousness

2009-06-24T13:36:08Z

I think hyperbolic discounting is pretty awesome.

Could possible use that as part of a Sims-like AI? If I understand correctly, the Sims AI has a very simple find-best-action core. The core accepts "advertisements" of possible actions from objects, describing why someone might want to, say, sit on the couch (it's comfortable). In the actual sims game, the language of the advertisments come in the form of quantities of various needs (comfort, social, food, bladder).

The difference here would be that the "currencies" would be happiness at various delays. Then the sims could choose between actions like eat ice cream (happiness now, unhappiness later) and throw out all icecream (unhappiness now, happiness later), and evaluate them according to their own discounting schedule.

I doodled a little bit of code related to this idea, but I didn't get very far.

// Beware of bugs in this code, I have rewritten it since the last time I tried it.
// forward declaration
class Action;
// A callback interface used by Action.
class ActionSubscriber {
protected:
  // Constructor.
  ActionSubscriber() {}
public:
  // The reason for this interface to exist.
  virtual void ActionAvailability(Action* who, bool available);
  // Destructor.
  virtual void ActionSubscriber() {}
};
// Publishes availability of an action.
class Action {
public:
  // Constructor.
  Action(bool starting_availability)
    : subscribers(),
    current_availability(starting_availability)
  {
  }
  // Mutator.
  void Subscribe(ActionSubscriber* to_subscribe) {
    subscribers.insert(to_subscribe);
  }
  // Mutator.
  void Unsubscribe(ActionSubscriber* to_unsubscribe) {
    subscribers.erase(to_unsubscribe);
  }
  // Do the Thing!
  virtual void Run() = 0;
  // Accessor.
  bool GetAvailability() {
    return current_value;
  }
protected:
  // Mutator.
  void SetAvailability(bool new_availability) {
    if (new_availability == current_availability) {
      // no need to announce anything
      return;
    }
    current_availability = new_availability;
    Publish(current_availability);
  }
  // Sends availability to all the subscribers.
  // Normally, one would use SetAvailability instead.
  void PublishAvailability() {
    // Take a copy, publishing can influence subscribing.
    subscribers_type local_copy(subscribers);
    for (subscribers_type::iterator i = subscribers.begin();
      i != subscribers.end();
      ++i) {
      (*i)->ActionAvailabilityChanged(this, to_publish);
    }
  }
private:
  typedef std::set<ActionSubscriber*> subscribers_type;
  subscribers_type subscribers;
  bool current_availability;
};
// Represents a prioritized list of actions.
class PriorityList : public Action {
public:
  // Constructor.
  PriorityList()
    : Action(false),
    helper(this),
    priorities(),
    available()
  {
  }
  // Mutator.
  // Client guarantees that no two actions have the same priority.
  void Add(Action* to_add, int priority, bool currently_available) {
    to_add.Subscribe(helper);
    priorities[to_add] = priority;
    if (currently_available) {
      available[priority] = to_add;
    }
  }
  // From Action.
  void Run() {
    assert(!available.empty());
    available.begin()->second->Run();
  }
private:
  // Keeps PriorityList from having to be an ActionSubscriber.
  class Helper : public ActionSubscriber {
  public:
    // Constructor.
    Helper(PriorityList* to_help)
      : to_help(to_help)
    {
    }
    void ActionAvailability(Action* who, bool available) {
      to_help->PrivateActionAvailability(who, available);
    }
  private:
    PriorityList* to_help;
  } helper;

  std::map<Action*, int> priorities;
  std::map<int, Action*> available;

  void PrivateActionAvailability(Action* who, bool is_available) {
    assert(priorities.find(who) != priorities.end());
    int priority = priorities[who];
    if (is_availabile) {
      available[priority] = who;
    } else {
      available.erase(priority);
    }
    SetAvailability(!availabile.empty());
  }
};

atheorist @ 2009-05-18T00:48:00

2009-05-18T04:48:40Z

We have a puppy!