Slashdot Mirror

SSDs do not solve a problem

Perhaps not for you, but SSDs do offer enormous benefits for some of us. For instance, I use an IDE that dynamically performs hundreds of inspections at any given time. For large projects, file I/O became the limiting factor. SSDs essentially remove file I/O from the equation. Seek times go from milliseconds to nanoseconds. For all intents and purposes, anything your system requests will be available immediately.

Another area this could be helpful is with databases--you're basically moving the entire database into memory. You could instantly generate multi-GB table indexes. You could take backup snapshots of production systems with no additional latency. That's insane.

SSDs essentially remove an entire category of performance restriction. It's like... imagine if car makers didn't have to think about aerodynamic drag any more in their car designs. That'd be pretty freakin' insane, right? That's SSDs. (/dumb car analogy)

Some better examples of fast Java apps would be: IntelliJ IDEA or Aqua Data Studio.

IDEA is also a lot better than Eclipse functionality-wise but that's not really releveant for this comparison.

Netbeans is actually a piece of junk, and nobody in their right minds doubts that Swing is a nice idea but a really really poor implementation. If you want to see a performant Java UI (and an excellent IDE to boot) check out IntelliJ Idea (http://www.intellij.com/).
As for server apps, I've consistenty seen a properly written Java server outperform its Perl/PHP/CGI predecessors by orders of magnitude.

You can easily move your classes between packages as long as you don't use CVS :-)

In our projects we use Intellij IDEA IDE. We already have painfull experience with ability to move classes easily (while using CVS). Try moving a class and then merge modifications to different branch...

Good news is that SVN integration comes to IDEA soon. We will migrate our projects to SVN ASAP and then enjoy all features of IDE.

I've been programming Java for years and I've always used vi. How much time have I wasted? I find IDEs a bigger waste of time.

Up until IntelliJ's IDEA I would have agreed with that. As if I needed a buggy, limited text editor with a bunch of cruft-generating wizards. Blech. Yeah, I'm talking to you, JBuilder.

However, IDEA is an utterly different experience, and Eclipse is a reasonably close competitor. Both of them allow you to navigate the code in a much more dynamic way, and the tight integration with JUnit allows you a much faster development cycle than is possible with something like vi. Also wonderful is the tight CVS integration (with per-line color hints), the java-aware assistance (like the live templates and the intentions), and the in-editor docs (where a quick keystroke can show you the javadocs, the parameters, similarly named methods, and other valuable info).

Plus, there's excellent support for keeping your hands on the keyboard; although I do use the mouse sometimes, I never have to use it.

So download it and give it a fair try. I liked it enough that I bought a license out of my own hard-earned cash. It's that good.

And posting the correct link woul have been better.

For instance, let's say you have an interface I, and a class X that implements I. If X is the _only_ implementation of I loaded at the moment, then all calls to methods on I can be direct, non-virtual calls because there's only one choice! In fact, HotSpot will even inline the method calls if it decides it will be beneficial.

But then a class B is loaded. HotSpot will de-optimize the inlined and direct calls to methods on I.

There are many more examples, such as loop bounds-checking elimination, and other things HotSpot can do because it sees the state of the running system.

If you've used a slow Java program, it's no doubt the result of a poor design and coding job by the programmer. "I'll just pick up Java for Dummies in 24 Minutes. Now I'm a 1337 j4v4 h4x0r!!" You may also have been using an old, slow JVM. The performance increases between Java 1.2, 1.3, and 1.4 are truly awesome. Also, Sun's Java 1.5 starts up on my machine in less than half the time that 1.4.2 did, and the graphics as OpenGL accelerated now, ... the list goes on and on. For anyone who had used a Java IDE, especially NetBeans/Forte (which I like, except that it's so freakin' slow I fall asleep between operations), you must try IntelliJ IDEA. It is so responsive and just a joy to use. On the systems I've run it on, it is significantly more responsive than Eclipse.

Sure, there could be one program that would do both, but that wouldn't be as useful.

Don't knock it until you try it. The stellar Java IDE IntelliJ IDEA has pretty much gotten rid of the save command. I don't miss it. Why? Because I always want my work to be saved. The only reason I wouldn't is when using an app with poor undo support.

IntelliJ IDEA hands down kicks the snot out of VS.NET.

It doesn't matter. You buy a Mac if you like Macs. I personally enjoy using Mac OS X far more than using Windows. Everyone I know who uses Macs love Macs. Nobody I know who uses PCs love PCs, they just tolerate them. But you need to decide for yourself.

Now, you asked about Java performance on the Mac. It's fine. I recently switched from doing Java development on a PC to a Mac, and the Mac was faster. It was a faster machine (a dual 1.25 GHz G4 vs a single 1.6 GHz Athlon), so what this proves is that the Java performance on the Mac isn't totally horrible (otherwise the faster machine would have been slower at Java).

One thing to consider is that Apple, not Sun, is in charge of making the JVM. Apple is always a bit behind. They just recently released 1.4.2, for example.

And I would disagree with the people who recommend XCode. It's a nice IDE, but if you're doing pure Java, then you're better off using a smart IDE like IDEA or Eclipse that can do refactoring and smart code completion. IDEA and Eclipse both run fine on the Mac, though they look and feel a bit weird (IDEA has been getting much better recently; check out the version 4.0 release candidate instead of the currently-shipping 3.0 release).

Finally, if you do decide to get the Mac, and you've never bought a Mac before, here are some tips: Apple (like all manufacturers) charges a lot for extras so you might want to consider buying extra RAM elsewhere, and fixing a Mac can be expensive so I would recommend Apple's extended warranty, especially on a laptop.

IDEa is apparently the leanest Java IDE you can get. Eclipse is actually more lean than most of its competitors (jBuilder, Sun's offerings etc), but yeah, it might create problems if you don't have too much RAM.

That's so true. Very few people tries IDEA and goes back to somehting else. None of the Eclipse users I know has ever used IDEA. if they had, they'd be IDEA users now. :-)

I used JBuilder for a long time, I also used its Oracle basterdised son JDeveloper, but the day I switched to IntelliJ IDEA will stick in my mind for a long long time. What a difference. Unless you are doing solely GUI stuff (and after IDEA 4 comes out even that wont be an excuse) IntelliJ IDEA has definitely got to be the hands down nicest Java IDE.

IntelliJ IDEA. Considered to be the best (and smoothest working) IDE by a lot of Java developers. Costs $499 though.

They created an entirely new GUI API because Swing sucks. A better GUI for Java was desperately needed. Swing does not approach the results of a native GUI application, while SWT does.

The Java IDE of choice, IntelliJ IDEA, use Swing, and runs every bit as smooth as Eclipse imo.

Sure there's a lot of overhead in Swing, but, just like with native apps, it's usually bloat and poor programming that cause those unresponsive GUIs.

I dont think the GUI toolkits are the issue here...

IDEA from the folks at intellij just about blows all other java IDEs out of the water IMHO, and its Swing.

It does suffer from the occasional slow down (during garbage collection) but so does eclipse.

Whats more, the look and feel is miles ahead of eclipse. It is commercial, but its worth every penny if you spend long enough infront of it.

In the end, you, as a developer need to figure out what tool you want to use. I think it's great there are so many choices. On the project I'm working with all but one are using IDEA and the last one uses Eclipse. We have no problems at all interoperating. We all use the same source, and the same Apache Ant scripts. So why should we care about this?

In the end, you, as a developer need to figure out what tool you want to use. I think it's great there are so many choices. On the project I'm working with all but one are using IDEA and the last one uses Eclipse. We have no problems at all interoperating. We all use the same source, and the same Apache Ant scripts. So why should we care about this?

And I refuse to use any IDE (like Netbeans) that uses Swing.

sorry to say, but this is ignorant. eclipse is a great app and netbeans might have a sluggish gui, but i would not ditch an application because of its toolkit...

a great example for a good swing-app is intellij idea and its a hell of an IDE (IMHO the _very_ best java-IDE _by far_) use it one day and you never want to go back to any other java IDE. its pure swing, looks good, feels good and is fast and responsive!

yes, its commercial, but thats not the point in this discussion (but you can get a trial-licence, so i'd suggest to try it)

Informative my ass...

Dude, show me a better IDE than Intellij IDEA which is entirely written in Java, and then we'll start talkin'.

Let's say I have a class in package A and I want to move it to package B (in dotNet parlance, packages are namespaces). In dotNet, I'd have to personally touch every piece of code accessing that class and redo the import statements (dotNet: using statements) to reflect the change. Same goes for method name changes, public member changes, method signatures (parameter order, adding parameters, etc.), etc.

Also, the good refactoring IDEs provide a lot of extras like generation of getters/setters (dotNet: properties) (also referred to as encapsulation), extracting interfaces and/or superclasses, replace inheritance with delegation, replace constructor with factory method, make method static, etc., etc., etc.

Note that most of the above refactorings not only change the class in question, but also all accessing classes and methods. This sometimes means you can make a significant change to a heavily used method or class and do NO WORK to the rest of you classes.

If you are interested in the power of IDE refactoring, check out the IDEA refactoring page. Here is a screenshot of the refactoring menu.

In short, refactoring is REALLY powerful and very, very useful. If you are saying otherwise, you probably haven't used it. Also, it should be noted that several companies are making refactoring plug-ins for Visual Studio. Obviously SOME people don't think that Visual Studio's features render refactoring "unnecessary" or a "waste of time." Myself included. (I'm a Java junky programming in a dotNet environment.)

Taft

Let's say I have a class in package A and I want to move it to package B (in dotNet parlance, packages are namespaces). In dotNet, I'd have to personally touch every piece of code accessing that class and redo the import statements (dotNet: using statements) to reflect the change. Same goes for method name changes, public member changes, method signatures (parameter order, adding parameters, etc.), etc.

Also, the good refactoring IDEs provide a lot of extras like generation of getters/setters (dotNet: properties) (also referred to as encapsulation), extracting interfaces and/or superclasses, replace inheritance with delegation, replace constructor with factory method, make method static, etc., etc., etc.

Note that most of the above refactorings not only change the class in question, but also all accessing classes and methods. This sometimes means you can make a significant change to a heavily used method or class and do NO WORK to the rest of you classes.

If you are interested in the power of IDE refactoring, check out the IDEA refactoring page. Here is a screenshot of the refactoring menu.

In short, refactoring is REALLY powerful and very, very useful. If you are saying otherwise, you probably haven't used it. Also, it should be noted that several companies are making refactoring plug-ins for Visual Studio. Obviously SOME people don't think that Visual Studio's features render refactoring "unnecessary" or a "waste of time." Myself included. (I'm a Java junky programming in a dotNet environment.)

