v
Showing posts with label java. Show all posts
Showing posts with label java. Show all posts

Go vs Java

On the surface Go and Java might seem to have a lot in common. They are both modern C/C++ like languages with garbage collection, supporting object oriented programming.



But beyond that there are quite a lot of differences. I will not highlight so much of Java's strengths compared to Go, as Java has been around for a long time. What is more interesting is why a developer should want to choose Go over Java, given Java's ubiquity, large number of frameworks, tools etc.



First issue is efficiency both with respect to memory usage and performance. Go allows much more low level tuning similar to C. A problem in Java is that all types except primitive types are reference types. That means related data can't be stored in one location. E.g. say we have a Car object with 1 Engine object, 4 Wheel objects etc. All those objects are stored in different locations in memory. While in C or Go you could store all the Car related data as one continuous block of memory. Why is that important? In modern computers CPU's can process data a lot faster than it can be feed to it by regular RAM memory. Due to this frequently used parts of the main RAM memory are stored in a super fast memory called cache. For caches to be efficient related data needs to be close in address space. That is hard to achieve in Java.



An example of this in practice is the distributed version control system git. It is known to be very fast. It is written in C. A Java version JGit was made. It was considerably slower. Handling of memory and lack of unsigned types was some of the important reasons.



Shawn O. Pearce wrote on the git mailinglist:
JGit struggles with not having an efficient way to represent a SHA-1.
C can just say "unsigned char[20]" and have it inline into the
container's memory allocation. A byte[20] in Java will cost an
*additional* 16 bytes of memory, and be slower to access because
the bytes themselves are in a different area of memory from the
container object. We try to work around it by converting from a
byte[20] to 5 ints, but that costs us machine instructions


Like C, Go does allow unsigned types and defining data structures containing other data structures as continuos blocks of memory



Method calls


Before reading this it might be good to read Scott Stanchfield's article on why all java method calls use pass-by-value, and that there is no such thing as pass-by-reference in Java. However as mentioned Java does not support value types for other than primitive types. This causes problems for method calls. One problem is that small objects like a Point might often be faster to copy in a method call, rather than copy their reference which is what Java does.
More importantly perhaps is that value semantics is often easier understood. E.g. it would be natural to assume that Point would be a value type. If I pass a Point object to a function I don't expect my point to be modified by called function. And yet that can easily happen in Java.



Too strong focus on OOP


Since the decision was made that Java would have no free functions (even though static methods in a way is free functions) this has caused the Java designer to come up with very cumbersome syntax to deal with problem that would have been best handled with free functions. Instead of closures Java got nested classes:





myButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.toFront();
}
});



The same thing is achieved a lot less verbosely in Go using closures:


myButton.addActionListener(func(e ActionEvent) {
frame.toFront();
});



Actually the Java version requires even more code, because the ActionListener class needs to be defined somewhere. The function object passed in the Go example is defined right were it is used.



Why Java code end up being considerably more verbose than Go code


When you start building more complicated things this problem starts adding up, causing excessive amounts of code to be needed in Java, while short readable code can be used in Go for the same thing. Consider this example. For a game engine I was writing I used Lua as a script language. Algorithms for planning movement of Non player characters was based on combining different functions describing different behavior. Without a lot of background information the code below is not easy to follow. But bare with me:



local flank = Geometry.makeFlank(player, 10)

local seek = Geometry.makeSeek(player:position())

local combo = Geometry.combineBehavior({0.001,seek}, {1,flank})


flank, seek and combo are functions created by other functions makeFlank, makeSeek etc. The combo function is created by combining the flank and seek functions. Basically each function takes two arguments referred to as s0 and s1, which denotes a orientation and position in space. Below is the code that creates the seek function:



function Geometry.makeSeek(target)

  -- Goodness of trajectory from state 's0' to 's1'

  function seek(s0, s1)

    local p0 = s0:position()

    local p1 = s1:position()

    local d1 = s1:direction()

    

    -- direction to target

    local dir_target = (target-p1):unit()  

    

    -- direction of from current point to next on path

    local dir_path = (p1-p0):unit()   

    return 0.25*(1 + d1*dir_target)*(1 + dir_path * dir_target)

  end

  return seek

end


The details of the code is not important. It is mainly vector operations used to calculate how desirable s1 is with respect to getting the non player character to the goal position target. The candidate s1 position and orientations are produced elsewhere by considering places in space which does not cause collision with other objects etc. The code below shows how we would do this in Java. Since Java does not have closures we have to use classes:



interface Behavior {

  public float goodness(State s0, State s1);

  public void  add(Behavior b, float weight);  

}



class Seek implements Behavior {

  Vec2 target;

  

  public Seek(Vec2 target) {

    this.target = target;

  }

  

  public float goodness(State s0, State s1) {

    Vec2 p0 = s0.position();

    Vec2 p1 = s1.position();

    Vec2 d1 = s1.direction();

        

    // direction to target   

    Vec2 dir_target = (target.minus(p1)).unit();



    // direction of from current point to next on path

    Vec2 dir_path = (p1.minus(p0)).unit();

    return 0.25*(1.0 + d1.dot(dir_target))*(1.0 + dir_path.dot(dir_target));    

  }  

}


The different behaviors will then be combined as follows:


Behavior flank = new Flank(player, 10);

Behavior seek  = new Seek(target);

Behavior combo = new Combo();

combo.add(flank, 1.0);

combo.add(seek, 0.001);


With Go we can write the code more like we did in the dynamic script language Lua.





func makeSeek(target Vec2) func(s0, s1 State) float {
func seek(s0, s1 State) float {
p0 := s0.position();
p1 := s1.position();
d1 := s1.direction();

// direction to target
dir_target := (target.minus(p1)).unit();

// direction of from current point to next on path
dir_path := (p1.minus(p0)).unit();
return 0.25*(1.0 + d1.dot(dir_target))*(1.0 + dir_path.dot(dir_target));
}
return seek;
}



The the different behavior can be combined in much the same way as it was combined in Lua. The last statement can be done in many ways. The code below is valid since Go supports functions with arbitrary number of arguments, but it can't be properly type checked at compile time.





flank := makeFlank(player, 10);
seek := makeSeek(target);
combo := makeCombo(flank, 1.0, seek, 0.001);


For stronger type checking one might want to do something like the code below, which requires defining a struct Elem with a function pointer and float member.




combo := makeCombo(List{Elem{flank, 1.0}, Elem{seek, 0.001}});



Doing something similar to the Java way is also possible:





var funcs FuncList;
funcs.Add(flank, 1.0);
funcs.Add(seek, 0.001);
combo := makeCombo(&funcs);



What should be apparent is how much boilerplate code one has to write when making Java programs:


  1. Every method needs public in front

  2. Type has to be repeated for every argument in method definition.

  3. An interface has to be defined every time we want to simulare combining two functions.

  4. The type of a variable has to be specified every time even though the compiler
    should be able to figure it out based on assignment



The lua code goes on to create new functions:


local eval = Geometry.makeEval(combo, 0.5, 0)

local larger = makeBinary(eval, greaterThan)

Since eval and larger have different function signatures, we would need to create two new interfaces in Java and two class implementing them. Each class will have two methods and some member variables. In contrast the Go solution would only require a total of 4 new functions. No classes or interfaces needs to be created.



Conclusion


As stated earlier the aim of this article was to make the case for Go over Java, so you have to excuse my bias. Java has improved a lot over the years. It used to be extremely verbose for simple things like reading and writing to console. Java 5 improved upon that a great deal. But as these examples show, Java still requires a lot of boilerplate code that doesn't add anything to readability and ability to abstract or reason about the problem you are trying to solve.



I have not touched upon other clear Go advantages like compile time, channels for easing concurrency programming etc. I wanted to show that even without Go's most touted features here is a lot to gain. As new versions of Java comes out new features are added which addresses deficiencies in the language. However the problem is that gradually Java loses some of its original appeal which was that it was a very simple language. Go starts with a small feature set than present Java, perhaps more comparable to the original Java. However the features are better selected so similar kind of expressive power as todays Java can be expressed with far fewer features. I think that is worth somthing

