java

java vs .net: the community

Michel Grootjans — Mon, 31 Aug 2009 16:32:07 GMT

Since the beginning of July, I've been working on a java project. The language is very close to C#, although it has some minor irritating differences, like the lack good generic support, extension methods and closures. The big difference however is not in the language, the tools, the libraries or the utilities. One of the big differences I've seen is the community.

I've been on many projects that have worked exclusively with Microsoft tools, libraries and (god forbid) examples. When the subject is raised of alternatives like an open source ORM or IoC container the response is predictable. It's a raised eyebrow stating clearly that non-MS solutions couldn't possibly be better than libraries like the EF, EntLib and such. Oh, and were you suggesting using anything else than stored procedures for data access?

Your idea won't scale...
Your idea won't perform...
Your idea won't be secure...
Your idea will be buggy...
Have you thought about the maintenance ...

Let's look over the wall now, shall we? If you announce proudly that you're going to work on a java project with hibernate and spring, you get a blank look from your fellow devs. "Duh! Of course! What else?". This best of breed approach took some years to mature but is way ahead of the default .net crowd.

The alt.net movement, the NHibernate mafia and all those alternative folks who don't adhere to the true MSDN way of doing software development are actually very close to this. The difference is that we are there by choice and by experience. The java guys are there, almost by default. This means that the mainstream java dev knows and understands things like IoC, AoP, ORM. He might have forgotten (or doesn't know) why these practices were introduced, but he's been using them daily for some years. Just like we forgot about writing our own compilers and practicing bit shifts to divide by 2.

I think it is our responsibility to enlighten our colleagues, one at a time, for the rest of our professional lives. To try and bridge that gap between alt.net and the mainstream .net development. And ultimately, as a community, help Microsoft on the course it is taking to embrace open source.

Quoting a fellow alt.net colleague I value greatly: How on earth did it ever get this far in our industry for this mindset to be considered alternative?

java vs .net: the language

Michel Grootjans — Sun, 09 Aug 2009 15:43:53 GMT

I'd like to compare the java language to .net as I'm experiencing it. First of all, I'd like to point out that the differences are less than the similarities. Purely seen from a syntax point there really are no differences. Except of course if you're used to .net 3.5. This is irritating at first, but after a while you're just resigned to it. Take the simple properties we're so used to in .net

Compare these two identical pieces of code:
java:

private int counter;

public int getCounter(){
return counter;
}

public void setCounter(int value){
counter = value;
}

.net:

public Counter{get; set;}

I know we didn't have them before .net 3.5, and I realize the dangers of overexposing members, but I love the conciseness of automatic properties. For 7 properties I have 7 lines of code in .net and 70 lines of code in java.

Other things you don't get in java are anonymous methods, so that's no lambdas or LINQ either. No extension methods, so bye bye to simple readability like 1.February(2005). Access modifiers are slightly different but that's just something you accept and move in. All in all it's like having to go back to .net 2.0, which a lot of us have to do from time to time.

However, the thing that the .net platform really nailed, compared to java, is generics. I'm going to illustrate this with an example.
.net:

public T Get<T>(int id)
{
return session.Get<T>(id);
}

This is just not possible in java. For example, you cannot ask the type of T at runtime like this typeof(T)). Generics are just a little syntactical sugar at design time and as a compiler check.
In java, your code will look like this:

<T> public T get(Class<T> clazz, int id){
return (T) session.get(clazz, id);
}

Which makes every caller look like this:

repository.get(Person.class, id);

The cast to T might even fail at runtime if the type returned by session is not of T.

Primitive types are also something to get used to. In .net, you can easily do 1.ToString(). No such luck in java. new Integer(1).toString() is the way to go, since 1 is not an object. To me, java seems a more technical language where it is harder to express intent without giving in too much into technical implementation.

I might sound a little whiny in this post, but all things taken into account, I enjoy this journey into a new, albeit a similar language. I can't wait to get an offer to try Ruby on Rails ;-)

Polyglot programming

Michel Grootjans — Thu, 06 Aug 2009 06:11:59 GMT

For many developers, the one-language notion is a sign of lack of professionalism. This is best exemplified by the Pragmatic Programmers' advice to learn a new language every year. The point here is that programming languages do affect the way you think about programming, and learning new languages can do a lot to help you think about solving problems in different ways.

From Martin Fowler’s at http://martinfowler.com/bliki/OneLanguage.html

I got the opportunity to participate in a java project since July. I’m going to share the pleasure and pain this brings to a .net developer. There are interesting differences in language, conventions, tools, application servers, IDE, … Since all I’m doing in the next weeks and maybe months will be java, you’ll hear that from me.

Too bad Martin fowler ended his paragraph with:

It's important to learn languages that are quite different in order to get the benefit of this. Java and C# are too similar to count.