A new white paper positioning the IBM J2EE Middleware Platform vs. the Microsoft .NET Platform is now available and reflects IBM’s overall marketing plan to aggressively combat Microsoft. While it will be useful to many, its primary target is CEOs, CFOs, and other high-level decision makers at ISV companies who are focused on the mid-market and looking to make a platform/partnering choice in the next 12 months. The outcome of the J2EE vs. .NET decision by ISVs is critical to IBM’s ongoing success and relevance in the midmarket arena, traditionally a Microsoft stronghold.
IBM J2EE vs. Microsoft .Net Whitepaper
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
This is a pretty good brochure, but one thing bothers me about stuff like this. They make this whole argument throughout this piece saying if you go with .NET you’re locked in to Microsoft. Then, throughout the whole piece it’s IBM Whebsphere runs on all these platforms, IBM provides you with servers, IBM has middleware software you can use, IBM has this, IBM has that. This is the kind of paper that needs to be written by some unbiased third party that will say…if you go with .NET you’re locked in to Microsoft. If you want to go with the J2EE platform, here’s offerings from IBM, Sun, BEA, etc. All this paper is doing is saying you can go with an all Microsoft package, or go with all IBM.
Another thing I would like to see is an article that details a company that developed everything in Java, made a switch from their first platform to a totally new one; and all that “Write once, run everywhere” stuff they wrote, did exactly that. I’ve been a Java developer since ’97, but every place I’ve worked at has always been just one platform that the apps would run on. If anyone has a link to an article that actually proves the whole “Write once, run everywhere” mantra in a big way, not just some one-off app, I’d love to read it.
sorry no whitepaper i can publish but
I am working for the 3rd insurance company in switzerland.
– local developement and aplication integration run on NT/eclipse/mysql/weblogic/hp nimius/resin/apache/cygwin
– integration in hpux/tomcat/oracle/weblogic/hp nimius/apache
– test stage hpux/tomcat/oracle/weblogic/hp nimius/apache/virtual vault
– prod stage hpux/2 * tomcat/oracle 9i/weblogic/hp nimius/apache/virtual vault
prod stage
– we can render to WAP/HTML/PDF as well
– Linux prototype on going (because we can do everything and it very near production)
– offline stage for notebook
only 1 ONE!! tree of code, only java (but different JVM because you can not switch to latest jvm with virtual vault)
The company I work at create “enterprise software” that’s running on Windows and lots of Unix versions (including Linux). It contains both C++, Java and Python code. Java seems to be, by far, the easiest to handle. Of course, in a sufficiently large project, you will run into bugs in various Java implementations, that force you to create some platform specific java code. Other than that, Java Just Works(tm).
C++ code will have to be ported, but that to be expected, and you can make that job a lot easier by creating good platform abstraction libraries. Python on the other hand is a total pain in the a**. It pretends to be platform independent, but it just isn’t.
As Cedric (in the post above), we also just have one tree of code, and that includes all the C++ and python code also.
As Cedric (in the post above), we also just have one tree of code, and that includes all the C++ and python code also.
And that’s *many* million lines of code, I might add.
…give me a clear-cut example of how Microsoft can just destroy an “investment” like a software program written in .NET?
– a bug/security problem in the CLR/CLI which is closed source
🙂
all application/language have bugs, closing source may have more! security by obscurity is bad….
– our plattform run in production with 4 proc and 16gb ram with 260Gb database (we call it a street, handling 10000 users, adding a/more street and youre done) -> scalability is under control in J2EE world, I still want to see a windows 2003 handling so much proc and not rebooting because of patchs…(windows is trying now to go in advance computing and farms market)
– sorry always the same complains…we have in prod a lot of NT services running in admin user space, as comparaison hpux virtual vault webserver has 56 levels of privileges, gaining access is difficult if not impossible, and we have it under control.
others than that .net was created to be good if not better than java (collect(ion last 30 years good idea and copying a lot of java idea is not so difficult), M$ just missed the fact that we want to run code across various devices (not always running M$ OS).
except GUI problem (swt, swing, awt, others) Java is fully portable
I never had problems with portability with Java (but then of course, it was made for that). Its extremely sastifying to work from different OS environments with 1 code-tree under Eclispe (using CVS). I especially like SWT, it being losely coupled to the native environment with its widget implementations that are based on native peers.
This paper is clearly very subjective. Naughty IBM
… I’d like to read a more objective paper on .NET vs J2EE since I spoke to a friend recently who’s company had to choose a new platform. Their choice was .NET because it was more affordable than Websphere, which clearly is the opposite to what this paper says.
Don’t forget CIOs. They’re more likely to make those decisions, based on budgets.
James Addison
http://www.pjsoft.ca
This is the kind of paper that needs to be written by some unbiased third party (…)
Dudes, this is an I B M paper. It’s not meant to be unbiased.
They say .NET gives you MS lock-in, and they point out IBM fully supports J2EE. That does not mean IBM lock-in.
All of it may very well be true. I can’t argue with you there. But as a developer working in the trenches, I prefer .NET infinitely over Java from a standpoint of pure coding enjoyment. Obviously I don’t “prefer” it as a cross-platform solution, because it’s not cross-platform. So listen to what I’m saying very, very carefully:
1. I prefer the C# language to the Java language.
2. I prefer the .NET Framework to all the java ones.
3. And that’s it. In other areas, Java may very well be better, e.g., in the (overblown*) cross-platform arena.
I’ve worked extensively with both “platforms,” so I think I can comment intelligently in this arena, although ultimately these are opinions.
*I say cross-platform is overblown because — while it’s important — what’s more important are standard formats and communication protocols. And it’s here that I have a beef with Microsoft. I don’t really care much about write-once run-anywhere. But I’ll leave that for another day.
I agree, for me C#/.net is a much more enjoyable coding environment. The language is far more flexible (and just generally nicer to code in), the framework is more flexible (for example, compare what .NET remoting’s capable of compared to RMI).
Obviously, if the software needs be cross-platform, Java’s quite possibly a better choice. However, if you’re using Windows only, .NET is by far the better platform. Even if some cross-platform compatibility is required (for example, just for a small number of client systems), .NET’s XML/SOAP support is good enough that you should be able to get it to interoperate with Java code without too much trouble.
.Net’s got the typical Microsoft problem.
Make things easy for incompetent programmers and give up Enterprise Quality.
– VB.Net didn’t copy the JavaBeans model so we still have Dll’s to deal with esp. in Component building.
– Pointers gives up Java’s easier and more Secure Coding model
– No Checked Exceptions means Microsoft won’t be coding any… same old crash city.
– managed and unmanaged code, together again: is this Microsoft keeping the ability to write it’s own spyware?
Microsoft MCSD education is still a joke:
– They teach database coding using Grid Controls, which will kill database performance, fine for single user desktop apps. but not for Enterprise coding.
– They don’t teach any SQL
– They show an example of USING an async threaded class, but, Not how to code one. ( Remember, with Microsoft, if there’s no example code, it’s Broke. )
– The Thread class is NOT inheritable!?!
– They use the toString() method on a String!
This is the WORST copy job in history.
I’ve never seen anything this Half-A**ed.
.Net: Microsoft Bunts
Java: Sun hits a home run, and is so thorough, that they run around the bases Twice!
I used to read this kind of comments when I was learning and programming Java, but I no longer stand Java nor its cousing .Net, much less the war comments between the two.
While you talk, the Indians are hard at work.
Wake up! Do something actually useful with what you know.
Good luck to all!
Sun’s biggest advantage is the JCP: the Java Community Process.
This is what protects Enterprise programmers for Microsoft’s ” The cheapest software money can buy” mentality.
The JCP FORCES a DESIGN REVIEW.
Lazy Genius’s begging for Coding Loopholes Don’t get thru the JCP.
I’m continually amazed by how the incompetent continue to get their way at Microsoft. It’s as if there’s some kind of management rule: Write high quality code and get fired.
But, that’s just my rant.
i thought .NET was surprior to Java like most people here have been claiming its not locked due to open source and OS loves .net therefore we should all use mono and dotGNU
>.Net’s got the typical Microsoft problem.
>Make things easy for incompetent programmers and give up >Enterprise Quality.
>- VB.Net didn’t copy the JavaBeans model so we still have >Dll’s to deal with esp. in Component building.
>- Pointers gives up Java’s easier and more Secure Coding >model
>- No Checked Exceptions means Microsoft won’t be coding >any… same old crash city.
>- managed and unmanaged code, together again: is this >Microsoft keeping the ability to write it’s own spyware?
You really don’t know what you’re talking about. If you want to convince us that .NET is worse then please please use better arguments than these.
As we know that IBM hates Microsoft a lot and this article is stricly biased, and to me this article sux and cannot be rely any of the fact that include in this sux article. IBM claimed that MS .NET is not cross platform and gonna locked-in the users, o yeah r everybody have forgetten about MONO that is design to be compatible with ms .net. That why Microsoft have submitted .NET to be ECMA standard to make .NET cross platform. Not like Java that own by Sun and not open standard at all (no ECMA, no ISO).
Sun help open source now days because with the help of open source community it will got guts to fight with microsoft rather than itself alone that have no enough capability to do so(no enough money, no better idea), that why Sun need help from man kind to crush MS and the Evil behind Sun is IBM. As i can see this situation is about politics war between giant company to win the world.
IMHO the biggest problem of the .NET the microsoft patents. They can kill a big part of mono or dotgnu if they want. In this case the .NET based companies are hardly depend from microsoft technology, and IMHO the enterprise level companies are don’t want it. If microsoft grant a permission to mono and other open source projects to create open source clone of .NET the .NET can be more acceptable for biggest companies.
Actually Microsoft has NOT submitted .NET to be ECMA standard. Microsoft submitted C# as a standard, and everyone who has used a Microsoft product knows that they will move off a standard even if they help create it. Dot Net will never be cross platform because it easily depends on technologies such as directX which is not cross platform. The Mono guys are subsituting technologies here and there, but it will be too easy for Microsoft to increase the dependance on proprietary technologies that cannot be ported.
As for IBM, I will take IBM over Microsoft anyday!
I agree with you, snowflake.
>- VB.Net didn’t copy the JavaBeans model so we still have >Dll’s to deal with esp. in Component building.
Microsoft’s component model is quite a bit superior to JavaBeans. JavaBeans requires one to write all sorts of ugly adapter classes and other ancillary rubbish. Instead, .NET uses custom attributes, which “decorate” methods, classes, fields, and properties with metadata about how they are used.
A Windows DLL (“dynamic link library”) is just a shared library, nothing more, nothing less. In other words, it’s almost exactly equivalent to a .so on Linux. .NET packages shared objects in a DLL. What’s the big deal?
>- Pointers gives up Java’s easier and more Secure Coding >model
This is more James Gosling FUD. Yes, it is possible to use pointers in .NET, but only in an extremely limited fashion. You *cannot* get a pointer to a reference type in .NET, and you can only use it in a block marked “unsafe” and then you must compile with a special compiler option.
If you’re thinking you can do all kinds of C and C++ pointer magic, you’re wrong. Not possible. You can use pointers to value types (primitive types and structs) and that’s it.
Why have pointers? Because it dramatically simplifies interop. Beyond that, they aren’t much used. Their use is extremely rare.
>- No Checked Exceptions means Microsoft won’t be coding >any… same old crash city.
Even many in the Java camp say that checked exceptions were a mistake!
>- managed and unmanaged code, together again: is this >Microsoft keeping the ability to write it’s own spyware?
Hunh?!
I really hate it when people who haven’t worked extensively with a technology make comments about it. Has anyone ever heard of objectivity? Critical thinking? Does it exist anymore?
If you’ve never used a technology, but only heard what its detractors have said about it, I think it’s dishonest to comment on it from a technical standpoint.
Now, if you’ve never used a technology, but you dislike its licensing model or the company that makes it, why not keep your comments confined to that arena? Here’s an honest comment about .NET for someone who’s never used it:
I’ve never used .NET, so I can’t comment on it from a technical standpoint. But I regard its originator, Microsoft, as an unethical company and I do not like .NET’s licensing model. Therefore I will never use it no matter what its technical (dis)merits may be.
See, I have used Java in real-world, large scale, complex business applications, so I feel confident comparing it to .NET, which I have also used in such a capacity.
> You can use pointers to value types (primitive types and structs) and that’s it.
And you don’t see the problem there?
> Even many in the Java camp say that checked exceptions were a mistake!
Enterprise coding is a responsiblity not taken lightly.
Allowing programmers to avoid tedious, but necessary, error conditions isn’t an advantage.
Should we accept programs into production environments that never check ELSE conditions, also, because the programmer didn’t have the integrety to code them?
The problem with exceptions is usually the programmer didn’t learn the THROW clause, and didn’t throw the exception back to the caller, where it could be dealt with in a logical place.
Pointers to primitive types
Perhaps you could elaborate on what the problem is.
Checked Exceptions
Just google “checked exceptions mistake” and you’ll find a host of great articles on this, so I won’t rehash it here. It goes way beyond those poor fools who don’t understand structured exception handling. There’s a lot more to it than that, including the problem of encapsulation.
About checked exceptions – take a look at:
[1] http://msdn.microsoft.com/vcsharp/team/language/ask/exceptionspecs/…
[2] http://www.mindview.net/Etc/Discussions/CheckedExceptions
[3] http://www.artima.com/intv/handcuffs.html
and you’ll see why checked exceptions aren’t such a good idea.
About pointers: The CLR can be configured to disallow unverifiable code in components that you don’t trust and they will get no chance of getting executed. Pointers are really powerful tool that let’s you write full-speed code (no overhead, equivalent to C++) without the cost and ugliness of JNI (java native interface). With pointers you can write “pure C#” code that CAN BE a lot more powerful (when used wisely) than Java will ever be.
While I’m glad we’re mostly on the same page, I don’t think “full-speed code” is a sufficient reason to use pointers, and fortunately I never see it done because it’s harder to use pointers in C# than iterators, and we all know programmers are lazy.
Rather, I think the main reason pointers exist is to support System.Runtime.InteropServices, e.g.,
// assume x is the number of strings
[DllImport(“FooBar.dll”)]
private static unsafe extern char **get_some_cstrings(int x);
public static string[] get_some_strings(int x)
{
string[] strings = new string[x];
unsafe
{
char **cstrings = get_some_cstrings(x);
for( int i = 0; i <= x; i++ )
{
strings[i] = Marshal.PtrToStringAuto((IntPtr)cstring[i]);
}
}
return strings;
}
Something like that. I’m sure it’s not quite right, having done it from memory, but that’s the idea.
The UBB tags fudged up my example, there should be an “i” in brackets after “strings”. Oh well.
Read your link for the microsoft diatribe on exception handling and it looks like their article boils down to “It’s too hard”, which is what I expect from microsoft.
However, in real Java production systems, as we type, there are systems that do exactly that: A calls B, B calls C, C calls D and D throws an exception which is passed ALL THE WAY BACK UP TO A. Imagine that.
Again, in Enterprise programming this is EXACTLY what is expected of the competent programmer.
Let’s not argue here too much. You buy microsoft’s “I can’t do it” argument and I don’t. Microsoft has never been know for Enterprise quality so I’m not surprised that they attempt to white paper over their fetish to get out of doing Professional Work.
By the way, Word 2004 for the Mac has a bug in it, it crashes when you attempt to cut/paste a large piece of text into Notebook View. An unhandled Memory Exception?
> The CLR can be configured to disallow unverifiable code in components >that you don’t trust and they will get no chance of getting executed.
Another loophole that must be closed by someone that must know what they are doing. That’s asking too much in most microsoft shops. It’s exhausting even reading about Microsoft’s shortcut-loophole philosophy.
I am completely unqualified to make the following funnies:
Java: Emulate everything at high abstracted level; one set of libraries for all platforms.
.NET: Call native code from managed code; let different implementations take care of platform dependent issues.
One of these approaches takes the speed hit because they won’t optimize for each platform the libraries run on for uniform library usage; theoretically, everything works the same way, the same speed.
One of these approaches leverages existing native libraries and exposes them at a managed level for speed benefits; interpretation from managed<–>unmanaged is up to the implemetation for flexability and portability.
Everything you say is fine in the theory. In practice, I’ve seen way too many code like this:
try
{
code that may throw
}
catch (Exception e)
{
// ignore and don’t rethrow
}
This leads to exception leaks where the application isn’t even aware of potential problems. IMO it’s much worse than letting exceptions pass through without any declaraion.
Another way to overcome checked exceptions which I see all the time is:
void method() throws Exception
{
}
It all happens in multi-million-USD “enterprise software” which I’ve seen a lot during software audits.
Checked exceptions just don’t scale to an enterprise scale.
Quote from Eric Gunnerson’s page:
Examination of small programs leads to the conclusion that requiring exception specifications could both enhance developer productivity and enhance code quality, but experience with large software projects suggests a different result — decreased productivity and little or no increase in code quality.
Full text at:
http://discuss.develop.com/archives/wa.exe?A2=ind0011A&L=DOTNET&P=R…
– It’s hardly an excuse that you’ve found Bad Java Programmer code in production systems, to give up on Checked Exceptions.
I wish to be warned of the most likely errors a class-method will incounter when implemented. If .Net refused to provide those warnings, then clearly Java is Superior, and/or the Sun programmers are better then the Microsoft ones.
– I’ve found in production systems: If’s without Else’s. Should we OUTLAW the IF statement, because lazy developers won’t code the ELSE clauses?
Again in Enterprise coding, is’s an unspoked rule: Every If Requires an Else.
The programmer is Required to think of the else codition and code it,
that may lead to programs issuing warning messages, and tedious error messages which also must be pass back up to the caller. It’s tough writing quality code. Write the code to handle errors up front, or do it at 3am when it crashes in production. Again, Microsoft has the Luxury to write crap and not get called in the middle of the night. I Don’t.
– Actually Microsoft’s arguments seem abit Over the Top to me.
– Different Versions are not radically different, and method’s don’t have radically different functionality from release to release. If they do, you write another class/method to deal with the new functionality.
– Large Systems are made up of smaller sub-systems. Most large systems are not a homogonus mix of code, if they are that’s Bad Code Design.
– Most Throws only go back 1 level anyway.
I find Sun’s documentation on this a bit lite.
Here’s an example:
// bad exception handling: eat the exception
public void setFrom( String sInFrom )
{
try
{
iaFrom = new InternetAddress( sInFrom );
}
catch( AddressException ae )
{
// can’t do anything useful here!
}
}
// pass back to the caller, the caller will know what to do, issue a dialog box // message to fix the address
public void setFrom( String sInFrom )
throws AddressException
{
iaFrom = new InternetAddress( sInFrom );
}
– Another problem with .Net is Why are you calling window’s api functions.
Why are these functions not in the .Net framework? Or, are they, but you haven’t bothered to learn the new classes?
– What justification do you have for using pointers and writing Unsafe code.
A .Net Manager must issue Guidelines:
– No win api calls
– No Pointers
– No unsafe code of any kind
to get the security and stability( Memory Leak protection ) you get with Java out of the box.
What Commitment is Microsoft going to make that they will Continue to develop and upgrade the .Net framework. Past experience with C++ shows that once Microsoft thinks it’s defeated it’s enemy( Borland’s C++ framework ) that they will abandon the .Net framework and call on developers to start coding directly to the Windows API.
You can see the problem now, certain Microsoft C programming groups are still writing API’s in C, and not wrapping the code in the .Net framework.
And C# programmers are calling this a Virtue.
IBM can’t do that. All new projects are in a Java and Java only framework. So, you get all Java code running in a JVM, with memory protection.
There’s no other alternative.