JAVADOTNET !!!

Hey folks have a look at this link and let me know your views !!!

http://www.halcyonsoft.com/news/javadotnet.asp

Where all this is leading to????

Regards,
Dharmesh Chauhan

"Dharmesh" <dharmeshchauhan@yahoo.com> wrote:
>Hey folks have a look at this link and let me know your views !!!
>
>http://www.halcyonsoft.com/news/javadotnet.asp
>
>Where all this is leading to????
>
>Regards,
>Dharmesh Chauhan
>
>

.NET written in Java? Sounds like some marketing guy forgot to check with
the developers to see if this was even possible. .NET is a superset of Java,
not a subset. There is key functionality missing in Java that would leave
large portions of Java.NET broken. This does not even take into account
the speed differences we are likely to see (unless we are talking converting
.NET byte code into native Java byte code, which is not beyond reason).
But there is still this little matter of pointers...

>.NET written in Java? Sounds like some marketing guy forgot to check with
>the developers to see if this was even possible. .NET is a superset of
Java,
>not a subset.

According to their whitepaper, they're going to simply translate IL bytecode
into JavaVM bytecode and add the support libs. Seems feasable, IL and bytecode
are similar enough. Which just proves again .NET is just one amazing ripoff
of Java. A better than the original ripoff, but a ripoff nonetheless. Embrace
& extend... embrace & extend... rename, copy copy copy.

Scrappy

"Scrappy" <scrappy@spambusters.com> wrote in message
news:3bb4390d@news.devx.com...
>
>
> >.NET written in Java? Sounds like some marketing guy forgot to check
with
> >the developers to see if this was even possible. .NET is a superset of
> Java,
> >not a subset.
>
> According to their whitepaper, they're going to simply translate IL
bytecode
> into JavaVM bytecode and add the support libs. Seems feasable, IL and
bytecode
> are similar enough. Which just proves again .NET is just one amazing
ripoff
> of Java. A better than the original ripoff, but a ripoff nonetheless.
Embrace
> & extend... embrace & extend... rename, copy copy copy.

C# has user defined value types, automatic boxing and unboxing of variables,
delegates/events, attributes, unsafe code, explicit interface
implementation, properties, indexers, foreach, param arrays (like varargs in
C).

Not to mention pointers.

I don't think there are JVM analogs for any of those, so doing a simple
translation would appear to be insufficient.

"Eric Gunnerson" <ericgu_nospam@microsoft.nospam.com> wrote:
>
>"Scrappy" <scrappy@spambusters.com> wrote in message
>news:3bb4390d@news.devx.com...
>>
>>
>>
>> According to their whitepaper, they're going to simply translate IL
>bytecode
>> into JavaVM bytecode and add the support libs. Seems feasable, IL and
>bytecode
>> are similar enough. Which just proves again .NET is just one amazing
>ripoff
>> of Java. A better than the original ripoff, but a ripoff nonetheless.
>Embrace
>> & extend... embrace & extend... rename, copy copy copy.
>
>C# has user defined value types, automatic boxing and unboxing of variables,
>delegates/events, attributes, unsafe code, explicit interface
>implementation, properties, indexers, foreach, param arrays (like varargs
in
>C).
>
>Not to mention pointers.
>
>I don't think there are JVM analogs for any of those, so doing a simple
>translation would appear to be insufficient.
>
>

The things that stick out in my mind are pointers, support for COM, and direct
access to the API. The other things could be simulated, I think, but if
the language expressly prohibits COM support, or pointers, or calling an
API function, then how do you translate it into Java byte code?

.NET is not a rip-off of Java any more than Java was a rip-off of Smalltalk.
Sun did not invent the technologies that exist in Java, they merely borrowed
them from different sources and packaged them together. In doing so, they
made some design decisions that limited the power of Java.

The biggest was WORA, write-once-run-anywhere. Windows people can't use
Windows features, and Unix people can't use Unix features. When it works,
it works everywhere, but you have to give up some pretty significant things
to get WORA, no matter what operating system you run on. I am all for optional-WORA
(make a set of portable libraries that I have the option to use), but don't
force it down my throat. If I want a Windows look and feel, I want to use
the Microsoft libraries.

Another big problem was the lack of support for COM. Sun's version of Java
works great on Windows, but it's like you are working in a vacuum. It doesn't
talk to anything else on the platform, and Sun sued Microsoft to prevent
them from adding COM functionality to Java. Sun supports CORBA instead,
and it is quite difficult to use. I have used J++. The COM extensions do
not interfere with the compliance of the product to Sun's standard for Java
1.1. In fact, if you don't use any MS-specific code, you can run the byte-code
produced by Visual J++ in any of Sun's VM's from version 1.1 on.

A third problem is speed. If you take a look at the MANDELBROT project,
which is somewhere in one of the articles on DevX, you can see a HUGE performance
gain when you manipulate large arrays with pointers instead of with indexes.
When you use indexes, the VM has to check the bounds every single time.
If you are doing simple operations, like converting a number to a color
in a large array, this overhead is significant. If you have ever developed
GUIs with Java, you know the performance can leave a lot to be desired.
With .NET, you have some more ways to tune performance, and since you are
using native Windows calls to begin with (under thin wrappers), the performance
is going to be a lot better than Java even if you never use a pointer.

It's my belief that the Mono project (and whatever secret project that Corel
is working on) has a better chance to bring .NET to the Unix platform than
a pure Java implementation would have. Java is a neat idea, but somewhere
along the way, they got too academic about it. It's one of those languages
that works well in the classroom, but doesn't quite live up to its potential
in the real world.

Can Java integrate with legacy software? No. Not without writing special
C++ code, anyway. Is Java close to the performance of C++? No. Can Java
support new features in the operating system where it runs? No. Are Java
GUIs full featured and fast? No. Is there a standard, mature Java suite
of tools that gives you the power and flexibility that VB users have had
for years? Well, maybe from Borland, maybe.

For C#, despite the fact that it is still in its infancy, the answer to every
one of the questions above is "yes."

The one BIG gotcha with C# is that it currently only runs on Windows, and
I have my doubts about how much of the framework can be translated to run
on Unix. However, I would rather give up that platform independance and
keep all the other good traits of Java, plus the new features that Microsoft
has added to this language.

If you really want platform independance, you can go with Java, or you can
go with a Unix/Windows translation like CygWin. When you want to reach 97%
of the client market, you need a tool that targets Windows exclusively.
If you want the best RAD tools for server development, you go with Windows
2000 on the server and use .NET.

In the past, Windows targeted the client, and some of the design decisions
made toward that end have hurt its acceptance on the server (try to install
two different versions of SQL Server on the same machine, for example).
.NET is going to allow you to separate your apps on the server, and that
will make Windows a lot more attractive for this purpose. We already run
Java as a service on Windows NT servers, and it's rock solid. How much nicer
it will be to have native support for Windows built into the framework!

In my humble opinion, .NET is the single technology that solves almost all
of Microsoft's problems for both client and server development. It gives
you all the good ideas in Java, but it also goes quite a bit further and
cleans up a lot of the language "features" in Java that I did not like, and
even some I had not thought of. It satisfies most of the needs of VB developers
and C++ developers alike (no small feat!), and it appears to me that programming
for Windows just got fun again.

I'm excited about this new technology. I'm looking forward to digging in
and learning everything I can about it. So far, though, I am convinced that
this is not a rip-off of Java. I believe instead that it is an evolutionary
step up from Java, and the promises that Java has not yet fulfilled.