Is LINQ leaving Java in the dust?

Call for improvements in the Java world... .NET is M$s beast, and it's hostage to their marketing whims.

period.

Well competition has made Java stronger in general terms. We probobly got annotations thanks to C# and these are clearly a good thing.  Lots of people think generics were only added because of C# to although this isn't actually the case.

LINQ is an interesting conceptually but it turns out to be pretty disappointing I think.  For a start the LINQ to SQL stuff is awful - it can't handle basic things like GROUP BY without using multiple queries or complex workarounds and is horribly inefficient.  Moreover the amount of type inference that is now present in C#  to make LINQ work  undermines one of the key strengths of statically typed languages it seems to me.   You can have, say, var x equals some random expression and no longer know they type of variable x.

One of the key features of Java is that it is easy to read and maintain – which is why so many enterprises bet their business on it.  And we need to stick to that.  So I think Java still has the edge and being relatively steady and cautious is likely to continue to win the race.  Where more "dynamic" language features are required you can mix and match with JRuby, Groovy, Jython or whatever.

So I think .NET is great news for Java – we get to learn from it, improve on it and (hopefully) avoid some of its mistakes.  ARM blocks is a nice example for Java 7 of taking a C# concept and doing it better.

I'm not well versed in LINQ, so maybe someone can answer me this.  Would some existing JDBC, DAO, XML binding/querying, or POJO capabilities fill the voids currently provided by LINQ?

Fortunately that is not an inherent limitation of the language/runtime. You can freely create your own LINQ providers; someone even created LINQ to Amazon:

var query =
  from book in new Amazon.BookSearch()
  where
    book.Title.Contains("ajax") &&
    (book.Publisher == "Manning") &&
    (book.Price <= 25) &&
    (book.Condition == BookCondition.New)
  select book;

And to expand upon nullstyle's comment, even at the language level there are very few breaking changes from C# 2.0 to C# 3.0 (I don't recall exactly; there might even be none). New keywords in C# 3.0 such as 'from' and 'where' are contextual: they are only keywords in certain cases that are all illegal in C# 2.0. So existing code such as 'int from' will port perfectly fine.

As for the inefficiency of LINQ, Rico Mariani has a series of blog posts that suggest a perf impact of 10% or so for his tests. Obviously these will differ in the real world, and I'm sure there are situations where LINQ is too inefficient. But also remember that there are a ton of other situations where performance isn't so critical, and the ease of LINQ (with Intellisense and all) is a significant step forward.

Dont forget the great hibernate criteria builder from grails.

A snippet from the grails reference:

def book = Book.withCriteria(uniqueResult:true) {
    def now = new Date()
    between('releaseDate', now-7, now)
    like('title', '%Groovy%')
}

>From a language feature perspective, C# and LINQ are evolving faster and adding more important features than Java.

Just because it is new, it need not be good and it need not be as important to each and every project. As people start using LINQ, the kinks will start showing up. The downside is that people who will work in depth on LINQ will not be posting to Java groups complaining about the issues they face.  So Java developer's comments will be from an information vaccuum w.r.t .NET/LINQ

Java has generated a healthy, intellectually advanced community with an emphasis on openness and collaboration even while competing. .NET cannot even come close to it. All the MS claims at .NET inception that it will/can run on any platform equally well and will provide an enterprise platform have not been realized. .NET components meant for enterprise collaboration still adher to MS standards rather than globally accepted standards.

It is not addition of new features that attracts people to a language. Some of the important attracting points are : how easy is it to use the language to create an elegant solution to a problem? how easy will it be to maintain/troubleshoot/enhance the solution? how easy will it be to use this solution on multiple platforms? 

FYI, LINQ does handle groupings and even complex query building naturally. There is both a SQL-like syntax and a methods-based syntax. The first is actually just a shorthand for the latter:

var q = from c in db.Customers where c.City=="London" group c by c.ZipCode

is equivalent to

var q = db.Customers.Where(c => c.City=="London").GroupBy(c => c.ZipCode)

Both will return a list of "groups" each with a Key property holding the zipcode. The individual customers for each zipcode can be accessed by enumerating over the group (it's an enumeration of "Customers"). I don't see any complex workarounds. Also (when performed against the database) it will retrieve all of the customers from London at once (building a query with a where clause) and perform the grouping on this set. Can you explain how this could possibly perform better?

You also misunderstand type inference. C# is still very much a statically typed language. When the compiler encounters var s = "Hello World"; it simply infers that the type of s is string just as if you had written string s = "hello World";