Let’s take the example on the puzzle page –

TIHS SENTENTCNES ISS NOUT VARRRY GOUD

It’s a munged up version of

THIS SENTENCE IS NOT VERY GOOD

The original problem statement involves minimizing the score (number of changes necessary) to transform each word in the munged up sentence into words that are in a predefined wordlist. It says nothing about grammatical correctness of the result.

So going by that, the score and the output sentence from my implementation are respectively, 8 and

TICS SENTENCES IDS NOT VAGARY GAUD

From the standpoint of the original problem, this solution is correct.
But not from a grammatical point of view. After some poking around, I realized it’s not possible for this program to spew out the correct version of the sentence without it being aware of English grammar rules.

P.S. Without getting into grammar correction, of which I have no idea how to implement, I made a small change in the program as an experiment. The second version favours a smaller word whenever the scores for two are equal.
And the result is (Score remains the same)

TIS SENTENCES IS NOT VARY GOD

Unfortunately I’ve been able to devote time for this mostly on the weekends. This translates to slow progress because UNP goes into a lot of depth about everything. This is a good thing, but it also means that I’ve to reread and review the last few pages everytime I try to pick up where I left off. This does not really help when I’m trying to understand concepts in depth. So what’s the solution? I’ll try to do a bit atleast 3-4 days a week from now on.

UNP is an amazingly detailed book – and as one of my colleagues said – “If you read that book properly, Stevens makes sure that there’s nothing left for you to know on the topic”. I agree.

Stevens wrote his own wrapper functions over common socket functions and used them in all the code examples in the book. The wrappers handle all error codes and portability issues (like IPv4/IPv6). These are included in a header unp.h (available in the back of the book as well as online on http://www.unpbook.com/src.html).

Some reviewers of the book gripe about this and say that this is an obstacle to learning the actual functions. But I think that there was no other way to do it without littering every example snippet with code for portability and error handling. The wrapper strategy makes it easier to follow the examples, and at the same time – as I found out – it makes you write those wrappers yourself. True, you can just include the unp.h header as you try the examples, but then you’ll never know what those functions are doing. I’ve found that creating my own header and writing the functions as I come across them, after looking at the book’s source code, works great. Most of them will end up identical to those in unp.h.

I’m pushing the examples I’m trying out into github – it’s a scratchpad so not everything might compile.

I’ve added a generic startserver function to my header – this takes a pointer to a function as an argument. The generic function starts a server socket (bind/listen/accept), forks a child when a client connects and calls the function that was earlier passed as an argument, abstracting out the actual serving part. The function pointer syntax was not hard to figure out – I’d read Peter van der Linden‘s algo on unscrambling declarations in C last week. Interesting how things add up!

Code Snippet 1

public class Init {
    {
        System.out.println("In the beginning was the command line");
    }

    public Init()
    {
        System.out.println("Created an instance");
    }

    public static void main(String[] args)
    {
        Init init = new Init();
    }
}

What do you think the output is? It’s this -

    In the beginning was the command line
    Created an instance

The ‘hanging’ braces at the start of the class definition are instance initializers. Most of us are more familiar with static initializers -

Code Snippet 2

static
{
    //Do stuff
}

Instance initializers (II) are not seen often in everyday Java code – so they might seem odd at first. They are executed every time an instance of that class is created, before the statements in the constructor are executed. (See The Java Language Specification 3 section 8.6).

One use of IIs can be to execute something whenever an instance is created, and the class has multiple constructors, without calling it in every single constructor.
Another one which has become popular is populating collections during declaration, in the style of Ruby or Python single-line initializers -

Code Snippet 3

private Set<String> names = new HashSet<String>() {
    {
        add("Rigel");
        add("Vega");
        add("Antares");
    }
};

This idiom was how I encountered IIs first while reading somebody’s blog.
What is actually happening here?

1. An anonymous inner class is created.
2. An instance initializer block is added to the anon inner class.
3. Objects are added to the instance of that class when the names variable is initialized.

Now take this scenario
Code Snippet 4

public class WrongUsage {

    private Set<String> names;

    {
        add("pleiades");
    }

    public void WrongUsage()
    {
        names = new HashSet<String>();
    }

    public void add(String name)
    {
        names.add(name);
    }
}

Based on what we have seen above, the names set is used before it’s initialized. So this throws a NullPointerException.
Let’s take another case – similar to the above but involving inheritance.

Code Snippet 5

public class MyHashSet extends HashSet {
    {
        add("pleiades");
        System.out.println("Added");
    }

    public MyHashSet()
    {
        super();
        System.out.println("After calling super");
    }

    public static void main(String[] args)
    {
        Set set = new MyHashSet();
    }
}

This runs, with the output being

    Added
    After calling super

In this case, add() internally uses the inner HashMap inside HashSet which is initialized in the HashSet constructor. This implies that the instance initializer is invoked before the class constructor, but after the superclass constructor (The super call is redundant here. It will be called anyway).

So the sequence is

1. Superclass initialization (this includes superclass instance initializers and constructor)
2. Current class’s Instance initializers
3. Current class’s Constructor

This is why the code in Code Snippet 3 does not throw an NPE – because it’s a case of inheritance (the anon inner class is a subclass of HashSet)

I buy a lot of books, mostly online. There are a few good online bookstores in India, notably Flipkart.com, Infibeam.com and Indiaplaza.in (Sadly, Amazon does not have full-fledged shipping to India yet). The way I usually search for a book in online bookstores is (was, till now)

1. Go to books.google.com and enter the book title
2. Click on the best match
3. Click on ‘All Sellers’ on the left of the page
4. The Indian bookstores are usually listed towards the bottom. It does not include all stores, and sometimes the prices are not listed. I have to go to each individual site and check them out.

I wanted to collapse these steps into one – a simple script that would accept the name of the book and show results from all these bookstores, with comparative pricing. And the result was this

http://github.com/talonx/book-search

It’s in Ruby, runs from the command line and writes the output to an HTML in the same directory called ‘search.html’. Much needs to be done, like

• Price based listing with the lowest on top
• A web interface for the search
• Add more bookstores – it’s only Flipkart.com, Infibeam.com, Indiaplaza and Bookadda.com right now.

To run the script, type this (you need Ruby 1.8.x, available from http://www.ruby-lang.org/en/downloads/ and the Hpricot HTML parser library, available from http://github.com/whymirror/hpricot)

ruby lib\book-search.rb “<book title (in quotes if it has spaces)>”