Think carefully about what this advice is trying to imply.

Using NLP-style nested loops, i.e. performing what is basically a stack overflow on the brain's frame-of-reference counter? Wicked.

No person may contribute to more than one entry.

This is important, because otherwise the contest devolves into who can submit the most copies of AbsolutismBot (cooperate with programs that share it's source code, otherwise defect)

I think that any submitted program can be improved by combining it with AbsolutismBot. If you're playing with someone who submitted the same program for you, cooperate (they can't defect against you in this scenario, since they're running identical source code). If they aren't running the same code, run whatever program lies underneath it.

I think this could get generalized to cooperation with everyone who has the AbsolutismBot "wrapper", since it doesn't matter what the code after the AbsolutismBot section does. In English (since I don't know how to program in Scheme), the program would be like this:

If the first 117 characters of the other program are the same as the first 117 characters of this program, cooperate. Otherwise, do some other strategy.

All players that implement this strategy will cooperate with each other. Granted, this doesn't help them win the tournament since it isn't a relative advantage compared to other AbsolutismBots - it just makes everyone who doesn't do this lose the tournament.

But even now, there's stuff you can do in 2013 that was largely out of reach, if not unknown, in 2000.

Have any handy examples? I find that a bit surprising (although it's a dead cert that you know more about pop music than I do, so you're probably right).

This article was very helpful for me. Especially the part about dentists. It reminded me to call my dentist and make an appointment, which I've been procrastinating on for weeks. Anyone else in the same situation? Call now!

I am not sure how much evidence there is for Extreme Programming. But if it works, I wonder how much its rules can be translated to areas beyond programming. (Or maybe it already exists. Maybe "two minds work better than one" was already know for millenia, only for IT people it remains a surprising and controversial topic.) Could we somehow abstract the coding details away, and call it Extreme Doing?

The parts about planning (estimates, acceptance tests) seem universal enough. Sure, the tests will not be automatical, but writing them specifically and in advance could help a lot. Stand up meeting every morning? Trivial. What is a proper analogy for refactoring? Probably it means avoiding procrastination on strategic things; if I know that a small change in environment could make my future work more efficient, I should do that small change as soon as possible. Unit driven development? Before you start doing anything, write explicitly on paper which properties do you except from your result; later check the paper to confirm you did not forget anything. Pair Programming? Don't do things alone; you will have more fun. (Also the obvious problem: you need to find another fan of Extreme Doing working on the same project.) I am not sure about the continuous integration. It probably means that you should design your plans so that they will bring some partial benefits during the way to your goal, gradually increasing the benefits as you progress (as opposed to: first I must finish everything completely, and only then it starts being useful).

I've made a recording with SuperCollider using almost the same algorithm as in the Python script above, here's the link /watch?v=wjZRM6KgGbE.

Identity is a process, not a physical state. There is a difference between continuity of body, which is physical, and continuity of identity, which is a process. If I replace a hard drive from a running computer, it may still run all of the same processes. The same could be true of processors, or memory. But if I terminate the process, the physical substrate being the same is irrelevant.

This reminds me of a game/mod (called "Prometheus" IIRC) where you had to complete objectives within a fixed amount of time in a manner impossible to do alone, with guards to kill and multiple switches to press at the same time to open a door... but all you had for help was yourself, in five copies.

The game would basically let you play the first copy, end, play the second copy while the first played out what you had done previously, then the third while the first two kept repeating what you recorded, and so on, and then you could go back and re-do earlier copies to account for new actions taken by the later copies, all culminating in one big five-minute match between You^5 VS (Causally) Impossible Level. Think Portal 2 coop but with time-traveling copies of yourself.

Perhaps some of the inspiration came from those?

So what does the algorithm do when you run it?

Would it help if the link were aimed at the real life section?