April 2014

First LomoChrome Purple XR 100-400

After coming across the astonishing Infra photos taken by Richard Mosse using the now discontinued Kodak Aerochrome, I kept an open eye when Lomography last year announced their new Aerochrome-inspired LomoChrome Purple XR film. I didn’t buy into it for the first batch, but in a weak moment I put down the order for the minimum of five rolls when the second batch came up for pre-sale, at a price of around 10€ each. Here are a few photos from the first roll.

Overall I’m a tad disappointed, but perhaps was so even before putting the film in the camera: the key, I suppose, is that the film is inspired by Aerochrome and does in fact produce results quite different from this old professional film apparently developed for the military. And this became clear when the photos from the first batch started showing up online.

However, paradoxically as it may sound, picking up the prints from the first film was actually a positively surprise; while they are not amazing, it does work better in some situations than I dared expect from following the film on Flickr.

For instance, the total submersion in purple in English Garden and Purple, Dog is not too bad. And although at first a bit skeptical about how the film renders blue sky, Dome and Collage are among my favourites on this roll.

Finally, since the film is rated ASA 100-400, and since there has been some talk online about making sure to overexpose, I also did a few test shots to see if there would be any difference: one correctly exposed according to an external light meter and two respectively over- and under-exposed by one stop.

And here perhaps was the biggest surprise, namely how very different the results are.

Book: Java Generics and Collections

During preparations for a job interview I noticed that my understand of Java Generics had some holes in it; and during the interview itself it became clear that there were also a few holes in my knowledge about the corner cases of the Java Collections framework introduced with Java 5 and 6. So, after looking around a bit, which book could be more suiting than Java Generics and Collections?

Now, I wasn’t completely lost for either of the two, but they were both introduced after I had my Java programming course (in Java 1.4) and apparently since then there hasn’t been a situation requiring much more than your typical

List<String> strList = new ArrayList<String>();

and the like (perhaps there rarely are?). However, when I came across the follwing signature:

public static <T extends Comparable<? super T>> T max(
    Collection<? extends T> coll) {
    // iterate to find max ...
}

it was clear that there was something not so trivial going on; a nice little example of why this crooked specification is useful is given in Section 3.3, but funnily enough I find the use of keywords extends and super a bit counter-intuitive here — mostly likely because I’ve “grown up” with the formal <: notation instead.

Now, in general the chapters on generics are well-written and usefully sprinkled with illustrative examples. There could sometimes have been more technical explanations, and perhaps links to formal type theory (it was written by Philip Wadler after all), however, overall it’s a highly recommended read!

It even taught me a little peculiar thing about Java bytecode, namely that generics allows one to overload methods based on return type:

class Works {

    public static void main(String[] args) {
        Works o = new Works();
        int i = o.<Integer>foo();
        boolean b = o.<Boolean>foo();
    }

    public <T extends Integer> int foo() {
        return 0;
    }

    public <T extends Boolean> boolean foo() {
        return false;
    }

}

which wouldn’t compile without generics:

class DoesntWork {

    public static void main(String[] args) {
        DoesntWork o = new DoesntWork();
        int i = o.foo();
        boolean b = o.foo();
    }

    public int foo() {
        return 0;
    }

    public boolean foo() {
        return false;
    }

}

since the compiler doesn’t know which method to pick in main. However, the bytecode calls a method by looking up in an index table, and with generics the compiler has enough information to differentiate these.

For the second part of the book, on the Collection framework, the book disappoints a bit: it covers most classes and uses, but few details are given and there’s quite a bit of fluff. It gave me the overview I needed, but not much more than going over the online Java documentation.