First I would like to point out that having used (too) many programming
languages over the past 15 years (assembly, visual/basic, pl/1, fortran,
pascal, c, c++, java, c# I decided to give J# a try. I am however no Java
guru as I have not used the language extensively (I have preference for C#).

The company I work for is a Java company, *everything* is done in Java
except no GUI applications (all web based). Since there was a need of such
GUI beast for a small project I decided to try out J#, also mainly because I
find Visual Studio .NET a more productive development environment than the
usual Java IDEs, specially for GUI applications.

Unfortunately I ran into several shortcomings and language deformities when
using J#:

1. The language has no support for enumerations or structures :-(. It amazes
me that Java (the real language, not the J# imitation) only gets these
things included in the language in its 1.5 release (named Java 2 version 5
to confuse people even more).

2. J# uses the somewhat outdated looking set_ and get_ (with underscore) as
setter/getter properties respectively. This instead of the usual
setPropertyName and getPropertyName convention in Java.

3. The two type system is rather confusing *and* annoying to say the least.
The autocomplete throws you a bunch of Java looking methods (getThis,
setThat, equals(), remove()) and .NET methods (This, That, Equals, Remove).

4. The Java libraries (java.*) appear to come without context help because
the autocomplete provides no informational comments with those as it does
with native .NET libraries.

5. A bunch of things simply throw an exception so I wonder why the methods
are available at all. One of those that I remember was the String.Format.

6. While J# is Java syntax (which is nice) it unfortunately uses .jsl as
language extension instead of .java (copyright?). This makes it difficult to
make other tools that look/use/expect .java files. If MS had only not gone
into a fight with Java we would probably be having a better J# today.

While I attempted to create an application as closest to pure Java as
possible, I still had to stick to some .NET libraries because their
equivalent from Java were not available in the provided Java libraries :(,
specially some collections stuff, javax.* and several other.

I think that if the idea was to "lure" as many Java (and hardcore) Java
programmers into the .NET then J# simply falls short. If one could actually
use pure Java sources in .NET with the provided java dlls in .nET and maybe
some wrappers for the missing parts, then it would have been fantastic. But
then again, the cost of developing wrappers for MS.NET libraries (such as
the exceptional regular expressions) is just too much.

So quite frankly if I have to use .NET my choice still falls for C# (yes, I
did a lot of C++ and C as well in years gone past...) but if one is in a
Java company I am afraid J# is not quite up to the job.

Of course it would be greatly welcomed if J# was updated with Java 1.5
things (such as enumerations).

Well, that is all. Just a little bit of feedback# regarding this `new'
language addition to .NET