J#

fuze writes: "It's basically a way for Java developers to migrate their Java apps to .NET.... even provide a 'convenient' migration tool... check it out on MSDN." News.com has a story describing Microsoft's plans to suck Java into .Net, and some commentary saying basically, "No one will use it".

Comments

Of course "no one" will use it

[Osty]

and some commentary saying basically, "No one will use it".

Maybe I missed the point, but it's a migration tool. It's not meant to take the place of Java, or even really compete with Java, other than it makes it possible for developers to take their existing java code and move it to the .NET platform with relatively few changes. This means the old objects are now accessible to all .NET languages (C#, VB, Managed-C++, and all the other marginal languages that have been ported), making it less painful to move over to C#. Until the old modules are reimplemented, they're still available. Moreover, even non-.NET languages will have access to those objects as COM objects, since that's a benefit of the CLR. So if you want to write code in C, or non-managed C++, you can still get at those objects (which you couldn't do before without extra work).

Re:Of course "no one" will use it

[jilles]

Even as a migration tool its use is limited to projects using the partial jdk1.1.4 API MS supports. Basically any serious Java project nowadays is written using the Java 2 (i.e. 1.2 and upwards) API. And if they are written to the 1.1 API they likely use jdk1.1.8 rather than 1.1.4.

So basically it is a migration tool for J++ applications. Considering that is a MS product, it makes you wonder if this is the best MS can pull of after all the sole reason migration is needed is because MS decided to drop Java support (so they already screwed you once).

And even for J++ it is limited since it only allows you to compile source code, you lose information stored in e.g. forms, project files and so on. In addition, Java objects tend to be closesely tied to the Java API and reusing them basically means you are using the Java. So you might as well go for the real thing (including richer API, better performance and so on) and use the com bridge to communicate with the objects.

In any case, if this is just a migration tool, MS is going through a hell of a lot of trouble to present it as a Java alternative.

Some advise to people considering to use it:
- After 'migration' it is still Java code you are using. It won't be much faster and you will still have to maintain it.
- MS is not very Java friendly, they might drop support for the migration tool at their convenience. The long term strategy is C# (if it ever takes of), not J#.
- Migration to real Java is probably much easier unless you heavily rely on MS specific APIs
- There are ways of letting Java objects talk to COM objects (and consequently also .Net objects) that don't require recompilation.

Re:Of course "no one" will use it

[Carnage4Life]

In any case, if this is just a migration tool, MS is going through a hell of a lot of trouble to present it as a Java alternative.

Where and how has MSFT presented this as anything more than a migration tool? From the MSDN Visual J# page.

Visual J# .NET provides the easiest transition for Java developers into the world of XML Web services and dramatically improves the interoperability of Java-language programs with existing software written in a variety of other programming languages. Visual J# .NET enables Microsoft Visual J++ customers and other Java-language programmers to take advantage of existing investments in skills and code while fully exploiting the Microsoft platform today and into the future.

Visual J# .NET includes technology that enables customers to migrate Java-language investments to the .NET Framework. Existing applications developed with Visual J++ can be easily modified to execute on the .NET Framework, interoperate with other .NET-based languages and applications, and incorporate new .NET functionality such as ASP.NET, ADO.NET, and Windows Forms. Further, developers can use it to create entirely new .NET-based applications.

This is rather unfortunate since it looks like no one is working on a port of the Java language to .NET especially since the claims that Rational is working on a Java for .NET seem to be unfounded considering there is no mention of it anywhere on their site. That's a shame, since I feel the combo of Java and the CLR would make a very killer combination.

Evil Ploy Alert!

[Gnight]

And in other news Microsoft has publicly announced plans for the following projects:

1. GNU#.net (RMS finally gave up and was hired my MS)

2. OSX.net (Steve jobs has now finally ground his teeth all the way off)

3. .org (DON'T even ask what it is)

Well

[MxTxL]

There is always the fact that Java is being natively excluded from Win XP. The conspiracy theorists among us would probably argue that this move is to have the J# initiative and thus the .NET initiative to be more successful and quash everyone else.

Re:Well

[sql*kitten]

There is always the fact that Java is being natively excluded from Win XP.

Uhh, hello? Didn't Sun just sue Microsoft? Aren't a bunch of other companies, including AOL and Real arguing with MS right now over bundling of products? It's not as if MS are saying that you can't run Java, they're just saying that it's a piece of third party software, you have to install it yourself, just like you have to install, say, WinAmp if you want it, or Photoshop.

Sorry, but I think Microsoft are doing the right thing here, or at least they are doing the least-worst thing.

Isn't it all supposed to be about choice? A world where Java is the only language (and we all know how responsive Sun have been to the wishes of the community, can you say ECMA standard?) would be a poorer world than one where Java/J2EE and C#/.NET have to compete on features and quality.

There's one way out of this for the Anti-Microsoft camp: get Java to be like C, SQL and FORTRAN, an ANSI standard. Until we see that, this battle isn't one for the engineers, it's marketeer vs marketeer.

Boycott D Flat

[Anonymous Coward]

I will never use D flat.

According to CNN, Microsoft's B flat is the programming language of choice of Osama bin Laden.

GTK#

[Majix]

Spotted this on the GNOME Weekly Summary:

Hello World in C# using the GTK toolkit :)
The syntax does look pretty clean.

It's not quite up to Java GNOME functionality yet, which is now compilable to native binaries, with gcc3 (For those of us who couldn't care less about platform independence but really like Java as a modern language). More choice is always good however.

Re:GTK#

[Lars Arvestad]

Bah, that ain't clean. This is clean:

echo 'Hello world!'

or if you are into elisp:

(message "Hello world!")

For further discussion, I refer you to the (almost) definitive resource on hello-world programming: Hello World! Thank you.

Re:.NET

[Osty]

I still don't after all this time understand exactly what is the point, or rather the benefit of .NET. I've even had the on-campus M$ rep try to explain it to me, all to no avail.

Check out http://www.microsoft.com/net/whatis.asp for an explanation on what .NET is. Take special note that .NET is not the Common Language Runtime, or the C# programming language, or Visual Studio.NET, or Visual Basic.NET, or the SOAP Toolkit, etc. Those are part of the .NET Framework, or the platform that enables you to build .NET services (since .NET is all about XML-based web services).

As far as what benefit you gain, that's twofold. With the .NET Framework, specifically the Common Language Runtime, you gain the ability to easily work with objects across many different languages, without any grunt work to get in the way (such as making sure you write everything as a COM object, and doing your own reference counting, and making sure you initialize and deinitialize COM). And since all the objects from code targetting the CLR are exposed as COM objects, you can even use them from languages that don't support the runtime, such as C, non-Managed C++ (aka, C++), VB6, Delphi, or any other language that supports COM objects.

.NET itself is more about server-server communication over the web. By passing around SOAP messages (via SSL, when security is an issue), you can implement anything from alerting users that they're being out-bid on something like eBay, to providing stock quotes more easily (without having to "scrape" html pages), to offering choice hotel information when you book a plane flight, and so on. Yes, all of that can be done now, but .NET aims to make it much easier. The potential for XML-based web services is pretty much bounded only by your (editorial your) imagination, and since it's all based on standard communication methods (HTTP(s), SOAP), you won't have to define new protocols for passing data around each time you want to do something new.

There are similar things out there, such as XML-RPC, but they don't focus as much on providing web services as .NET does.

This is good news...

[Jotham]

The CLR (Common Language Runtime) is a great idea and is in my opinion the next generation of programming tools. ie. it doesn't matter what language you prefer or what language library X is written in if they go through the CLR you can use it.

The ability to write in your favorite language C#, C++, VB, JScript, etc and now Java is a huge improvement over locking a project into one language only and missing out on all the other shared libraries because your project is in Java or Objective-C or Python etc.

Unfortunately in removing one lock, microsoft has added another (to their OS). What I'd love to see is a Common Runtime for Linux... unfortunately all I see is people dismissing it or complaining because its Microsoft.

Re:This is good news...

[Lars Arvestad]

The ability to write in your favorite language C#, C++, VB, JScript, etc and now Java is a huge improvement over locking a project into one language only and missing out on all the other shared libraries because your project is in Java or Objective-C or Python etc.

I'll admit that I have never done any large scale programming, but this statement about language lock-in seems entirely false to me. I have done programming for research purposes and combined C with C++, C with Scheme, and used tools mostly written in C call Fortran libraries. I have seen and used examples of Perl and Python programs accessing common C libraries.

Where is the lock-in?

Re:This is good news...

[King Of Chat]

Is it a good idea? I can see that it would be - if it weren't for the small point that it only runs on Windows. If you're only going single platform then surely you'd be better off going native code and just using the same compiler back-end for all languages (as Borland do for Delphi and C++ Builder - which both run like sh*t off a shiny shovel).

Sure they say they can build a CLR for other platforms, but I'll believe it when I see it.

Of course, if they didn't have this CLR, then they couldn't make the claim that they were going multi-platform so it looks like they just found a way to slow down your Windows code for no good reason.

Re:This is good news...

[Osty]

Is it a good idea? I can see that it would be - if it weren't for the small point that it only runs on Windows. If you're only going single platform then surely you'd be better off going native code and just using the same compiler back-end for all languages (as Borland do for Delphi and C++ Builder - which both run like sh*t off a shiny shovel).

For now, yes, the .NET framework is only available for Windows. However, Microsoft has committed to providing a reference implementation for the *BSDs (FreeBSD, I believe), and other projects like Mono have sprung up to bring an implementation to Linux and other unix-like operating systems. Since Microsoft has submitted both the CLR and C# to ECMA for standardization (say what you will about ECMA, but at least it's a standards body), anybody can write their own implementation. Sun's backed out several times on submitting Java to ECMA.

Of course, if they didn't have this CLR, then they couldn't make the claim that they were going multi-platform so it looks like they just found a way to slow down your Windows code for no good reason.

That would be true, if it were the case that CLR bytecode only ran under the VM. However, that's not the case at all. The CLR has the ability to compile its bytecode down to native code for whatever machine you're on. Most likely the way this will happen is that CLR bytecode will be "shipped" (in a box, or as a download), and as part of the installation that bytecode will get compiled to your platform. What that means is that, taking a Windows-only view for a moment, when you buy Office.NET (just as an example -- I don't know whether Office.NET will be targetting the CLR or not), it won't matter whether you're running on a 32-bit x86-based system, or on a 64-bit iTanium (or whatever AMD's 64-bit chip is called), the same version will run on both. And with native speed, because after installation, you'll be running native code. Obviously, it's developer choice whether or not to compile down to native code, but that's the point -- the choice exists. And given full CLR implementations on other platforms, I don't see any reason why pure CLR bytecode wouldn't be perfectly cross platform, even to the point of compiling down to native code and running as a native app on your chosen system. Perhaps this is how we'll eventually see IE, Office, etc on Linux? (Through the efforts of Mono)

Re:This is good news...

[Domini]

I don't think People will use J#, not because it is MS, but because I think people will rather move to C#. (Just my opinion there...)

.NET is so far as I can tell something good... Microsoft has done something right. Don't mock it, it does happen sometimes! I just can't stop feeling nervous...

I'm a Python advocate, and I like the .NET initiative. It may not be all unique ideas, but finally someone if driving it and formalising the processes to get it to a standard.

MS is not oficially giving up on COM, but .NET will certainly downplay it a lot. (Which is also a good thing.)

Initial reactions

[Rogerborg]

Microsoft are still strongly implying (at least) that Visual J++ is Java. Uh, wait, didn't a court tell you to stop doing that?

• "Visual J# .NET enables Microsoft Visual J++ customers and other Java-language programmers"

Tsk, tsk, Bill. There's no "other" in that sentence.

The focus seems to be on J++ developers, not Java developers. But personally, I will use J# iff:

• It compiles Java completely and correctly.
• It compiles to a native .NET executable that gives a significant speed advantage over VM bytecode on a .NET platform.
• I have to make exactly zero changes to my Java to have it compile to both VM bytecodes and to a .NET executable.

Basically, I can live with loading J# and hitting compile once for each of my Java projects. If it's any more hassle than that, I agree, it's not worth my while.

However, I'm keeping an open mind. Microsoft's decision to not include a JVM in WinXP concerns me, as does the increasing size of the Sun VM. I love Java and want to keep using it purely, but I'm not going to cut off my nose to spite my face. If Microsoft and Sun collude to make it hard to use Java and easy to use J#, I could be swayed. I hope not though.

Re:Initial reactions

[0xA]

The focus seems to be on J++ developers, not Java developers. But personally, I will use J# iff:

It compiles Java completely and correctly.

It compiles to a native .NET executable that gives a significant speed advantage over VM bytecode on a .NET platform.

I have to make exactly zero changes to my Java to have it compile to both VM bytecodes and to a .NET executable.

So basically what you're saying is that there's no way in hell you're going to use J#?

I agree with the points you made 100% but I don't think its' going to happen.

Re:Initial reactions

[Milo]

"Visual J# .NET enables Microsoft Visual J++ customers and other Java-language programmers"

Tsk, tsk, Bill. There's no "other" in that sentence.

Actually, the is an other. They are only referring to the java language, not the java platform. Like has been done for a large number of other languages, the .Net platform will allow compiling of java code to their intermediate language (IL), which will then run in the .Net common language runtime (CLR).

Basically, instead of compiling to java bytecode and running in a JVM, it will compile to IL and run on the CLR.

If you want cross platform support, this sucks. However, if you want to take your java app and get the best bang for your buck on the windows platform, using the CLR will probably provide better performance than a JVM, because the writer of the OS writes the CLR.

So, even if you don't currently develop with Visual J++, if you're going to release a java app for Windows.Net, you might want to think about using the MS compiler, if not the IDE.

Re:Initial reactions

[TomV]

Microsoft's decision to not include a JVM in WinXP concerns me

This seems a reasonable point to attach the following question, to which I cannot come up with a reasonmable answer right now...

How can it be evil for MS to INCLUDE a browser / media player / etc in XP, viciously anticompetitive and so forth, ...

and...

simultaneously evil for MS to EXCLUDE a JVM in XP?

If anyone can supply a reasonably coherent answer to this, I'd be really pleased to see it :-)

TomV

Re:Initial reactions

[GreyPoopon]

How can it be evil for MS to INCLUDE a browser / media player / etc in XP, viciously anticompetitive and so forth, ...

and...

simultaneously evil for MS to EXCLUDE a JVM in XP?

Actually, there's a pretty simple answer to this. Both of these actions kill competition.

Microsoft owns the browser, media player, etc that it bundles with XP, so they can eliminate competition by including them and making them impossible or extremely difficult to remove. The problem is that most people will not know enough or be motivated enough to switch to a competing product. So, since Microsoft owns the OS, they can be reasonably certain that people will use their integrated browser, media player, etc. By doing this, they can also be reasonably certain that companies who develop content for these products will be inclined to purchase Microsoft products to aid in the development of that content.

Java is a slightly different story. Microsoft does not own the Java technology. They have to play ball with Sun in order to use it. They have to follow Sun's rules. But more importantly, there is quite a bit of competition for Java development environments. Supplying a JDK or JVM with their OS does not in any way motivate developers to use their development environment, unless they can add proprietary extensions or other changes to the language to make their development products attractive. They attempted this with J++ and have been told they can't. So, since they can't make any money from J++, they decide to develop their own environments and languages, and bundle THOSE with their OS instead of Java. That effectively kills competition by sending a message to developers: "Do you want your application to run without hassle on 95% of desktop systems? Use .NET."

Try and remember that these tactics are only questionable because Microsoft has a MONOPOLY. That is the defining factor. Otherwise, they'd be considered good business practices. If Microsoft had only 30% of the desktop market, bundling the browser, media player, .NET technology and other things with XP would only help them to be certain that most of that 30% would be using their technology and their tools. They would be forced to make their tools operate on other desktop environments in order to increase market share. This would put them on an even playing field with their competitors. However, since they currently dominate the desktop market, the game is way too easy for them. Tricks like inclusion / exclusion just help cement their monopoly in other areas of the market. It is illegal to use a monopoly in one market segment to stifle competition and increase market share in other segments. Both of these tricks accomplish this. You really have to look at the end results.

Re:Initial reactions

[mroshea]

"The focus seems to be on J++ developers, not Java developers. But personally, I will use J# iff:

* I have to make exactly zero changes to my Java to have it compile to both VM bytecodes and to a .NET executable. "

That won't be possible. The .NET Framework Base Class APIs available through J# are not based on the J2SE APIs although in places the object models look similiar. For example, both have a base Object class from which all other classes inherit but even the APIs on this class are different. All of the auxiliary APIs for IO, Math, Collections, Security, Reflection also differ in too many ways to describe. Perhaps they will provide tools to automate the conversion of source from one API set to the other but don't expect it to be automatic.

That's not to say that the .NET Framework is worse than the J2SE APIs or vice versa - they are just different.

All Microsoft are facilitating with J# is allowing developers who know the Java language syntax to develop .NET apps using the .NET Framework APIs. Java the platform (the JS2E APIs and VM) are not part of the deal.

Re:Initial reactions

[sheldon]

If Microsoft includes a Java Virtual Machine within Windows, it kills the potential competition in the market there for JVMs.

Obviously if Microsoft includes a JVM, then no users will go out and bother to download the JVM from Sun, IBM or Acme Computing. You already state that there is quite a bit of competition in the Java market, so obviously with Microsoft including this old outdated JVM it stifles the ability for that market to move forward.

I'm sorry, but the original poster was correct. Your argument is horribly inconsistent and flawed. If it is evil for Microsoft to include Internet Explorer, it is equally as evil to include a JVM.

You really can't have it both ways. If you get to say what goes in Microsoft's products, then I feel it is my moral duty to say what goes into Linux distributions.

And I hereby declare that bundling lilo into RedHat is evil because it kills competition in the boot manager market. RedHat's purpose is obviously to damage the market that System Commander operates within, without providing them adequate compensation.

Re:Initial reactions

[spongman]

actually J# does alot more than you think: it includes .NET implementations of the (albeit outdated) Java APIs. for example, the following namspaces (corresponding to java packages) appear in the library:

• java.applet
• java.awt
• java.beans
• java.io
• java.lang
• java.math
• java.net
• java.security
• java.sql
• java.text
• java.util

along with a bunch of 'com.ms.*' packages.

I just compiled a couple of small java applications one (TCPMapper) uses sockets and another was a multi-threaded AWT app. Both compiled without changes into small .EXEs (11K & 25K respectively) and ran fine.

Also, I downloaded PC Labs' JMark1.1 which comes only as .class files (no source) and used J#'s jbimp.exe which converts .class files to a .NET assembly (.EXE/.DLL) - very cool. It ran fine also, and gave reasonable results, although MS's JVM was quicker overall. Still some room for improvement on performance there, but given that the JVM's been around for a while, and both J# and the .NET system it uses are still in beta, it's pretty imprssive nonetheless.

Re:Corporate Thinking or Public Service?

[Moridineas]

Are programs like Wine and VMWAre really taking away from MS's desktop share?

Most of the people that would ever run these would be running *nix/*bsd already. In fact you need to one a copy of Windows for VMware, and it prolly helps for Wine.

And besides, as long as people are running windows apps, developers will continue to target windows. This is similar to the dilemna IBM faced with OS/2 Win32 emu stuff. It was so good (ANY win3.1 app could run in native OS/2) that very few native OS/2 apps were ever made.

Scott

so Java is ...

[quick_dry_3]

even more portable than before?!

J# vs. C#

[MrBlack]

Java and C# are already pretty similar...how am I going to know at a glance which one I'm looking at. Surely the differences between the two (which are subtle, but certainly there) will catch people up all the time.

Re:J# vs. C#

[BitwizeGHC]

XML Comments? What are they smoking? They must be really intoxicated with XML hype over there. Pretty soon Ballmer'll start mandating that all meetings be conducted in an XML variant. Instead of "This meeting is adjourned" you'd hear "Open bracket slash meeting close bracket!"

Re:J# vs. C#

[Mindbridge]

Languages do matter. Certain language features can significantly improve productivity and the quality of the code. Especially in respect to team environments and large projects.

Case in point: Java has checked exceptions, C# does not. The extensive use of exceptions in large projects is typically a significant source of program instability if you do not have the benefit of compile time checking. This is a very simple language feature, but it makes a major programming mechanism from one that requires caution to one that is ubiquitously useful.

Even carefuly selected syntactic sugar can make the code clearer and simple and cause some boost in productivity as a result (e.g. 'foreach' in C#). Of course, badly selected syntactic sugar can have just the opposite effect -- massive confusion. I find it astonishing that in C# you can never be sure what the expression 'a.b = c' does (assignment or function call). Are the several characters that are saved from 'a.setb(c)' worth the amount of programming time that would almost certainly be lost due to misunderstandings? I very much doubt it. (although anyone who has public members probably deserves that)

So languages do matter, and even the small differences can have a big impact on the stability and maintainability of a large program.

Re:.NET

[jonnosan]

This is the perspective of someone with a couple of years experience in "enterprise" development, i.e. apps that have a UI that is probably a bunch of data entry forms, a database at the back, and a "business logic" layer that looks at the input, massages it, acts on it, sends it to the db, etc.

These sorts of apps are not very sexy compared to writting an OS or a game or something, but they're what 90% of developers in the world work on.

A typical enterprise app will need to have a bunch of different front ends (e.g. web interface, a simple gui for data entry clerks, a bunch of reports) etc. Also, you'll have lots of people working on different bits and peices, and lots of changes going on all the time, e.g.say a sales manager comes up with a new promotional scheme that gives volume discounts you need to update your app to handle the calculations.

So with all these people working on apps that are evolving rapidly, you can end up with spaghettii code pretty quickly. If you want to have something that's maintainable, you really need to use OO and come up with an object model that seperates the user interface, the business rules, and the data layer.

The problem with this is that it is hard to have an object model that works well over distributed systems, and hard to have an object model that can be used by developers using multiple languages.

COM is a start to allowing objects to be used from multiple objects, and over distributed systems, but it has limitations, largely related to the fact that different languages don't have the same idea of basic data types.

.NET solves this by making all languages share a virtual machine that defines a bunch of basic data types, and a base 'object'. This means that any object created in one .NET language can be accessed by another .NET language.

So you can have a your web front end people write ASP (VB) pages that interact with business logic written in c# without having to compromise your object model.

Re:Corporate Thinking or Public Service?

[sql*kitten]

I ask the question :- if you were a director/shareholder of a company like Microsoft would you

a) play to your strength and leverage your current market domination and try to eliminate competing standards while creating new "standards", eg .NET that ultimately play back into your desktop Windows (XP) market, or

b)go open source, support Java, employ open standards, go cross platform, etc etc and risk losing any market dominance you have now?


Legally, you would have no choice at all. If a director fails to act in the interest of shareholders, the penalty can be a jail sentence and a ban from ever running a company again, at least under UK law. Yes, that's right, you can go to jail for doing the "right thing". Unless you could prove that it was in the best interest of shareholders - who will tear you apart if you miss your quarterly earnings target - there is no option for you but (a).

The reason corporations put profit before everything else is because the law - created by the governments, who represent the taxpayer - have decreed that they must do so. It would be a little hypocritical to criticize a thing for acting in accordance with its nature.

What does it DO?

[macpeep]

Yeah yeah, J#, GNU# ha-ha. We've heard all the jokes and M$ spelling already. Now can someone please explain what J# actually DOES cause the Microsoft site doesn't seem to explain this. Does it operate on compiled bytecode? Does it translate the source code? To what language? C#? The site says that J# "improves the interoperability of Java-language programs with existing software written in a variety of other programming languages". That doesn't sound like just a migration tool to me. Also if it's just a migration tool, the name is pretty misleading since most people assume it's a language (C#, J#, ...)

Later in the "article", it says that J# INCLUDES technology that enables customers to migrate Java stuff to .NET. But I still get the impression that J# is more than just a migration tool.

Having said all this, I don't see that there would be a big need for this.. Most Java developers and companies using Java are using Sun's VM's and technology and won't be migrating to .NET. Most Visual J++ developers were writing Windows-only, client apps - not server side stuff, so I don't see that they would benefit from this either.

Can someone enlighten me?

Re:What does it DO?

[Zico]

J# lets J++ and most Java developers get in on the .NET action. I say most because the version of Java supported by J# is 1.1. And yes, almost all of the hardcore Java developers are using Java 2 now (as they should be), but there's a large percentage of people still coding to the 1.1.x standard, either because they're still doing applets or because they haven't gotten all that serious about Java development.

The Java code doesn't compile to Java bytecode, but instead to CIL, the Common Intermediary Language (formerly MSIL), so that it can run under the Common Language Runtime, just like C#, VB.NET, JS.NET, Perl.NET, Python.NET, etc. It improves the interoperability because I can then take any Java class and use it like it was any other .NET class. Someone write a sweet applet or chat server or ssh client in Java? Cool, I'll take the .java files and compile them to CIL and now I can use the classes directly in my C# programs, extend them, whatever, just like they were C# files. And vice versa, and with any other .NET language.

Personally, I know it's not officially a migration tool, but I view this as more of a migration tool than anything else. Otherwise, you're going to be left using an older version of Java. It's important to note, though, that Microsoft isn't alone in this Java on .NET thing, so I think a lot of people need to calm down about it. What I mean is that other companies are going to be putting the Java language on .NET, just like other languages are being ported to .NET. And these companies will be using Java 2. So, I don't think that anybody should dismiss this concept just because Microsoft itself is only supporting Java 1.1 with it, because it's going to happen. For now, though, it is an important release so that Microsoft can support their Visual J++ users. As for a true migration tool, that's the JUMP tool (Java User Migration Path to .NET), which is coming out later, and from everything I've heard, will be for migrating Java 2 as well Java 1.1 code, probably to C#.

That said, I think there's a good benefit to it. A lot of Java programmers just flat out like the language, the whole WORA jive never mattered to them. It's really not a huge event, though, it's just one more language coming to .NET. One interesting thing, though, is that .NET programs run quite a bit faster under Windows than Java programs do. So, once a current Java is on .NET (and probably also a little bit with the older Java available via J#), Java on .NET is going to be pretty tempting to people wanting to squeeze better performance out of Java, especially if they really don't have much interest in non-Windows platforms. Interestingly enough, Microsoft could parlay this into its advantage in that .NET platform could ironically enough become the best platform on which to run Java programs. (Based on the few ports I've played around with in J# today, my really tiny code ( < ~30 LoC or so) runs faster in the 1.3.0-C JVM, while the larger stuff is running faster in the .NET CLR.)

Anyway, I really like the move, I'm glad somebody has finally put something out there which separates the Java language (which is pretty nice IMO) from the whole Sun vision of Java as a platform. Hope this helped...

Re:Corporate Thinking or Public Service?

[Zico]

Well, I understand that as a self-described "rabid Slashdotter," this might be news to you, but your entire premise is pretty wacked.

- your grip on the server market appears to be slipping

Hate to break it to you, but Microsoft's server market share has never gone down since NT first came out.

great companies such as google.com are proving that you can grab web market share fairly quickly with a better product

Well, seeing how Microsoft/MSN gets around 7 times the number of unique visitors that Google gets, and that they hang around the site around 25 times longer than Google's, you tell me how concerned they are.

technologies such as Linux, VM Ware, WINE and Java are threatening to nibble away your desktop market

They are? Funny that Microsoft's desktop market share, just like its server market share, went up over the past year. Guess they better be on the lookout for OS/2 and Amiga, too.

having some spectacular white elephants such as MSN on record

See above about MSN.

I think that the shareholders of Microsoft would be pretty relieved that it's one of the best performing stocks this year. Oh, and they're probably happy as Hell that they don't listen to Slashdot hype, otherwise they might've traded all their Microsoft shares for stock in VA Linux, Red Hat, and Sun, thus watching their kids' college funds go *poof*!

Migration for Visual J++ developers

[samirkseth]

I believe this is merely Microsoft's solution to provide a migration path for the Visual J++ developers who have been left high-and-dry since the discontinuation of that product. The references to "other Java language" is just a red herring.

It would not make sense to suck "Java" into the .NET platform, when a language so close to Java (C#) has been expressly created for that purpose.

It's about debugging.

[Otis_INF]

Ok, with COM and COM+, you could f.e. use a component written in C++ in VB or vice versa. However, when you're debugging your VB application and the error you receive is inside that C++ component, you're out of luck. (You can, in a way, compiled VB stuff in VC++, but it's a nightmare). With the CLR, you're not. You can step into that C++ component directly from your VB code. And if that C++ component uses a serie of C# components, no problem there.

The main advantage is here: development is faster in a team where every programmer can use the language he/she likes the most. Even if you're not familiar with C++ in the example above, you can pinpoint the developer who wrote the component that in line xyz his code bugs when you supply it the parameters your VB application passed to it. File the bug your bugtracker system et viola. The C++ developer can even use your VB application to debug his own code, without having to write a testapp in C++ that will supply EXACTLY the same inputparameters.
With COM and COM+ you don't have that.

Re:It's about debugging.

[MillionthMonkey]

The main advantage is here: development is faster in a team where every programmer can use the language he/she likes the most.

.NET people love to say this and it makes me laugh. It's so naive. It's like saying that development is going to be faster once you let all the programmers use the bracing and indent styles that they personally prefer.

"Welcome to the team. I wrote the C# parts of the application. John writes in Eiffel, Paul here likes C++ and uses that, and George over there prefers to use VB because he really likes its type system. You'll be sitting at this desk here, and you'll be in charge of the code that Ringo was working on before he left. None of us really knows how it works because we don't know INTERCAL."

I submit that development is faster in a team where all the developers are using the same language and can at least read each other's code. I work with a bunch of guys on a successful Java-based scientific application. We have to go into each other's code and change things all the time. They're all smart guys- and I have real respect for them, because 1.they're very productive and 2.might be reading this. But they're physics PhDs with no formal CS training, and they write fiendishly clever code that is really hard to read. The best of them writes huge amounts of complex-flow infrastructure that is riddled with "historical" stuff that gets coded around everywhere. Another one writes impenetrable clockwork mechanisms. A third delights in purposeful obfuscation (so he handles the licensing validation code). If any of them were on a plane that got hijacked, the company would be in serious trouble! Their code is pretty hard to read, but I can usually figure it out because I'm used to deciphering uncommented Java. The mere idea of these guys running around writing different parts of the code in their favorite languages makes me shudder. (The clockwork mechanism guy likes OCaml, for example, and naturally the obfuscator would prefer C.)

The idea of everyone coding in their favorite language only works well if each developer is going to be entirely responsible for his/her own domains of the code, and nobody will need to cross boundaries too often into other domains. If there is more coupling than that, then soon everyone has to learn everyone else's favorite language. This sets up a language holy war. It also makes it difficult to reassign responsibility for parts of the code because now you have to worry about who knows what language.
This might be useful for more loosely coupled development teams. As in, your project in language X could really use this nice new library that someone wrote in language Y. But you can already use language bindings that are already available for that purpose. If you encounter a bug in a library do you normally debug it yourself? If you're like most people, you either send a nasty email to the guy who sold you a buggy library, or you dig through a mailing list archive to find out what the problem is. If you use a debugger at all, it's to get a general idea of what's going on so that you might get an idea for a workaround to put in your client X code. But you can usually just pull that off if you just have the source! It is kind of neat that you can step into a different language, but it's unlikely to be of much critical importance for reasons that have more to do with humans than computers.

Also...

[Otis_INF]

(sorry for the separate message, but if I put this text in the other message I replied, Slash will time out. Please fix this)

Also, you don't have to register your components anymore. With COM/COM+ components, you have to register them in the registry. This is not a problem, but updating registered components is. In n-tier webapps, where the webserver has loaded the components in its core process (or separate process, if you've tuned it that way), you can't overwrite the dll and re-register the new components, because the dll is locked (which makes sense). Witb the CLR, just dump the dll in the dir and off you go. Updated the dll? overwrite it. The CLR will automatically see that the file is updated, and reload the components into memory.

Re:Corporate Thinking or Public Service?

[Anonymous Coward]

>Well, seeing how Microsoft/MSN gets around 7 times the number of unique visitors that Google gets, and that they hang around the site around 25 times longer than Google's, you tell me how concerned they are.

considering that google is a search engine , and msn is just a mess, I would consider your statement to be a glowing endorsement of google. People get what they need 5 times faster!.

And it's true because you said it!.

Too many languages

[StrawberryFrog]

You are right in that the advantage of CLR is that it is a level of integration better than COM, which is itself a level of integration better than the flat-DLL/library API function call interfaces that the original poster was happy with.

but

development is faster in a team where every programmer can use the language he/she likes the most.

Is it really? It hasn't been tested in the real world yet. IMHO, that's not a team, that's a collection of individuals going off in all directions. IMHO a project that's written in 5 different styles in 5 different languages would be a 'mare to maintain, extend or even to complete.

I'm all for picking the right tool for the job, and writing the project in the best language (or two) for the job, but in a medium-to-large project, it is important that code is collectively owned, well-integrated and understood by more than one person.

How will that work if everyone codes in thier pet language? Do you now expect Joe VB to learn not one but ten new lanuages? Or to not understand 4/5 of the project he is working on, even with the source? Language choice should not be made on personal whim, but as a group decision on language suitablity.

I see this as having the potential for of a whole new level of code impenetrability.

Re:.NET

[pubjames]

At the end of the day, if can happily do everything I need to do with one company, why not stick with them?

There's a simple answer to that - because you then give the company the power to screw you. The question is not sticking to one company, but choosing a partner that uses open standards which do not lock you in.

Microsoft is beinging to turn the screws by increasing their licencing fees, which at least in the UK is upsetting an awful lot of big organisations. They are only able to do this because of their 'vendor lock-in'.

Re:More importantly :how to pronounce J# ?

[muffel]

In German, '-is' is appended to the letter for # (and '-es' for flat).

So: Jis

which I will comment no further.

Why?

[Dexter77]

Could someone explain to me why would I start to code J#?

I cannot create standalone applications with J# so I had to learn C# to do them anyway.

J# is not compatible with Sun's Java so I can't use them together.

Sun's Java runtime is available for Windows(tm).

C++ is faster than C# so why would I use .NET?

increasing size of sun VM?????

[jilles]

I keep reading about this on sites like this. It should be pointed out that even the JRE (java run-time environment) for jdk 1.4 is well below 10 megabytes (mainly depending on the platform). Of course if you download the full jdk you have a bigger download, mainly because that includes, among others, various tools and the source code for most of the API. But even then we are talking about 30 or 40 MB.

Go check out Opera or netscape, both have an optional download for the JRE 1.3.x. I think it was about 6MB. The JRE includes everything you need to run Java applications. It is hardly bigger than MS jvm and does a lot more.

Incidently, there is currently a beta of an enhanced 1.3.1 JDK that includes an activex component that fully replaces microsoft's JVM. Yes that's right, you can now run all your applets in IE using jre 1.3.1. Of course it doesn't support the MS specific extensions of the JVM.

Welp, the Register has a good article on J#, too

[haggar]

Gotta love the title:

Apply here to screw Java: Microsoft recruits more J# developers

Competition never hurts. I welcome J# completely.

[javabandit]

First, a disclaimer, I am not a Microsoft advocate. Those guys can stick it up their ass. That being said, I will do what it takes to do my job and get paid.

The issue here is that *many* Java developers have been trying to code quality front-end applications on Windows using Java -- and have failed (or fallen very short). *I* am one of those people who have done so. I know many other Java developers who have failed to meet their expectations reasonably when coding on Windows.

If I know that my target platform is only going to be Windows, but I can't use any of the Windows libraries... what good is Java? Its not. So I have to go back to C++. But C++ is a horror in its own ways.

Too many in the Java community are zealots about what Java should and shouldn't be used for. The idea that if it isn't WORA (Write Once Run Anywhere) then it shouldn't be written in Java is completely ludicrous, IMHO.

Some Java developers want the elegance of Java with an easy way to utlitize Windows native libraries without having to write convoluted JNI interfaces all over the place.

The answer is J#. However, I was perfectly happy with the idea of C#. C# has some compilation advantages and syntax advantages over Java that I really love.

I have extensive experience with Swing (Java GUI libraries), and they just simply don't cut it for serious front-end application development. The more complex controls such as JTable and JTree are full of bugs, they are difficult to use, and complicated. If you want less complicated controls, you have to buy a proprietary vendor's API and use those, instead. The Windows 'look and feel' does NOT look and feel like Windows. Because of the MVC design, you have to import practically every single class in Swing into your programs.

AWT was much more compact and easy to use. It also was pretty snappy; however, it suffered from lack of GUI controls.

I don't see anything wrong with J#. If it works for you and serves your purpose, use it. If it doesn't, then don't.

But a little competition in the Java marketplace (or any marketplace) never hurts. Maybe it will light a fire under Sun's ass and get them to contribute more to the front-end side of Java -- which has been ignored for far too long.

Better yet, maybe they will open-source Java, instead. Even better.

So .NET = selling CORBA to suits?

[Balinares]

.NET solves this by making all languages share a virtual machine that defines a bunch of basic data types, and a base 'object'. This means that any object created in one .NET language can be accessed by another .NET language.

Okay, so, in terms of functionality, how does that differ from CORBA, where you can very easily call a complex method written in Java on an Alpha box running OSF/1 from an object written in Python on an x86 box running Linux?

Outside, of course, the fact that CORBA is a fully documented specification, meant to be completely open and interoperable, complete with mappings for data types and everything, and that you don't need a virtual machine to make it run where you want, the way you want?

Please note -- it's not a troll. I'd just really want to know.

Re:Get thee to the C# decompiler.

[jilles]

Decompilers are close to useless for maintenance activities unless you don't have the sourcecode (so either you threw it away, duh, or you're not supposed to have access to it). You do maintenance on sourcecode, preferably properly commented source code, preferably source code you are familiar with.

Whether you compile to .Net or to bytecode is irrelevant. There's really only one certainty: migrating to .Net will generate additional maintenance activities since you will have to test whether it works and almost certainly you will encounter small problems. Once you have migrated and supposedly actually use the binaries you will find that you need to fix little things and even add new features from time to time. So you will keep tinkering with your old J++ code.

It is worthwhile to mention that J# is not really a migration tool since there is no conversion of source code taking place into one of the typical .Net languages. Also J# apps still use the rather limited 1.1.4 API and not the .Net API so it is really a tool to communicate with legacy J++ applications rather than to migrate those legacy applications (which eventually you may need to do after all). And once more: the whole problem of J++ applications being legacy software is because MS decided to abandon J++. First they charge you for a J++ development environment and now they charge you again for some crappy solution to let you keep using your J++ stuff. Probably the reason you decided to use J++ in the first place was to be compatible with the other wonderful windows stuff you paid for. You were screwed three times! If I had used J++ in the past, I'd be very pissed off. This also shows that you have to be careful to invest too much into C# or Visual Basic or .Net because MS may suddenly decide that they need some extra revenue and change things so much that what you invested in heavily suddenly becomes legacy software. Visual Basic changed substantially during its existence and generally 'migrating' apps between different versions cannot be done fully automatically (i.e. it will cost you). Just like with office it is highly debatable if the changes are worthwhile and that breaking compatibility is really necessary but you have no alternative so you upgrade and revise your old stuff.

jdk1.0.2 code still compiles on jdk1.4 (ok, minus some minor API changes which were necessary and are generally easy to fix). The resulting bytecode can still be executed on a jdk1.0.2 VM. Try to do that with VB applications written in 1995 (when jdk1.0.2 was released) on the latest version of VB and you will see my point.

Open source non-Swing Java tree and table Java

[jonabbey]

Actually, if you are looking for less complicated tree and table components, check out the ones included with Ganymede.

I wrote them because I needed them for Ganymede development, and Swing hadn't quite come along yet. I kept them because they are simple to use, they are pretty high performance, and you can do fancy tricks like node dragging ihttp://www.arlut.utexas.edu/gash2/doc/javadoc/arl ut/csd/JTable/baseTable.htmln the tree with little-to-no effort.

You can read the Javadocs on them here and here.

They are licensed under GPL, along with the rest of Ganymede.