Taft

One word: www.intellij.com

As someone has mysteriously marked the parent as "interesting" it might be worthwhile to provoke a genuinely interesting debate below it so that readers are not too disappointed.

The parent insists that no Java IDE "can touch" VS for "any single thing you could possibly want to do", but a moment later admits that "VS.NET doesn't have as robust a feature set as some Java IDEs".

Features like refactoring, perhaps, as found on the free Eclipse IDE, or the modestly priced IDEA?

Or, looking a bit further afield, we could ask how one might develop a complete workflow system in VS, as you can in WebLogic Workshop?

My clients do these things all the time, but VS has a long way to go to offer a competitive alternative to the Java tools available now.

There are some good Java IDEs, no doubt, but none of them can touch Visual Studio for, well, any single thing you could possibly want to do with an IDE.

If you do any Java development try IntelliJ Idea.

Then come back and try saying that again.

I'd be very happy to hear from someone who tried both, and still like VS.NET more.

Because pretty much the main drawback of Java is that it severly limits which platforms you can distribute to, ironically.

The only other option is distributing a 50 meg JVM with every app

and increasing support costs by having to walk people through tedious installation procedures, for the JVM and your app.

If you can compile a native binary, you can distribute it to any binary compatible platform, regardless of what other software they have installed.

You don't have to explain CLASSPATH to your users.

