Dear Customer,

Due to a European shortage of the Nintendo Wii Consoles, we regret to inform you that Play.com will be unable to supply your pre-ordered Nintendo Wii at launch. As an Official distributor of Nintendo products we are guaranteed more stock before Christmas, but Nintendo have informed us, along with all other official Nintendo retailers, that the console will not be freely available until next year.

All pre-orders will be fulfilled on a first come, first served basis and we will fulfil your order as soon as we can.

If you no longer wish to keep your pre-order with Play.com please login to your account and remove the item from your Outstanding Orders.

AAAAAAARRRRRRRRRRRGGGGGGGGGHHHHHHHHHHH!!!!!!!!!!!!

1. When did Hallowe’en lose its apostrophe? It always had one when I was a kid; now it seems to be “halloween” everywhere…
2. When did it become such a big deal? It seems every shop is full of cheap plastic pumpkins and witches hats. I’m sure someone could write something erudite about how the secularisation of Britain has combined with the shops’ need to have something to fill the space between “Back To School” and “Christmas”…

I have ordered some :-)

I’ve also started listening to more Keith Jarrett, and I’ve produced a basic transcription of his improvisation Radiance #8.

Watching the Gould programme made me go back and listen again to his awesome recordings of the Goldberg Variations. It’s such a fantastic piece – I’ve ordered the sheet music online.

I’m going to find out exactly what damage only playing on an electric piano has done to my technique…

The syntax looks like:

for (element foo : collection) {
    ...
}

To allow your own classes to be iterated over with the foreach construct they must implement the new Iterable interface and thus provide an “iterator()” method to return the appropriate Iterator object.

However, there is a limitation in the current implementation. In some code I was writing I found I had a class which looked like:

public class Foo {
    private List<Integer> intList = new ArrayList<Integer>();
    private List<Float> floatList = new ArrayList<Float>();
}

I wanted the user of Foo to be able to choose to iterate over either the intList or floatList. My first attempt was:

public class Foo implements Iterable<Integer>, Iterable<Float> {
    private List<Integer> intList = new ArrayList<Integer>();
    private List<Float> floatList = new ArrayList<Float>();

    public Iterator<Integer> iterator() {
        return intList.iterator();
    }

    public Iterator<Float> iterator() {
        return floatList.iterator();
    }
}

But it won’t compile! The problem is that you are not permitted to implement the same interface more than once, even if you use a different generic type each time.

I’m not sure why this is, but I guess it has something to do with the requirement to support legacy code without modification. It meant that being able to write:

Foo foo;
for (Integer i : foo) {
    ...
}
for (Float f : foo) {
    ...
}

was impossible.

I thought about this for a day or two until a solution popped into my head (after a few beers, as often happens!). It is possible if we use Java’s support for inner classes. The code isn’t quite as simple, but it’s the best we can do – and the difference to the user is so small that I think it’s a neat solution. The code follows:

public class Foo {
    private List<Integer> intList = new ArrayList<Integer>();
    private List<Float> floatList = new ArrayList<Float>();

    public class Integers implements Iterable<Integer> {
        public Iterator<Integer> iterator() {
            return intList.iterator();
        }
    }

    public class Floats implements Iterable<Float> {
        public Iterator<Float> iterator() {
            return floatList.iterator();
        }
    }
}

The user code looks like:

Foo foo;
for (Integer i : foo.new Integers()) {
    ...
}
for (Float f : foo.new Floats()) {
    ...
}

I’m quite pleased with this solution. I wouldn’t go as far as to call it a design pattern, but it certainly allows us to work around one of the limitations of Java generics.

smithycodeJaeiextostgpsacgreamqwfkadpmqzv

I started to investigate it. It is not:

1. Caesar cipher (including ROT-13 ;) )
2. Atbash cipher
3. Vigenere with key of DAVINCI or SMITHYCODE

There isn’t enough ciphertext to use any of the standard attacks against Vigenere, so I just tried a few guessed keys. If it is Vigenere then someone will have to get lucky.

A few people online have noticed that the ciphertext is the same length as “do not waste the time of the high court”….

UPDATE: It’s been solved! And it was Vigenere. The key was generated from the Fibonacci sequence (mentioned in the book apparently).