Consider a web application, required to do lengthy operations from time to time, either IO bound, or CPU bound. To save time, and maybe also bandwidth or CPU time, we are interested in caching the results of these operations.
So, let's say we create some database table, that has the following fields:

• Unique key: input
• output
• use_count *
• Last use date *

I've marked with an asterisk the fields that are optional, and are related to managing the size of the cache. These are not relevant at the moment.
Here is how code using the cache would look like (in pseudocode form):

This code will work well under normal circumstances. However, in a multithreaded environment, or any environment where access to the database is shared, there is a race-condtion: What happens if there are two requests for the same input at about the same time?
Here's a simple scheduling that will show the bug:

Thread1: result = cache.select(input). result is None
Thread1: result = compute(input)
Thread2: result = cache.select(input) result is None
Thread2: result = compute(input)
Thread2: cache.insert(input, result)
Thread1: cache.insert(input, result) - exception - duplicate records for the unique key input!

This is a classic race condition. And here's a small challenge: What's the best way to solve it?

Finding out what IE was so upset about wasn't fun, as I didn't have a debugger for IE. So I started looking for one. Not wanting to install visual studio just for that, I installed(*) "Microsoft Script Debugger", which is one old piece of software. It's so old that its readme states that it works with IE 4. At least it works. It lacks watches and some other features you'd expect from a debugger (which Firebug has!), but it got the job done. Mostly.

I wasted about 40 minutes on that issue.

* Installing "Microsoft Script Debugger", contrary to what some my tell you, does not require installing old office versions. I followed a download link on Microsoft's website, and got it. It does require some voodoo if you're running Vista, but nothing too hard to handle.

This little gem took me two hours to track down.
It turns out that since my code is using sqlobject, it also uses the decimal module. I had some constants set up, and from within some larger algorithm I wanted to compare values extracted from the db to those constants. However, my code didn't seem to work, and I was sure the problem lay somewhere else in the algorithm.
Two hours later, and I found this comparison. It might be similar to this issue, but I'm not sure.

In any case, I was using Python 2.5.2, and decimal works as expected in Python 2.6, so I guess it is indeed time for an upgrade.
After some more checking with Python 2.6, it seems that:

Not good.

In any case, Mochikit has really easy support for good looking drag&drop. However, as usual, my requirements were strange enough to fall upon the following corner case:
I wanted to add a "tool tip popup" for some text, where I would display pertinent information to said text. To make the tool tip popup thingy work, I used the following css "on mouse over" visibility trick:

This works beautifully, and with a little bit of positioning, and maybe an event here and there, you can make it appear where you want.

Cue the drag&drop. I wanted to add some drag&drop based slider to that tool tip. Since I wanted to limit the "draggability" of the slider's selector, I used the snap argument for Mochikit's Draggable object so that if you move the mouse too far, the dragged selector stays at the limit of a predefined area.
This was all very well, and both of the tricks described worked pretty fine separately, until I tried to put them together.
When dragging and leaving the allowed area for the drag, because of the snap argument, the dragged object stays back, and mouse is no longer over a child element of the original tooltip and tooltipped text. This means that the css trick no longer applies, and the tooltip loses visibility. This would have been fine if the drag ended there. However, the drag was not ended, and at each move of the mouse, the coordinates would grow more. Since I use the drag coordinates to compute the result of the drag, I got some pretty strange results.

To work around this behavior, I used Draggable's starteffect and endeffect optional arguments to make sure the tooltip remained visible, thus avoiding this issue.

Still, there were many other issues with all this drag&drop going around, and I decided to go for a simpler design, and not put in more time on this.
Issue sealed with a Keep It Simple Stupid.

Read on for the full instructions.

Click on the images to enlarge.

	1. We'll start with a black square piece of paper.
	2. Fold the horizontal and vertical folds. Note the direction of the folds, to make sure the spider comes out colored.
	3. Fold the diagonal folds.
	4. Create this regular base (I forgot the name) by folding inside.
	5. We'll start folding the limbs the usual way. for each flap fold it up, unfold, and fold it down. In the picture two folded flaps are shown. The right one is up, and the other is down.
	6. Precrease each flap as shown. The line goes from the corner to the intersection of the two previous folds.
	7. Open up the flap as shown.
	8. Fold the edges inside along the precrease created on step 6. In this picture one edge is folded and the other is not.
	9. Fold the other edge as well.
	10. Close the flap back, and repeat the process for each of the other flaps.
	11. Here it is shown after another flap was folded.
	12. This is how it should look after all four flaps were folded.
	13. Precrease the top of the fold. Fold it in both directions.
	14. Open the fold between two side flaps, and the small extra flap up. Repeat this for the other side as well. (This should be repeat twice, and not four times)
	15. Open up one of the flaps, and fold the edges inside as shown.
	16. Close
	17. Repeat the two previous steps for each flap.
	18. Now prepare the limbs. One pair of limbs should be reverse folded to the sides. The other pair should be just folded back. In the picture the bottom pair is folded to the sides, and one limb from the upper pair is folded back.
	19. Turn the fold over, and reverse fold the front limbs. (The ones pointing to the sides.)
	20. Open one of the sides, and precrease as shown. Do this for the other side as well.
	21. Squish the op inside. This is a bit complicated. You can use a closed pen from the inside to straighten it a bit.
	22. Squish down between the 'head' and the stomach. Reverse fold the back legs twice to give them shape.
	23. Fix the stomach a bit to finish up. I'm not too good at it myself, as it takes a little practice.
	24. And it's done!

Here are the results:

These two critters look moderately bug-like. Note that the left one has these two fins at the side - those are two of the flaps. One other is the head.

I had another piece of paper which is now fubar (folded up beyond all recognition) of the same fold, which resembled a human being. I'll probably be playing with this fold some more, while looking for minimum cuts (in graphs) and writing a compiler (for cpl).

I also wanted to create the web-page myself, so I had to learn a bit of JavaScript, html, css, and other cuss-words. Indeed, JavaScript seems to me a bad language. There is no printf equivalent! I tried looking for it on the web, and all I could find were partial implementations by people around the world. Did I say these implementations were partial?

Nevermind. So here is the new origami page, soon to be filled with many wondrous creatures.

Here is a preview of the first fold waiting there: