The new
Go Programming language from Google is very interesting because it attempts to bring to the world of compiled languages some of the benefits of the VM based languages, such as garbage collection and dynamic interfaces. I am considering porting one of my projects to Go, but before diving in, I would like to explore Go by writing a few small programs and comparing these with the Java versions.
Without further ado, here is a very simple program that reads a file and outputs lines to the console. First, lets look at the Java version:
package org.majumdar;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class CatFile {
public static void main(String[] args) {
if (args.length == 0) {
usage();
return;
}
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(args[0]));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (Exception e) {
System.err.println("error: " + e.getMessage());
} finally {
close(reader);
}
}
private static void close(Reader reader) {
if (reader == null)
return;
try {
reader.close();
} catch (IOException e) {
}
}
private static void usage() {
System.out.println("usage: CatFile ");
}
}
Now, the same program implemented in Go:
package main
import "fmt"
import "os"
import "bufio"
func usage() {
fmt.Printf("usage: catfile \n")
}
func main() {
if len(os.Args) < 2 {
usage()
return
}
f, err := os.Open(os.Args[1], os.O_RDONLY, 0)
if err != nil {
fmt.Printf("error: %s\n", err)
return
}
defer f.Close()
r := bufio.NewReader(f);
for {
line, err := r.ReadString('\n');
if err == os.EOF {
break
}
if err != nil {
fmt.Printf("error: %s\n", err)
break
}
fmt.Printf("%s", line);
}
}
I am really not sure which one of the two is more readable.
The main differences in the two programs are in how errors are handled, and how resources are cleaned up.
Java offers the finally clause in a try block for cleaning up resources; the Go approach is to allow functions to be scheduled to be invoked when the enclosing function returns via the defer statement. The Go approach doesn't offer much programmer control over when the cleanup should occur. With a try block, the placement of the cleanup code is more under the programmer's control.
Error handling in Java is based upon exception management. Go doesn't have exception management yet; although some form of exception management is planned. The authors of Go seem opposed to exception handling as a mechanism for error handling; their argument is that the try-catch-finally construct makes the code convoluted and that encourages programmers to label ordinary errors as exceptions. My personal preference is for the Java approach because it forces you to handle the error condition. By convention in Java (although the language does not enforce this), error conditions are indicated via exceptions and not by return values.
I think with either approach you can write bad code that doesn't handle errors properly. In Java, you can do this by handling the exception incorrectly; in Go, if you forget to check for an error condition, the program will probably fail at runtime in an unexpected way.
My initial thoughts are that I prefer the try-catch-finally approach to the Go approach, both for error handling and for resource cleanup. Of course the Java approach isn't perfect; for example, the usefulness of checked exceptions is doubtful, and there could be better support for resource cleanup - in fact this is coming in
Java 7.
The programs listed above are trivial, and the comparison is not really fair as the strengths and weaknesses of the two languages are not clear. I am hoping to compare two additional programs - a simple TCP/IP server implementation, and a Lock Scheduler implementation. I have the Java versions of these, and am hoping to write the Go versions in the next few days.