You don't have to explain why they can't type "java filename.class", but instead must type "java filename".

GCJ is the only hope Java has of actually being more than an acedemic curiosity, and "something that Sun used for a few apps".

Are you even aware of the number of web sites exist whose server code is completely written in Java? Most likely you visitied a couple before you came here today.

You obviously haven't tried IntelliJ Idea. Idea is what Java IDE's are supposed to be. Idea is what Eclipse wants to be.

After using IntelliJ for a couple of years I hate having to go back to VS for C#. I'm hoping dearly that IDEA produce a C# IDE. I've never been a huge fan of Eclipse for various reasons, its Visual Age heritage, performance, general look and feel, nothing overwhelming, I just prefer IntelliJ.

However good Eclipse may be, it simply doesn't compare to the king of all Java IDEs, IntelliJ IDEA.

Nothing else comes close. I'm still discovering helpful (but not intrusive) IDEA features a year after I started to use it.

Having said that, Eclipse is pretty good, and much more pleasant to use than NetBeans.

Personally I like IntelliJ IDEA.

It's not free...but I don't think I could go back to Eclipse.

IDEA definatlly is the best Java IDE out there.

Have you considered Together/J as a possible alternative to Rational Rose? It has great Linux support. The app was developed by the same team as IntelliJ.

I agree whole heartedly. And in addition to this, (at least with Java) if you use a modern IDE such as IntelliJ IDEA then you'll know about compile errors without actually having to compile thanks to tools such as on-the-fly code analysis. This saves a great deal of time for the developer and helps break the 'write a few lines, compile, write a few line, compile' cycle.

