Our company is using eclipse since several years now (we are using WTP since release 0.7)
I am currently evaluating eclipse 3.6.2 with WTP 3.2.3 which should replace eclipse 3.4.2 with WTP 3.0.4 as being our main IDE.
And I have to say that once again I am quite disappointed in concerns of performance:
WTP 3.2.3 seems to be much slower than 3.0.4.
In fact I am really wondering why WTP gets slower with each release.
One of our applications (dynamic web project) contain about 4000 java classes and 700 jsps/jsp fragments. We only need basic WTP functionality for developing jsps, xmls and xsd. We don't need high sophistic features like Dali (should JPA tools really covered by a webtools project?), Libra or a visual xml editor in the first place.
Another interesting point is that WTP seems to slow down the whole IDE.
SWT is non-reponsive for some fraction of seconds, cpu usage is very high (especially after a built took place - if you look at the system jobs, several jsp/javascript indexers are doing work for some minutes, even if all WTP build validators have been disabled), opening new files are slower, navigating through the project etc.
This can be especially seen on older machines which do contains only a single core cpu.
The worst thing is that I've got the feeling that the WTP dev team does not care much about performance
(e.g. have a look at the http://wiki.eclipse.org/WTP_Performance_Tests page - last update took place in 2008).
Bug reports and Newsgroup posts regarding to performance of basic features (e.g. jsp editing/validating) are often ignored or closed after some time, some examples: here, here, and here.
Quo vadis, WTP?
Please don't get me wrong:
I don't want to blame WTP.
In fact I believe that WTP is a good open-source project developed by a talented team.
But obviously the project has a problem with its quality assurance, especially in terms of performance which affects usability and user acceptance.
I just want to point out that the team should focus on the things which are essential to most of the users in the first place and afterwards work on implementing super-duper-features.
My Questions
What are your experiences with WTP, especially the most recent releases?
Can you confirm or disprove my observations?
Are there better alternatives?
Did you switch from or to WTP and why?
Do you have some best practices to speed it up, especially for upper-mid-sized like ours?
UPDATE
I'd like to make an update on this question to reflect the current answers and
to sum up the current results:
Many users complain about more or less on the same issues so I see those issues as confirmed.
BTW, this question is also mentioned on a news post on theserverside.com with additional comments.
The responsible WTP project lead, nitind, made a notable post on the current situation of WTP, which I like to cite:
"The simple fact is that we don't spend much time on performance tests because we lack resources for doing that."
"Of course we'd like to be proactive about it rather than reactive, but we tend to allocate our time to functional problems first."
So this question turns a little bit into some kind of an open letter from the community to the WTP team:
Dear WTP team,
it's obvious that WTP is suffering from major quality/performance issues
which you try to play down or to ignore.
Please invest some time to improve the current situation
at the cost of new features and do everything what's required
to solve the current problems.
E.g. revive the performance team, do some regression tests between
previous releases or ask the community for (precise defined) help.
I am sure that they are enough people willing and able to help here.
If you like, do some kind of poll to get a feeling what should be
the most important scopes of future's WTP releases.
Please, please, listen to your community.
To respond, I'm the lead for the projects that supply the JSP, XML, and JavaScript source editing functionality in WTP. The simple fact is that we don't spend much time on performance tests because we lack resources for doing that. Of course we'd like to be proactive about it rather than reactive, but we tend to allocate our time to functional problems first. We do have an adopter product running performance regression tests regularly, but I expect that tests are run on multi-core machines by now--and we haven't had any new red flags reported to us for some time.
Of the 3 bugs you linked to, 2 predate the 3.0.4 version you laud and the third is either a formatting performance issue (since addressed) or one with as-you-type validation specific to XML files (the fixing of which would have triggered a memory leak in Xerces, iirc, hence us not putting it in at that time). If you have concrete projects that you can attach to a bug and say "doing X is slower in 3.2 by Y amount", we'll do what we can to figure out where there's a regression.
As for the indexers, they should at least eventually complete. The on-disk information that is stored has changed between WTP versions, and those files need to be reprocessed so they're again included in search and (where implemented) refactoring operations. Once the initial indexing is complete, it should act incrementally and be virtually unnoticeable. One architectural change you may be running into is that for JSPs, the entire workspace needs to be indexed in a single workbench session for that index to be considered "up to date". Shutting down Eclipse out of frustration will only prolong the impact of that reprocessing.
It sounds like your company's standard install includes the entirety of WTP rather than rolling your own custom distribution. I urge you to check the Startup and Shutdown preference page and turn off early startup of any functionality you're not interested in using. Nothing you've mentioned interest in makes use of that facility, but there are other areas of WTP and the Platform that do. Anything you're not interested in validating is fair game on the Validation preference page, as well as the setting to validate JSP fragments by default on the Web / JSP Files / Validation preference page.
We have the same problem with WTP 3.2.3 here, too. We use it in our product for several years, too but the acceptance of our developers and customers in this tool is decreasing every year because in every newer release it is slower and slower.
I would like to use it if I could disable all "advanced" features but as you mentioned you cannot disable the indexers at all. Also you cannot stop the validator of JSP files if it is already running (you can test this if you have that many files as you have and we also have around 1000 JSP files and many tag files in our project).
I also can prove that increasing the memory does not help. It only prevents crashes of the whole eclipse but it does not reduce the UI blocking internal operations of WTP.
In the newest version 3.2.3 I got many hangs when I start Tomcat from within the servers view. The UI just hangs about 1 minute. It's not only me who has the hangs, it's all my colleagues who work on Windows have the same problem. On Linux I do not know about this problem.
Also there are problems in WTP when you have no access to the internet. It seems there are request to some registries to download schemas or such things and if you do not have a connection then it just hangs and waits for the time out.
I don't know who's to blame: WTP or JBoss Tools.
The fact is that, as I work with GWT (minimal JSP), I went the opposite way: No WTP at all!!! I'm now using plain Eclipse for Java, and use a run configuration to deploy (programatically invoking ANT) and start the server, and I never looked back!!!
Eclipse used to take ~1.5GB and crashed several times. Now, it sits on ~800MB, and the whole environment became more stable.
I have seen similar effects, here's one solution that might be suitable in some project environments...
To guarantee fast and responsible Eclipse Web project environment, consider this:
Use Eclipse IDE for Java Developers
98MB version is leaner than 200MB EE version
from General / Startup and Shutdown, disable all but "Eclipse UI"
from Validation, disable validators which you do not need
these probably prevent some performance issues (YMMW)
Use Jetty
you do not need WTP or any other plugins, it's pure Java
like Tomcat but very quick & simple to install into any IDE / environment
embed directly into your project files, configure once for every developer
works in any IDE (Eclipse, IDEA, JDeveloper..)
start Servlet Container with "Debug As" / "Run As"
shutdown Servlet Container by clicking red box on Eclipse console
IDE Console, debugging & hot code replacement & JRebel works fine
Result: fast & responsive Eclipse when compared to many other Eclipse installations that use Eclipse EE version with WTP stuff.
Why? It might be that some Eclipse feature or plugin contains bugs or simply uses resources in a bad way and this makes Eclipse UI sluggish.
Non-Java EE Eclipse is good enough even for many Java EE project environments, it all depends on your architecture and what tools you are using..
Here's a quick tutorial to get started in case you wish to try Jetty Servlet Container out with Eclipse. See https://vaadin.com/web/jani/home/-/blogs/vaadin-for-everyone-how-to-get-started . Download VaadinProjectForAnyIDE.zip, it's an Eclipse project. Just ignore that Vaadin stuff and replace HelloWorldApplication.java with your own servlet and edit web.xml accordingly.
One more thing. With Eclipse EE version, you might also wish to try J2EE preview server which actually is Jetty embedded into Eclipse bundle. However, this also uses WTP mechanism.
I also think the stability and performance of Eclipse/WTP is somewhat alarming. I'm using Eclipse since mid 2003 and have been trying WTP since its very first releases.
At first the quality was absolute abysmal, but for a 0.x version I couldn't complain of course. While waiting for WTP to mature, I used MyEclipse, which was sort of okay but had its flaws too (and being partially based on WTP, inherited some of WTP).
When MyEclipse became heavier and heavier, slower and slower and we ran into several stability issues, we switched to 'pure WTP'. All we were using was really the basic JSP/JSF editor and deployer.
Since WTP doesn't do incremental deployment (at least not for the JBoss server runtime) we added the separate server runtime from JBoss tools. When we adopted Facelets, we also switched to the editor from JBoss tools.
We do however run into a lot of problems we also had with MyEclipse. There are unexplainable slowdowns, but much worse are various stability problems. There are lots of awkward exceptions and crashes. A typical .log file on many different workstations I examined is chockfull of exceptions. A small selection of the last 10 exceptions in my log:
1.
java.lang.NullPointerException
at org.eclipse.jst.jsp.core.internal.validation.JSPActionValidator.isElIgnored(JSPActionValidator.java:147)
2.
java.lang.RuntimeException
at org.eclipse.jface.viewers.ColumnViewer.checkBusy(ColumnViewer.java:763)
3.
java.lang.ArrayIndexOutOfBoundsException: 38
at org.eclipse.debug.internal.ui.viewers.model.FilterTransform$Node.addFilter(FilterTransform.java:67)
4.
org.eclipse.jdi.TimeoutException: Timeout occurred while waiting for packet 302111.
at org.eclipse.jdi.internal.connect.PacketReceiveManager.getReply(PacketReceiveManager.java:171)
5.
java.lang.NullPointerException
at org.eclipse.jst.jsf.facelet.core.internal.cm.ElementCMAdapter.getLength(ElementCMAdapter.java:109)
6.
Caused by: java.lang.NullPointerException
at org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.WebappConfiguration.getConfigFilesFromContextParam(WebappConfiguration.java:184)
7.
org.eclipse.emf.ecore.resource.Resource$IOWrappedException: Feature 'span' not found. (file:///mysystem/Eclipse.app/Contents/MacOS/com
/sun/faces/metadata/taglib/facelets_jsf_core.taglib.xml, 453, 52)
at org.eclipse.emf.ecore.xmi.impl.XMLLoadImpl.handleErrors(XMLLoadImpl.java:83)
...
at org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.TagModelLoader.loadFromInputStream(TagModelLoader.java:100)
8.
java.lang.NullPointerException: No IModelProvider exists for project P/my_project of version: Utility Module
at org.eclipse.jst.j2ee.model.ModelProviderManager.getModelProvider(ModelProviderManager.java:101
9.
java.lang.NullPointerException
at org.eclipse.jst.j2ee.internal.deployables.J2EEDeployableFactory.clearCache(J2EEDeployableFactory.java:238)
10.
org.eclipse.jst.jee.model.internal.mergers.ModelException: java.util.ConcurrentModificationException
at org.eclipse.jst.jee.model.internal.mergers.EjbJarMerger.process(EjbJarMerger.java:79)
Note that these are just the last 10, there are many, many more exceptions.
The casual reaction would be: "Your Eclipse install is corrupted! You have a local problem!" Yes, I might have a local problem, but this "local problem" seems widespread as many Eclipse installs I inspected seem to have this stuff in their logs.
I'm also having problems with deployments like reported at the following link in various incarnations: http://community.jboss.org/thread/158611 It may be JBoss tools specific or it may be based on the underlying WTP or even Eclipse code. I don't know, but I do know it's a nasty problem. Every WTP and JBoss tools version there is 'something' fixed, and every version a problem like that resurfaces in a slightly different form.
Between the stability problems I'm able to get some work done and I love the auto completion and navigate-into features the editors offer me (which keeps me from switching to a text editor and building completely on the command line), but I sure would love some increased stability.
By far the best way for speeding up my projects has been to precompile code that I am not currently using. We have about 20 projects that make up our system and when working on any specific problem I'm only touching a specific subset of those java files. Compiling most of the code that I won't be touching and throwing it into some .jar's, then using that as the source instead of including the projects has proven to speed up things by quite a bit. I imagine it will help you as well if you have 4k+ files.
Each project just has a little build.xml that will make a jar out of it to include.
As for the mind numbing slowness in the JSP editing. I have the same problems, it's just so dam slow. I don't have many more than 100 jsp files but I have the same issues as you. My solution has just been to throw money at hardware, which I must admit I enjoy doing :P.
To answer the following question:
Do you have some best practices to speed it up, especially for upper-mid-sized like ours?
Turning off validation and auto-building after file-saving is a good start to increase performance.
I've disabled the WTP JSP editor for the reasons you mentioned above: It just needs too many resources. Some more things you should consider:
Edit JSPs in the normal HTML editor. That means you don't get code completion which is a good thing. IMO, Mixing Java and HTML is a mistake in the first place and an editor can't fix that. Put all Java code into helper beans (which you can then test easily) and just access the beans from JSP. This should get rid of 99% of all the <% %> tags and solve most of your problems already.
Consider using Spring to be able to build more complex beans and inject them into your JSPs using these patterns:
How to inject spring beans into a jsp 2.0 SimpleTag?
Use SpringBeanAutowiringSupport:
<%!
#Autowired
private Bean bean;
public void jspInit() {
SpringBeanAutowiringSupport
.processInjectionBasedOnServletContext(
this, getServletContext()
);
}
%>
Try a different VM. WTP editors creates huge amounts of objects and now all VMs (GC implementations) can handle that equally well. If you use Sun's Java, try JRockit or IBMs J9. Also play with the GC settings. Increasing RAM won't help because if you have GC issues, more RAM usually only makes it worse (since the GC will have to process more data).
Precompile as much code as possible. You don't need 4000 classes open at all times on your workspace. Cut your huge project into manageable chunks.
Replace JSPs with plain Java servlets and use HTML rendering libraries like rendersnake or use a programming language which plays more nice with HTML (like Groovy).
Get some decent hardware. A new PC with a quad core and 8GB RAM costs $1000. If you save ten minutes every day, the investment will be paid up in 50 days (at the rate of 1 person costs $1000/day all in all).
Try MyEclipse which has much better web editors. The JSP editor is better than WTP (code completion works most of the time, for example) but it's still sluggish.
WTP (3.2.3) is slow for me too. I belive I have found some ways to make it not so slow:
We use maven, so there is a target directory which contains a copy of all JSP's and some other XML's. I have recognized that they are sometimes scanned by the WTP validators. But this is not necessary, so I have excluded them from validation (Project/Properties/Validation/XXX/Exclude Group/). (You should be able to gain the same effect when marking the target directory as derived, but that does not work for me some times ;-( )
I have made the (not scientifically proven) observation, that WTP seems to be faster with JSPX than JSP files.
If you need barebones Java EE then you are better off with Netbeans, if you need everything but just working you are better off with IDEA. It is as simple as that.
Couldn't comment so I will just put my comment in to this answer.
Have you tried upping Eclipse's memory allocation, I know it used to crash all the time when I used it on Mac OS X awhile ago. There is a config file that has the base RAM allocation in it, once I modified that file and gave it an extra 128 megabytes of memory it behaved better. Not sure if this will affect WTP, I am commenting more in regards to the core Eclipse application itself.
Related
We have a Java EE 6 web application which is fully mavenized, and we use the Maven "war overlay" facility to add customer specific files, and which currently runs in Glassfish 3.1.
We have traditionally used Eclipse for development, but I have found that the combination of Maven processing and War deployments may not be optimal in terms of deployment times, and that the mavenization allows us to use any IDE with good Maven support.
Therefore is Eclipse the best bet for our particular scenario (maven war overlays -> glassfish, and debugging it) or is e.g. Netbeans or IntelliJ better?
Please, back opinions with actual experiences, thanks.
EDIT: Some inital experiments with Netbeans 7.2 bundled with Glassfish 3.1.2.2 under Ubuntu 12.04.1 strongly hints that Netbeans work much faster in this scenario.
Admittedly Netbeans does have some nice features for Java EE Development and can be downloaded pre-packaged with glassfish, making life a bit easier.
BUT frankly as far as I am concerned it comes down to witch IDE you are most comfortable with. As any advantage you may gain from slighly better support, will be wiped out completly by your (teams) not being familiar enough with the new IDE's features and tools.
I guess what you really ought to considering is something like JRebel, witch plugs directly into the JVM, allowing real hot deployment. And has been developed specifically for faster Development by reducing the time spend on rebuiling and republishing entire projects for even the smallest of changes.
All the mentioned IDEs have more or less similar features in regards to maven support and hardly any of then could help you in this particular scenario. You could rather try avoiding maven overlays in development process as it adds time to the build phase. As suggested earlier, you could also benefit of JRebel for faster turnarounds. With that you will not have to run mvn clean install and save plenty of your valuable time.
The ide used is :IBM Rational® Software Architect™ for WebSphere® Software
Version: 7.5.5.3
The app server used is Wbesphere 6.1.
I am posting this question because my server takes about 7 to 8 minutes to start.
So even if i make a small change ,i have to wait 10 minutes to test the change in my application.So is there a way where i can make changes to my java code and test them without restarting the server.
Suggestions appreciated !!!
Note:
I am not supposed to use any build tool in my environment.
There is a plugin called JRebel that let's you do changes without restarting the server.
Dynamic Code Evolution VM is open source alternative to JRebel you can try for reloading classes. It will do entire class redefinition, even reloads changes done to class hierarchy.
Theoretically reloading classes is build into the JVM, although most implementations (specifically Oracle's) only reload (hot swap) as long as you only change code inside the body of a method.
The other problem is that in Eclipse the WTP adapter has to cooperate and only deploy the changed class definition (incremental deploy). GlassFish for some reason has always been a big opponent of incremental deployments, and hence its WTP adapter restarts the server after making even the most tiny change.
JBoss used to be a proponent of incremental deployments, but after AS 7 ("everything has to be different"), they are now a follower of the "restart the server" school as well.
Yet another issue is that plain class loading is often only one part of the story. In EJB, JSF, JPA and many other frameworks classes also have to be re-registered by the framework, caches have to be cleared, etc
This all is where something like JRebel comes it. It reloads nearly all kinds of changes to classes. It also works independently from the WTP adapter thus freeing you from the whims of the server vendors regarding if restarting is hip today and lame tomorrow or exactly the other way around. JRebel also has knowledge and plugins for many frameworks.
Unfortunately JRebel is not perfect and occasionally things will just fail, but overall it works pretty well.
One other piece of advice: most modern application servers start up in a second on relative fast hardware and with a small application or a some 10 seconds for a larger app. With those and session serialization you almost don't need things like JRebel anymore.
When going to Java Web Development such as JSP, JSPX & others.
What IDE do you consider Eclipse or NetBeans?
What are its advantages and disadvantages?
Which is better preferred in-terms of developing Web Applications such as Websites, Web Services and more. I am considering NetBeans because it has already bundled some features that will allow you to create and test web applications. But is there a good reason why choose Eclipse WTP?
From a micro perspective, Netbeans is a more consistent product with certain parts more polished such as the update manager. I am sure you will find all everything you need in there.
Eclipse is sometimes a little less stable simply because there is still alot of work going on and the plugin system is usable at best. Eclipse will be faster because it uses SWT which creates the UI using native code (so, it will look prettier as well).
At a macro perspective thought, I'm sure you've heard on the news of the recent acquisition of Sun by Oracle. Well, let's just say I'm pretty sure Netbeans is pretty low on Oracle's priorities. On the other hand, Eclipse has big blue (IBM) backing it. So, in the long run, if you don't want to end up in a dead end, go for Eclipse.
I used both Eclipse and NetBeans. I like NetBeans more than Eclipse. From Java editor point of view, both have excellent context sensitive help and the usual goodies.
Eclipse sucks when it comes to setting up projects that other team members can open and use. We have a big project (around 600K lines of code) organized in many folders. Eclipse won't let you include source code that is outside the project root folder. Everything has to be below the project root folder. Usually you want to have individual projects and be able to establish dependencies among them. Once it builds, you would check them into your source control. The problem with Eclipse is that a project (i.e .classpath file) dependencies are saved in user's workspace folder. If you care to see this folder, you will find many files that read like org.eclipse.* etc. What it means is that you can't put those files in your source control. We have 20 step instruction sheet for someone to go through each time they start a fresh checkout from source control. We ended up not using its default project management stuff (i.e. classpath file etc). Rather we came up with an Ant build file and launch it from inside Eclipse. That is kludgy way. If you had to jump through these many hoops, the IDE basically failed.
I bet Eclipse project management was designed by guys who never used an IDE. Many IDES let you have different configurations to run your code (Release, Debug, Release with JDK 1.5 etc). And they let you save those things as part of your project file. Everyone in the team can use them without a big learning curve. You can create configurations in Eclipse, but you can't save them as part of your project file (i.e it won't go into your source control). I work on half dozen fresh checkouts in a span of 6 months. I get tired to recreate them with each fresh checkout.
On the other hand, NetBeans works as expected. It doesn't have this project management nightmare.
I heard good things about IntelliJ. If you are starting fresh, go with NetBeans.
My 2cents.
I use Netbeans mostly for development, and can say it's pretty good in providing most of the features I need. Code completion, one click compiling and deployment, even version control. If you need a feature not found in the core, you can also choose from a good variety of plugins. As far as I am concerned, Eclipse have a very similar feature set, though I did not work with it in detail.
However, netbeans have serious memory problems, and is very demanding on available memory, and I have seen it eat up 400-500MB of ram after repeatly deploying my app for debugging. Other than that, I say Netbeans is quite fast (if memory is adequate).
Aptana for Eclipse was I using some months ago but changed to NetBeans. It has less feature but the out-of-the-box things were nearly the same as Aptana after 2 hours customization.
Each software has some slowdowns and memory leaks, some annoying code validating bugs.
But NetBeans is better in code completing, rarely slows down, can manage 1 mb javascript files. That's why I changed from Aptana for Eclipse to NetBeans.
Other Eclipse tools I used before was lacking the things which are in Aptana and NetBeans by default. And although I am using some plugins, I don't like hacking on the IDE for days to achive a usable program.
For me:
NetBeans +
Eclipse -
From my own experience, while Eclipse provides you with tons of plugins, that is not always guaranteed to meet your expectation. I had so many problem with Eclipse plugins, ranging from different versions of Eclipse itself to the multiple plugins prerequisite for a plugin.
Plugins in NetBeans is so easy to install, but yea, it is not as many as Eclipse's.
Feeling clunky while using Eclipse also led me to move to NetBeans. While SWT is nice GUI, its load time takes considerably a long period of time compared to NetBeans Swing. But, be warned, NetBeans feels good if and only if you are using Windows platform. Apparently Swing in Linux (at least on Ubuntu 10.10) blows. Each time I click on a file in Project Manager, it tries to rename it. But this happens only if you use NetBeans in Linux.
Another point of me moving to NetBeans is the project management window. In Eclipse it sucks and does not work as what I expected. If you had ever use Visual Studios IDE project/solution view, NetBeans is the closest one resembling it.
Both consumes a lot of memory. Even worse, the Swing GUI takes a long time to load after you wake up your machine from Hibernate/Sleep. No joke. Happens to me all time.
Anyway, this is purely my opinion. Hope this helps.
Go for eclipse for unlimited plugins(free).
I was a fan of Eclipse for long time. Specially when I developed plugin and Android program.
Now I have to work with some project with maven build system and tomcat (web app), and found Eclipse too much complicated to load and debug and changes to take effece from any jsp file. And Netbeans is so smart in this regard. Even debugging with Tomcat webapp is so easy with Netbeans. So I moved to Netbeans.
At least for now, for web app development, Netbeans is the best, I guess.
Also auto completion in Eclipse for Mac, is a nightmare to me. I could not make it work with Ctrl+Space, since its a shortcut for Sptolight/Keyboard change by default. I did not use netbeans with mac yet, but I shall try.
For GUI, the WindowBuilder or Jigloo, always crush in Mac. Netbeans GUI designer was better in that sense.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
I've been using Xcode for the usual C/C++/ObjC development. I'm wondering what are practical considerations, opinions of Xcode, Eclipse or NetBeans usage on a Mac for Java development?
Please don't include my current usage of Xcode in your analysis.
You missed the Rolls Royce of all IDEs. IntelliJ Idea.
If you can afford to buy a personal license, go for it. Edit: There’s a free Community Edition which is a superb way to get started with Java, Scala or Kotlin.
I like NetBeans on OS X for Java.
It seems like I spend more time configuring eclipse to get a decent java programming environment. With NetBeans the setup time is less and I can get down to programming quicker...
I would advocate Eclipse on the Mac for Java, mosly because I had a very good experience. I'm not going to bang on about its merits as an IDE, but here are some unexpected advantages I found:
When my employer switched IDE's to Eclipse I was way ahead.
Pretty much any language I fancied trying out had a free IDE somewhere as an Eclipse plug-in, so I have a very consistent multi-language development environment.
When I eventually went over to the Windows dark side I could use the same development environment, which was a huge relief.
But this is a bit of a religious topic, so expect to get a whole bunch of different opinions
Just to be sure you give them fair consideration, Eclipse and Netbeans have gone back and forth for a while. Eclipse used to be a good deal quicker because they didn't use Swing.
Now Netbeans has caught up (perhaps surpassed) and has a lot of momentum.
You will get more votes for Eclipse. Period. This is because it was better and more people use it--and it's just human nature to feel what you are using is the best and everyone should use it.
Because it was better does not mean it's better now. Netbeans has more languages supported and more all-around support--so it's growing faster.
Currently I use Eclipse--I've used both (and IntelliJ and TextMate and Notepad...) and I can tell you that Eclipse has exactly one feature over netbeans... Mylyn (it's been renamed, it used to be called Mylar). This thing is pretty damn cool, but few people seem to even know it exists.
So, if you don't know a bunch of keystrokes that already tie you to an editor, the up and coming is Netbeans--don't pass it up because of a bunch of Eclipse votes.
Better yet, get good with both--it can't hurt and makes me a lot more comfortable when a company requires one or another. Don't whine when they make you change.
Do not use Xcode - Java support in the later versions is very much lacking. Even Apple, who make it, suggest you use a different IDE. As for NetBeans and Eclipse, they both have their strengths and a large number of vocal followers. I suggest you try both and use whichever you find more comfortable.
I for one use TextMate and shell scripts. But I'm strange.
Well, I can chime in with Netbeans, it seems to work really well. There are some function key issues that I believe has a solution, I just haven't solved it. I've been quite happy with Netbeans. I like its "all in one out of the box" nature over the pick and choose plug in nature of Eclipse, but that's just a matter of taste.
Another vote for IntelliJ. http://www.jetbrains.com/idea/
I used both Eclipse and Netbeans. I like Netbeans more than Eclipse. From java editor point of view, both have excellent context sensitive help and the usual goodies.
Eclipse sucks when it comes to setting up projects that other team members can open and use. We have a big project (around 600K lines of code) organized in many folders. Eclipse won't let you include source code that is outside the project root folder. Everything has to be below the project root folder. Usually you want to have individual projects and be able to establish dependencies among them. Once it builds, you would check them into your source control. The problem with eclipse is that a project (i.e .classpath file) dependencies are saved in user's workspace folder. If you care to see this folder, you will find many files that read like org.eclipse.* etc. What it means is that you can't put those files in your source control. We have 20 step instruction sheet for someone to go through each time they start a fresh checkout from source control. We ended up not using its default project management stuff (i.e. classpath file etc). Rather we came up with an Ant build file and launch it from inside Eclipse. That is kludgy way. If you had to jump through these many hoops, the IDE basically failed. I bet eclipse project management was designed by guys who never used an IDE. Many IDES let you have different configurations to run your code (Release, Debug, Release with JDK 1.5 etc). And they let you save those things as part of your project file. Everyone in the team can use them without a big learning curve. You can create configurations in Eclipe, but you can't save them as part of your project file (i.e it won't go into your source control). I work on half dozen fresh checkouts in a span of 6 months. I get tired to recreate them with each fresh checkout.
On the other hand, Netbeans works as expected. It doesn't have this project management nightmare.
I heard good things about IntelliJ.
If you are starting fresh, go with Netbeans.
My 2cents.
It depends what you want to do. My experience with Java on the Mac is about a year old by now, but NetBeans had a much better out-of-the-box support for Tomcat (in particular) deployment, and generally seemed to be a little more user friendly. For instance, the Netbeans beta I tried out used forms for web.xml configuration, in comparison to Eclipse's plain ol' XML editor (and in Europa, at least, the XML editor's row redrawing was a little sketchy on the Mac).
That said, for that project, I wound up doing a bit of configuration (for a was a n00b) in NetBeans, then moved the XML config files over to Eclipse, and developed the rest there. As others have mentioned, the zillions of plugins are great, and in general the experience is just very consistent. Especially if you have to work on another platform.
If Eclipse had better OS X bindings (does it have any? I'm unaware), I would use that for Obj-C development, as well.
I have tested editors for Java extensively and prefer Netbeans to Eclipse by a significant margin. NetBeans has excellent support for Java, a very beautiful user interface and powerful features. It also has excellent support for C++ and I would choose for this it over, say, Visual Studio. Consider JCreator classic edition, an excellent place to start although not as powerful as NetBeans, easier to get into at first.
I'd also defend NetBeans plugins against Eclipse because although Eclipse is highly praised for the flexibility it is afforded by plugins I think this is largely down to the fact that the also very powerful plugins features of NetBeans are not shouted about so much, even though it is also very strong in this area. I have seen computational fluid dynamics applications based on the NetBeans platform, very impressive, I just don't think NetBeans developers make such a big deal over it because it's already a complete package from the moment you download it, powerful without any need for configuration with plugins.
If you're using Eclipse, be sure to use Ganymede (3.4) or later. They run great. The previous version (Europa) ran poorly on my Macbook Pro.
I happen to use Eclipse on my Mac (actually EasyEclipse which comes preconfigured with the most important plugins) and I must say it runs great. I have a less positive experience on Linux though.
I have also used NetBeans 6 recently and I was very impressed. It seems to have more functionality build-in. Most of the functionality is undoubtedly also available as an Eclipse plugin though, if you can find it.
Currently I have the impression that if you start developing Swing, Netbeans is your best option. Otherwise, Netbeans or Eclipse with a handy set of plugins are both excellent options.
If you do check out eclipse, give a thought to EasyEclipse (free) or perhaps even MyEclipse (not free). They come with the most usefull plugins preinstalled.
I've worked with both Eclipse CDT and NetBeans's C++ support, and I must say that in my experience CDT is far superior in both stability and in features. It's really impressive how well the CDT indexer works; the tooling is almost as good as Java's. I'm also a huge fan of JDT when compared with NetBeans for Java development. The workflow is just so much smoother, if only due to the incremental compiler (compile-on-save).
One thing about NetBeans though, its UI does flow a little better in the "Mac style", which is ironic seeing as SWT was created to provide a more native interface. The next release of Eclipse should be based on Cocoa (rather than Carbon, which is the current), but that won't be until next June.
Final note: the whole "in box" vs "plugins" issue is entirely moot and it has been since Eclipse Calisto (two years ago). Now, with P2 (the new update manager), it's dead easy to get different features in the IDE. I can start with a download and get a fully-functional JDT/CDT/Mylyn environment up and running within five minutes of installation (assuming a reliable internet connection).
I use Eclipse for development, and have had nothing but pain. It has more bugs than a bait shop, and is one of the worst written programs I have ever used. Use Xcode if you want to save time and frustration.
I'll suggest Eclipse because it has a zillions plugins and is almost a standard for Java development. But I've heard that NetBeans is really nice since their latest release specially if you want to do desktop application(Swing) .
I can't comment on Xcode since I haven't play with it.
Just from my experience, Eclipse is very large IDE. It needs more work to become better suited for the Mac environment. Netbeans is the best out of box experience. After installed, it is essentially ready to go. After I tried IntelliJ IDEA I forgot every other kind of IDE :P
But at the end no one wins over the other.
IMHO as USUAL !
Eclipse, because it has better support of C++ on mac. I used Netbeans long time ago, did not like it.
Use Java based IDE on mac only if you have to (especially when doing Java development). Xcode already supports C/C++ development, so no need to switch.
am I missing the point here or are developers still considering using Mac for java development?
I was a strong and rigid supporter of Mac as a development environment but ever since Apple's decision to not port java on later versions of os x my confidence has shaken a little.
And please do not even think about doing any j2EE deployment on Mac as it will bring about a tsunami of woes.
So long Java but I like my mac book pro too much .
FYI:I still use Mac for java development but sometimes I wish I were a python developer :(
From my experience, I use both Eclipse and Intellij (license) for J2EE development.
For overall of speed on IDEs, Intellij is faster and crashed lesser than Eclipse. I used Eclipse first and later on, I got used to Intellij and fell in love with it. However, Google's Android Studio is Intellij based. It's more modernized. Debugging is much easier especially you can evaluate a block code during the debug mode to see how it behaves instead of just inspecting objects. I highly recommend!
I am having my web application deployed on Tomcat5.5 and I use it in integration with eclipse 3.2.Each time I close the eclipse and restart it, I need to republish the application even when it hasn't been modified.
Is there a way to avoid this or any step I am missing ?
Go to Preferences->Server->Launching . Remove option 'Automatically Publish When Starting Server'
I think adij.wordpress.com correctly nailed this one. If you find that you're spending a lot of time waiting for Tomcat to restart as you develop your application, consider using Jetty instead. It'll restart in a fraction of the time Tomcat does and provides a full featured alternative that is ideal for agile development.
We use Glassfish (Tomcat based) with multiple EAR files and it's dog slow for development so each EAR project contains a Jetty launcher that simply fires up for the single WAR the developer is working on at the time. If you use IntelliJ this can be made automatic so that changes at any tier of the application can be instantly reflected into the currently running application in the time it takes to click onto the browser and refresh the page.
Do eclipse 3.3 or 3.4, or later versions of WTP behave the same way for you?
As this is a quite old question and still filed under unanswered, I'd like to broaden the scope with this answer:
I assume there is a reason for you to want to cut out republishing of your application that I don't know (other than the aversion against unnecessary work being done)
The only thing I can guess is that it takes a significant amount of time. For me the publishing time has never been an issue, but if they are for you, you might think about
increasing your memory (if swapping virtual memory slows republishing) - e.g. buying new RAM
optimize dependencies in your project, e.g. prepackage dependent projects if there's a huge number of them or create subprojects and depend upon them if there's only one huge project. (This assumes, that any of these factors slows republishing. I have not measured it)
does using Tomcat6 or glassfish help?
It might be, that not publishing is your issue but startup time. You might gain a lot by controlling that very tightly, e.g. starting services on demand after the webapplication has started. I know several applications that do some heavy work during startup (before they accept their first connection and before they pass control on to the next application startup that might do the same). I hate them. Usually such services get lots of swear words and finally their own web/application server. Having to restart one of these applications should at least not make all the other applications (and their users) suffer that are written with nice startup times in mind.
If your question is still an issue and you are still looking for a solution, please comment. What is your republishing time?