Supple software

Tilting the platform

Sun, 10 Aug 2008 12:46:19 PDT

Ok, prepare for this, cause this is the most psychological I’ve ever been on this blog, but I am going to write it, just for the hell of it and because I keep seeing it in my real work life. Picture this: You and your girlfriend have lost/left your keys. You sit in front of your house. Imagine this exchange:

I can’t believe it’s happened again! We should leave a set of keys with our neighbour!
Yeah, but what happens if she’s away right when we lose our keys??

And you do nothing. This is unhelpful. You should have thought before having a girlfriend who starts most of her sentences with “But…” or even worse, “Yes, but…” And yet, it’s not her fault. She’s preserving the status. If you gave a key to your neighbour, this would tilt the relationship between you, your girlfriend and your neighbour.

Well, sadly, this happens a lot at work, and that’s why a lot of bad stuff (software, habits, mentalities, you name it) never changes. If you need to know more about this whole thing and how it works on psycho-level, read Impro for Storytellers by Keith Johnstone. It’s rather amazing and, in a bizarre way, explains a lot of the daily going-ons in a development team.

Persistence not supported for this MBean

Sat, 7 Jun 2008 15:04:00 PDT

I was getting an MBeanException with this message when I used jconsole to call a Spring exported MBean method called load(). Other methods (both attributes and operations) seemed to work fine. I may still be totally wrong, but I think that was because of the name of the method. I tried a lot of things for almost half a day, cleared the body of the method, changed attributes, changed the Spring config in many ways, changed names of beans and all sorts of other things - nothing worked. Eventually I stumbled upon this - piece of seemingly irrelevant code. It struck me though that the method that does nothing but throw an exception with a strangely matching message (this string yields only six matches in google) is called load(). I changed the method name and it worked.

So, what goes on inside is beyond me at this time, and I can’t be bothered to investigate right now, but if you’re going to export a @ManagedOperation through Spring do not call the method load().

Do you really want to use proprietary app servers?

Wed, 14 May 2008 05:10:23 PDT

If someone needs a proof that proprietary app servers must die (that’s if the hours you spend dealing with annoying little problems isn’t enough proof), have a look at this piece of code that somehow has appeared in the open source space, but is also used by BEA’s ejbgen under a different package structure.

Have a look at the JavaClassLoadingException and JavadocRunner classes. Especially the use of the JavadocException - with the static method call and all the rest that is going on. I bet the rest of BEA code is full of idiotic use of exceptions and all sorts of other rubbish. Which is why it is a pain… It’s just low quality code, especially compared to the constantly reviewed and improved stuff that comes from the open-source projects that last.

Now, I understand this was done in 2004, but I’ll argue that BEA’s developers have not got any better with the years, if anything they’ve probably done a fair bit of cost-cutting and migrated to using the grads who couldn’t make it to a bank and paying them peanuts.

How to win a pointless argument

Sun, 27 Apr 2008 15:38:44 PDT

By not trying… Here’s what Sir Christopher Wren did in Windsor. It’s somewhat bizarre that I lived in Windsor and ran past that same building practically every morning and never knew about it.

Christopher Wren was already one of the most respected architects in the country when some daft public servant questioned his design on safety basis, and asked for two additional columns to be built for extra support. Wren built them. Look here to see how - http://inel.wordpress.com/2007/02/09/sir-christopher-wrens-joke-in-windsor-guildhall/. They did not touch the ceiling. Many years later, they still don’t touch the ceiling.

As I mentioned earlier, I never knew that during the seven years I lived about half a mile away from this building. I’ve just found this out, from a book, whose main subject is how to ruthlessly manipulate people… Ah, well, you live and learn…

QCon talk by Peter Rodgers about REST

Sun, 16 Mar 2008 08:44:00 PDT

Actually, not just about REST. Those guys spent some time analysing the structure and workings of the web, and asked themselves why it was so efficient and malleable. While most other software was brittle, messy, and unreliable. They found some basic truths about the web, such as, the cost of change is much lower than the added value of that change, therefore it’s worth changing the system.