How does Go fit in with the C-family of languages

The C-family of languages is a pretty large group. It could be discussed which language is fit and which don't but I think it's worthwhile including the languages: C, C++, Objective-C, Java, D, C#.



First we got C++ which is trying to extend C into an object oriented language by taking inspiration from Simula. And then came Objective-C which took a more dynamic approach to object oriented programming and tried essentially to embed smalltalk in to C.



Years later we got Java which try to retain the simplicity of Objective-C compare to C++ but give it a more C++ looking syntax. C# tried to create better Java by using the basic ideas of Java but allow more the power of C++.



And right in the middle there comes D and tries to be what C++ should have been, or rather could have been if we could throw the nasty bits out.



A lot has been centered around C++, and I feel Go is about going back to the roots. Go feels a lot more like C:




  • Fairly simple and clean language. Compared to C++ with its huge feature list

  • No inheritance

  • No classes

  • No constructors and destructors. No RAII

  • You just allocate structs. No code is run like on C++. Like C you have to create
    separate initialization functions

  • The standard library is very similar to the C standard library. The way you deal with IO, strings etc, feel much more like C than C++

  • In C++ structs are not just simple structs. They can contain invisible fields you didn't explicitly put there like a vtable. In Go structs are just like C structs. There is no vtable



Unlike Java and C# there is no virtual machine. However like those and unlike C++ if a crash happens you are not left in the cold. You get a stack backtrace on the console. In this respect Go is more in the C++ and D camp than in the Java and C# camp. While Java, C# and D have been about trying to keep the basic ideas from C++ and fix them, Go seems to be more about getting duck typing like found in languages like Python, Ruby into the C-family. Or perhaps one could say the designer skipped the whole class and inheritance thing and looked at all the great stuff done with C++ templates which essentially gives compile time duck typing and decided that was a model on to witch Go's dynamic dispatch should be built on



Benefits of Go's interface type


Go doesn't use inheritance but achieve much the same through interfaces. However interfaces have some benefits over the traditional approach I'd like to highlight.
Below I am showing two code examples illustrating a struct or class B with a corresponding interface name A.


struct A {
virtual int alfa(int a) = 0;
virtual int beta(int b) = 0;
};

struct B : public A {
int alfa(int a);
int beta(int b);
int d;
};

int B::alfa(int a) {
return d + a;
}

int B::beta(int b) {
return d + b + 3;
}



Below is the Go version of the code above:



type A interface {
alfa(a int) int;
beta(b int) int;
}

type B struct {
d int;
}

func (m B) alfa(a int) int {
return m.d + a;
}

func (m B) beta(b int) int {
return m.d + b + 3;
}



In C++ we can call the methods defined on the struct B through its interface A like this:


int x, y;
B b;
b.d = 3;
A *a = &b;

x = a->alfa(1);
y = a->beta(2);



Likewise in Go:


var x, y int;
b := B{3};
var a A = b;
x = a.alfa(1);
y = a.beta(2);



On the surface this looks very similar but there are some notable differences. In C++ the inheritance hierarchy can be arbitrarily deep and so dynamic dispatch is dependent on traversing a vtable on a class to its superclass on so on until the correct implementation is found. In Go there is no inheritance tree, so each method will be accessed as if a single function pointer. In this way Go is more similar to how you typically create some kind of polymorphism in C. In C it is common to define structs with lists of function pointers, which are changed depending on type etc.

The other difference is that if you change the code on Go to this:


var x, y int;
b := B{3};
x = b.alfa(1);
y = b.beta(2);



Then the calls are resolved statically. There is no function pointer lookup, simply because there are no virtual functions in Go. If you call a method on a struct in Go, the compiler knows exactly what method you are calling.

