Ivan

Java or Python?

In the previous article, I wrote the "graph to csv" converting code in Python, because I thought it would be a suitable tool for the job. A few years ago, I ran a workshop with Keith Braithwaite called "Why Java programmers should learn Python", one of the premisses being that you should choose the correct tool for the job; Java isn't the best language for every problem. Too many Java programmers, particularly many graduates these days whose degree courses are dominated by Java, don't have a wide enough experience of other styles of language. Learning other languages is both good for your brain and often useful.

Python or Java?

There are some problems for which using Python can get you a solution sooner than Java, and the "type safety" of Java and other statically typed languages is often less important than you might think. Today, I thought I'd see what the Python code from the previous article looked like if re-written in Java to see if it would shed any light on these assertions.

Here is a Java version of the code - I've tried to make it reasonable - if you can see any improvements for either version, then please feel free to post them as comments, or post on your own blog and put a link in a comment.

package com.oocode;

import java.io.*;
import java.util.*;

public class Graph2Csv {
	public static void main (String[] args) throws IOException{
		Map<String, Integer> incoming = new HashMap<String, Integer>();
		Map<String, Integer> outgoing = new HashMap<String, Integer>();
		Set<String> nodes = new HashSet<String>();
		BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
		String line = input.readLine();
		while(line != null){
			if(line.contains(" -> ")){
				String[] parts = line.split(" -> ");
				String source = parts[0];
				String destination = parts[1].substring(0,parts[1].length()-1);
				increment(incoming, destination);
				increment(outgoing, source);
				nodes.add(source);
				nodes.add(destination);
			}
			line = input.readLine();
		}
		System.out.println("incoming,node name,outgoing");
		for(String node : nodes){
			System.out.println(num(incoming,node)+","+node+","+num(outgoing,node));
		}
	}

	private static int num(Map<String, Integer> incoming, String node) {
		return incoming.containsKey(node) ? incoming.get(node) : 0;
	}

	private static void increment(Map<String, Integer> map, String node) {
		if(!map.containsKey(node)){
			map.put(node, 0);
		}
		map.put(node, map.get(node) + 1);
	}
}

Conclusions

The Java version is slightly longer and I don't think the static typing adds either to the clarity or the correctness of the code. On the other hand there are some great Java IDEs that do most of the typing for you, so overall I probably made the same number of keystrokes in both cases. In this code, I think the new features of Java 5 made it better than if I'd used an older Java.

The static typing myth.

The type safety, or otherwise, doesn't affect my confidence in either version of the code nearly as much as the fact that neither version has automated tests. I've tested both versions manually with one sample input, and they both look like they work, but if either has a bug, it's not going to be spotted by static type checking, but by testing.

Where TDD fits.

So why didn't I use TDD? Several reasons:
I'm writing it by myself, for myself, rather than as part of a team.
It's a small, standalone, throw away piece of code, not part of a larger project or code that other people are relying on.
I don't care much whether it works for anything other than the one input I wrote it for.
It didn't seem like the sort of code where I'd be quicker doing it TDD.

Other languages?

If you think your favourite language would be just the thing for this problem, then please post a comment containing the code, or a link to the code on your blog.