Anyway, they figured that it’s the “uniform well-observed address space”, which allows the latest bleeding edge Firefox three to connect to some apache server which may have been running for twenty years. It is also the thing that allows resources to be cached in a way that is self-optimising, much like a system acting under the laws ofthermodynamics (the guy’s from a physics background). Incidentally, it is also the main premise behind REST. So apparently, they’ve figured a way to build systems that have similar properties. Their thing is here - http://www.1060research.com/. It’s very impressive in purely philosophical terms and in the implications it has for software developments as a whole.

I reckon some of these concepts can be applied in practice without actually buying their product, NetKernel…

By the way more on this can be found in Roy Fielding’s dissertation here - http://www.ics.uci.edu/~fielding/pubs/dissertation/restarchstyle.htm

Book: Psychology of Computer Programming

Sun, 17 Feb 2008 13:02:56 PST

If you haven’t read this, read it now - http://www.bookdepository.co.uk/WEBSITE/WWW/WEBPAGES/showbook.php?id=0932633420

I can not believe I have only found this book recently - it’s been around for 25 years! How good is that for a computer book. I reckon that’s because programming is not as much about technologies as it is about human behaviour, thought and self-awareness.

Gerry Weinberg explains, in his extremely effective and efficient style, familiar from Secrets of Consulting, what this stuff is all about.

Thanks to Ludo, on whose desk I spotted it. When you read it, pass it on - it can only do good to everyone who reads it and their immediate surrounding.

Java enums over IIOP

Sun, 17 Feb 2008 10:42:00 PST

If you pass an enum argument over IIOP, the value in the deserialised object on the server has very strange properties. Here’s what I observed (someEnum is the deserialised object on the server):

someEnum = null
someEnum.name() = null
someEnum.toString() = null
(someEnum == null) = false

Clearly a fairly useless instance for any possible purpose. It’s null, but not quite. It has no value and can not be meaningfully compared.

You can’t work around it with Externalizable, because the immutable enum can not modify itself, and for the same (perfectly valid) reason write/readObject are useless.

This was reported in May 2005 - here - http://bugs.sun.com/bugdatabase/viewbug.do?bugid=6277781

The last comment on that entry, made in Aug 2007 says: “btw, is someone working on that?…”.

Seems either people who use Java 5 and later do not use IIOP and vice versa, or you’d have thought someone would have done something by now….

Any super-clever ideas for a workaround are most welcome.

“Don’t use enums” and “don’t use IIOP” do not count as super-clever on this occasion.

And more code (no need to wait)

Fri, 23 Nov 2007 01:53:18 PST

Thanks to Yuri for pointing out that you don’t need to wait until all the results are done to start processing them. Here, we’ve only got integers, but in reality it is likely that the individual results will be big and meaningful and actually take some time to interpret or do something with. To start working on them as soon as each one is ready, we use CompletionService:


public class ParallelCompletionCounter {
    public int countWordsAsSoonAsFileFinishes(List files) {
        CompletionService completionService = new ExecutorCompletionService(Executors.newFixedThreadPool(4));
        for(final File file : files) {
            Callable counter = new Callable() {
                public Integer call() {
                    System.out.println("Starting file " + file.getName() + " at " + System.currentTimeMillis());
                    int time = 500;
                    if (file.getName().contains("304")) {
                        time = 5000;
                    }
                    try {
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    WordCounter counter = new WordCounter();
                    int count =  counter.count(file);
                    System.out.println("Done file " + file.getName() + " at " + System.currentTimeMillis());
                    return count;
                }
            };
            completionService.submit(counter);
        }
        try {
            int totalCount = 0;
            for (int i = 0; i<4; i++) {
                totalCount += completionService.take().get();
                System.out.println("Added File Count");
            }
            return totalCount;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        ParallelCompletionCounter counter = new ParallelCompletionCounter();
        List files = new ArrayList(args.length);
        for (String filename : args) {
            files.add(new File(filename));
        }
        System.out.println("Total word count is " + counter.countWordsAsSoonAsFileFinishes(files));
        System.out.println("Total elapsed time " + (System.currentTimeMillis() - start));
    }   
}

More code

Thu, 22 Nov 2007 05:06:12 PST

I’ve been exploring the java.util.concurrent package, and just thought I post some more code:



public class ParallelCounter {

    public int countWords1(List files) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        List> counters = new ArrayList>();
        for(final File file : files) {
            counters.add(new Callable() {
                public Integer call() {
                    System.out.println("Starting file " + file.getName() + " at " + System.currentTimeMillis());
                    WordCounter counter = new WordCounter();
                    int count =  counter.count(file);
                    System.out.println("Done file " + file.getName() + " at " + System.currentTimeMillis());
                    return count;
                }
            });
        }
        try {
            List> results = executorService.invokeAll(counters);
            int totalCount = 0;
            for (Future future : results) {
                totalCount += future.get();
            }
            return totalCount;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        ParallelCounter counter = new ParallelCounter();
        List files = new ArrayList(args.length);
        for (String filename : args) {
            files.add(new File(filename));
        }
        System.out.println("Total word count is " + counter.countWords1(files));
        System.out.println("Total elapsed time " +
(System.currentTimeMillis() - start));
    }
}

The five philosophers

Tue, 20 Nov 2007 01:54:00 PST

Here’s my little implementation of the five philosophers problem.

The chopstick:



package philosophers;

public class Chopstick {

    private int number;

    public Chopstick(int number) {
        this.number = number;
    }
    public int getNumber() {
        return number;
    }
}

The philosopher:



package philosophers;

public class Philosopher implements Runnable {

    private int number;

    private Chopstick leftChopstick;

    private Chopstick rightChopstick;

    public Philosopher(int number, Chopstick leftChopstick,
            Chopstick rightChopstick) {
        this.number = number;
        this.leftChopstick = leftChopstick;
        this.rightChopstick = rightChopstick;
    }

    private void eat(int time) {
        synchronized (leftChopstick) {
            System.out.println("Philosopher " + this.number
                    + " took chopstick " + leftChopstick.getNumber()
                    + " from the left.");
            synchronized (rightChopstick) {
                System.out.println("Philosopher " + this.number
                        + " took chopstick " + rightChopstick.getNumber()
                        + " from the right.");
                try {
                    System.out.println("Philosopher " + this.number
                            + " is eating...");
                    Thread.sleep(time);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    private void think(int time) {
        try {
            System.out.println("Philosopher " + this.number + " is thinking...");
            Thread.sleep(time);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public void run() {
        while (true) {
            think(1);
            eat(1);
        }
    }

}

And, bringing them all together, the Table:



package philosophers;

public class Table {

    /**
     * Chopstick 0 is on the left of phylosopher 0
     */
    private Chopstick[] chopsticks;

    private Philosopher[] philosophers;

    public void build(int numberOfSeats) {
        for (int i = 0; i < numberOfSeats; i++) {
            chopsticks[i] = new Chopstick(i);
        }
        for (int i = 0; i < numberOfSeats; i++) {
            philosophers[i] = new Philosopher(i, chopsticks[i],
                    chopsticks[i < numberOfSeats - 1 ? i + 1 : 0]);
        }
    }

    public Table(int numberOfSeats) {
        chopsticks = new Chopstick[numberOfSeats];
        philosophers = new Philosopher[numberOfSeats];
        build(numberOfSeats);
    }

    public void start() {
        System.out.println("Chopstick 0 is on the left of philosopher 0");
        for (Philosopher philosopher : philosophers) {
            new Thread(philosopher).start();
        }
    }

    public static void main (String[] args) {
        new Table(5).start();
    }
}

Deadlocks pretty quickly with the numbers as they are here.