I agree whole heartedly. And in addition to this, (at least with Java) if you use a modern IDE such as IntelliJ IDEA then you'll know about compile errors without actually having to compile thanks to tools such as on-the-fly code analysis. This saves a great deal of time for the developer and helps break the 'write a few lines, compile, write a few line, compile' cycle.

Oh my God... I get a woody just thinking about it.

IntelliJ's refactoring functionality is the absolute best I've ever seen, bar none.

It's not free (USD 499 for a commercial license), but if you bill for your work, the amount of time and headache you save because of it is worth SOO much more than that.

As for JBuilder, at $3,199 per seat for the Enterprise version, it's just not worth it. I used it exclusively at my last company, and it is crap compared to IntelliJ.

Interesting side note: Borland's response to the new IntelliJ/Eclipse.org/Netbeans onslaught? Raise the price by $200.

Disclaimer: I don't work for IntelliJ, I just use their IDE. :-)

> It's a subtle user interface trick that they've
> missed out on, although I'll admit that Java 2 is
> making things a little better.

I think you're making the right point for the wrong reasons. Java itself is not slow. The VM is highly evolved - have a look at the hotspot whitepapers if you don't believe me. Even the GUI performance is quite good if implemented correctly. The main problems are that correct implementation of a Java GUI takes experience. Have a look at IntelliJ for an example of a well implemented Java GUI. Sun could help by improving the defaults and more importantly supplying "best practices" for building GUIs which they are doing. The main "implementation" problem is that memory consumption is still quite high and that can have an impact of performance. Again, Sun is working in a number of areas to alleviate this. Hopefully, the "shared VM" will be available in 1.5 some time later this year.

I doubt there is a single feature in the .NET IDE that IDEA doesn't do better (except for GUI builder, of course, since IDEA doesn't have one. It's a tool for developers, after all[1]. :-) ).

Check out this review. Or this one.

[1] Actually, a GUI builder is coming in the next version, but it's still in alpha state.

Java has some very good IDEs, even compared to Visual Studio. Have a look at Eclipse and Netbeans for two good open source IDEs and IntelliJ for an excellent (and not that expensive) commercial IDE.

IntelliJ is an excellent Java IDE.

Oh, well w0000t! It's only cross-platform on Windows. What a very fucking useful piece of cross-platformness that must be. Truly its cross-platform powers are astonishing. What a dazzling range of platforms it crosses, indeed. If I ever need a cross-platform IDE, but I only want to run it on fucking Windows, Eclipse will be my first port of fucking call.

SWT also forces you to manually manage all resources. Yes people, it means that you once again are looking at huge potential resource leaks in your app.

I can only advise you to try out both IDEA and Eclipse to make up your own mind.

The .NET Framework has a SLIGHTLY smaller footprint than the latest version of Java (46.5 vs 47.3 on my workstation). And it does more stuff -- a lot of the add-on packages for Java, including all of their J2EE crap, parellels what's already in the Framework. Not that it matters...including the framework on an install CD is trivial, and most Windows Update and XP users have it already.