However if you change the code in C++ likewise, you are still making a virtual method call. To be fair in some cases the compiler can figure out the right method call. But the bp pointer could have been passed around and you can't know if it points to a subclass of B or not. With Go, this problem doesn't exist since structs don't have subclasses, making the job much easier for the compiler.


int x, y;
B b;
b.d = 3;
B *bp = &b;

x = bp->alfa(1);
y = bp->beta(2);



Better consistency in type system


Having methods on structs be statically resolved also makes it trivial to support methods on basic types like ints and floats. Something which isn't possible in C++ or Java. The reason that isn't possible is because ints and floats don't have vtables. While in Go you don't need a vtable to have methods, so it is not a problem. In my view this blurs the distinction between basic types like ints and objects which are e.g. in Java two clearly different things. That is a good thing since it creates better consistency. There are less special cases.

How to deal with missing features in Go


A lot of people will probably complain about all those C++ not found in Go. E.g. without constructors and destructors how does one handle resources safely through RAII? Go doesn't really need RAII because it has closures. That is used extensively in e.g. Ruby to get the same benefits.

E.g. here is some code I wrote that opens a file, reads one line at a time and closes the file.



ReadLines("struct-template.h", func(line string) {
fmt.Printf(doStuffWithLine(line));
})



The ReadLines function was implemented like this:



func ReadLines(file_name string, fn func(line string)) {
file, err := os.Open(file_name, os.O_RDONLY, 0);
defer file.Close();
if file == nil {
fmt.Printf("can't open file; err=%s\n", err.String());
os.Exit(1);
}

in := bufio.NewReader(file);
for s, err := in.ReadString('\n'); err != os.EOF; s, err = in.ReadString('\n') {
fn(s)
}
}


Which shows another way to deal with RAII. One can use defer which will call method after defer when function goes out of scope.

Exceptions are not present in Go either but you can mimic the kind of error handling you do with exceptions by using multiple return values were one signals error and use the named return value feature.



func ProcessFile(file_name string) (err os.Error) {
file, err := os.Open(file_name, os.O_RDONLY, 0);
// ...
return;
}



In the simple example above err will automatically be bound to the return value. So if the function didn't handle the error returned in err it will be automatically propagated to the calling function.

First impressions from the Go programming language

I spent the last week or so learning the new programming language release from Google called Go. The first program I written this a simple text processing tool. That is the kind of tools I've previously written in Python and Ruby. I would say that Python is still better suited for this kind of job. However that is mainly due to less functional regular expressions and string libraries found in Go. Although it is unavoidable that when using a statically typed language there is a bit more overhead. In particular with respect to typing.



Compared to regular statically typed languages


However for a statically typed language I can't find anything that can compare. I could write code in a manner to remind me a lot of how it feels to write code and script language. Other languages which I'm familiar with like C++, Objective-C, Java are much more verbose and clunky to use. Those are languages which encourage much more planning and feels better suited for larger applications.



C is a simple language but it lack so much features that it becomes cumbersome to do string processing. No string class and a bit too code spent managing memory.



Compared to Haskell and C#


Of course there are other statically typed languages like Haskell and C#. Now Haskell is probably a more innovative and elegant language then Go. But it is also the language requires much more understanding before it can be used productively. Most developers are not intimate with the functional languages. Especially pure functional languages like Haskell. With Go on the other hand I could use the skills I had developed while using languages like Python, C++ and C. That meant I could be productive quite quickly. With a sharp unafraid to comment because so much has happened without language to last year's and I haven't used in years. I know at least that the C# that I used to use could not compete with Go in ease-of-use.



Compared to Scheme


I have written text processing utility and scheme previously. The whole development process is nicer than most other languages I think. Mainly because of the interactive style development that scheme allows. I could quickly and easily test segments of my code in the interactive shell because everything in scheme is an expression. In this respect go is as cumbersome as any other traditional language. You run test your program one file at a time.



Of course came that same problem as Haskell. You can easily reuse programming skills developed while using C and C++ for many years. It's cumbersome to get used to reading scheme code that takes time to get used to what functions are called and how to print special characters like newline etc.