You said it yourself. You can't really compare size like that since there is more to .NET than just the libraries and the VM. .NET uses a huge amount of bread&butter stuff in the Windows libraries, something which obviously can't be used by Java. At least not in the same way, since Java has to work on more than one platform.

.NET does NOT integrate the web into windows applications. .NET allows users to create web apps in much the same interface as standard windows forms, using a system called WebForms.

True, but it does integrate .NET into the web. It makes it very easy to build applications with much more "intelligence" on the client side, similar to building a XUL application using Mozilla.

The downside (or advantage, if you're Microsoft) is that you will only get these "rich" client experiences when running Explorer, preferably on Windows. But that's the whole point. Lock-in by pretending to be open, it's brilliant.

It also allows regular ASP pages to be compiled into faster versions a la JSP/Servlets.

True again, but they are still slower than JSP's on fast app servers, for example Orion. (disclaimer: I don't have the latest benchmarks so things may have changed).

What's cool about .NET is that the IDE supports all sorts of really useful data transformation and reporting mechanisms using SQL/XML/etc built right in...no rolling your own data access methods (though I end up doing it anyway).

These things has been available in Java IDE's/libraries/toolkits for longer than I care to remember. I believe it started with Sun's JavaBlend (which agreeably wasn't very good, but a lot has happened in the 6 or so years since it came out).

Today we have several frameworks, suitable for different needs. For example Hibernate, JDO, or, if you simply want a fast persistance layer: Prevayler. There are more, of course.

Also note that the the JDO specification allows different vedors to plug in different implementations so you're not relying on a single vendor. This goes for pretty much all of the J2EE specifications as well. I'll take that over Microsofts solutions any day.

.NET is better than Java for apps that will always be used on a Windows PC, because: - It has a much faster graphics interface, while maintaining a robust graphics toolkit.

And how do you know that your apps will always be used on a Windows PC? Do you have a magic crystal ball that can see into the future? Do you really want your apps to be limited to Windows only? Also, with the latest versions of Java, the speed difference (for well written applications, mind you) is neglible. Take a look at IDEA for a good example of a very efficient Swing application. And if you really believe you need native widgets, take a look at SWT, which Ecplise is built upon. But it's a pain to program in, and it's only really cross-platform on Windows. All other platforms suffer from the same problems as Swing apps do.

It has a better messaging mechanism (Events/Delegates are a GODSEND and are the sin

IntelliJ IDEA just plain rocks. I don't know how I coded without it before. Anything else seems like coding with freakin' NOTEPAD.EXE (shudder)

For those of you that have no idea what IntelliJ IDEA is, check it out

• huge developer base
• almost all universities teach it
• It works equally good (if not better) on linux and OS X
• JDBC - works equally well on all databases
• JBoss Hey it's free, and it's good.
• IntelliJ IDEA not free, but worth every euro!
• Jakarta community is unrivalled.
• ANT simply the best build tool.
• Options, options, options. No single vendor lock in.

Try Idea by intellij. I know it is more of a pure java development environment but it has all of the requriments that you are looking for. My company uses it for all of their development(java, jsp, html ) and thus far we have been very very happy with it.

If you're looking for a Java Programmers IDE (i.e. not one that has a Swing/AWT dialog designer type thing), look at IDEA. It's worth every penny of the price. Eclipse is catching up to a lot of IDEA's features but doesn't stand a chance for a while to come.

http://www.xemacs.org
what more do you need? ;-)

If you want a *real* IDE, I'd check out IntelliJ's Idea product. It's a few hundred $$$. Lots of folks like Netbeans and IBM's Eclipse as well (sorry, no url to eclipse, but I'm sure you can find it). The latter 2 are opensource.

IntelliJ

How pleasant are client side gui's implemented in Java? HORRID! They are just slow, and ugly.

Oh, please. On my ancient 700 MHz Pentium III box, complicated Java applications like IntelliJ's IDEA work just fine; it's both responsive and pretty. If you're going to bitch about Java, stick to reasonably modern complaints, like its lack of type-safe collections (which won't be fixed until Java 1.5). Or bitch about the classloader. Or grumble about library management. But the whole "Java is too slow" thing is so 1998.