Eclipse webtools (WTP) project and its performance / quality

Question

Our company has been using eclipse for several years (we have been using WTP since the release of 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 our main IDE.

And I must say that once again I am very disappointed in terms of performance:
WTP 3.2.3 looks a lot slower than 3.0.4.
Actually, I'm really curious why WTP is getting slower with every release.

One of our applications (dynamic web project) contains about 4000 Java classes and 700 jsps / jsp fragments . We only need the basic WTP functions for developing jsps, xmls and xsd. We do not need high sophisticated features like Dali (if the JPA tools are really covered by the webtools project?), Libra or the visual XML editor .

Another interesting point is that WTP seems to slow down the entire IDE . SWT is not responsible for any part of the seconds, CPU usage is very large (especially after it was built - if you look at the system tasks, several jsp / javascript indexers work for several minutes, even if all WTP assembly validators were disabled ), opening new files is slower, moving around a project, etc.

This is especially noticeable on older machines that contain only one core processor.

Worst of all, I got the feeling that the WTP development team doesn't care about performance (for example, see http://wiki.eclipse.org/WTP_Performance_Tests - the last update was in 2008).

Error messages and messages in Newsgroup regarding the performance of basic functions (for example, editing / checking jsp) are often ignored or closed after a while, some examples: here , here , and here .

Quo vadis, WTP?

---

Please do not get me wrong:

I do not 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 quality issues , especially in terms of performance, which affects usability and user acceptance.

I just want to point out that the team should focus on what is important for most users in the first place, and then work on implementing super-duper functions.

My questions

• What are your impressions of WTP, especially the latest releases?
• Can you confirm or refute my observations?
• Are there any better alternatives?
• Have you switched from or to WTP and why?
• Do you have some better ways to speed it up, especially for medium sized ones like ours?

---

UPDATE

I would like to make an update on this to reflect current answers and to summarize:

• Many users more or less complain about the same problems, so I see that these problems are confirmed.
  By the way, this question is also mentioned in theserverside.com newsletter with additional comments.

• The responsible WTP project manager, nitind, made a notable entry about the current WTP situation that I would like to quote:
  "The simple fact is that we don’t spend much time on performance tests because we don’t have enough resources to do this."
  "Of course, we would like to take the initiative, not react, but we tend to devote our time to functional problems."
  

So, this question turns a little into some kind of open community letter in a WTP team:

Dear WTP team, it 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 required to solve the current problems. Eg 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 WTP releases. Please, please, listen to your community. 

Answer 1

To answer, I am leading projects that provide JSP, XML, and JavaScript editing features in WTP. The simple fact is that we do not spend much time on performance tests, because we do not have enough resources to do this. Of course, we would like to be active, not react, but we tend to devote our time to functional problems. We really have an adoptive product that regularly tests performance regression, but I expect the tests to run on multi-core machines by now - and we haven't had any new red flags that have been reported to us for some time.

Of the 3 errors that you are associated with, 2 is preceded by version 3.0.4, which you welcome, and the third is a formatting performance issue (since it is addressed) or one with a type check specific to XML files (a fix which would cause a memory leak in Xerces, iirc, therefore, we do not put it at this time). If you have specific projects that you can attach to the error, and say that "running X is slower in 3.2 by the sum of Y", we will do our best to find out where the regression is.

As for indexers, they should at least eventually complete. Information stored on disk has been changed between WTP versions, and these files must be processed so that they are again included in the search and (where implemented) refactoring operations. As soon as the initial indexation is completed, it should act gradually and be practically invisible. One architectural change you may encounter is that for JSPs, the entire workspace needs to be indexed in a single workbench session so that this index is considered "relevant." Shutting down Eclipse due to frustration will only prolong the effect of this recycling.

It seems that the standard installation of your company includes the fullness of WTP, and not the distribution of your own custom distribution. I highly recommend that you check the Startup and Shutdown settings page and disable the early launch of any feature that you are not interested in using. Nothing that you mentioned interest uses this object, but there are other areas of WTP and platforms. All that you are not interested in checking is an honest game on the Validation preferences page, as well as a parameter for checking default JSP fragments in Web / JSP Files / Validation .

Answer 2

We also have a problem with WTP 3.2.3. We have been using it in our product for several years, but the recognition of our developers and customers in this tool decreases every year, because in each new release it is slower and slower.

I would like to use it if I could disable all the "advanced" functions, but as you mentioned, you cannot disable indexers at all. Also, you cannot stop the JSP file validator if it is already running (you can check this if you have as many files as you have and we also have about 1000 JSP files and many tag files in our project).

I can also prove that increasing memory does not help. It only prevents all eclipse crashes, but does not reduce the internal blocking of the WTP user interface.

In the newest version 3.2.3 , I got a lot of freezes when I started Tomcat from the server view. The user interface only freezes for 1 minute . It's not only me who has the hangs, all my colleagues who work on Windows have the same problem. On Linux, I do not know about this problem.

There are also problems in WTP when you do not have access to the Internet. There seems to be a request to some registries to load schemes or such things, and if you don't have a connection, it just hangs and waits for a timeout.

Answer 3

I don’t know who is to blame: WTP or JBoss Tools. The fact is, while working with GWT (minimal JSP), I went the other way around: no WTP at all !!! Now I use simple Eclipse for Java and use the launch configuration for deployment (I invoke ANT programmatically) and start the server, and I never looked back !!! The eclipse used ~ 1.5 GB and crashed several times. Now it sits at ~ 800 MB, and the whole environment has become more stable.

Answer 4

I saw similar effects, here is one solution that may be appropriate in some project environments ...

To ensure a fast and responsible Eclipse web project environment, consider the following:

• Using the Eclipse IDE for Java Developers
  • The 98MB version is more compact than the 200M EE version.
  • from General / Startup and Shutdown, disconnect everything except "Eclipse UI"
  • from Validation, disable validators you don't need.
  • they probably prevent some performance issues (YMMW)
• Using Jetty
  • you do not need WTP or any other plugins, this is pure Java
  • like Tomcat, but very quick and easy to install in any IDE / environment
  • embed directly in your project files, configure once for each developer
  • works in any IDE (Eclipse, IDEA, JDeveloper ..)
  • run the servlet container with "Debug As" / "Run As"
  • shutdown The servlet container by pressing the red button on the Eclipse console.
  • IDE console, debugging, and replacing hot code and JRebel work fine

The result: fast and responsive Eclipse compared to many other Eclipse installations using the Eclipse EE version with WTP content.

Why? It is possible that some features or the Eclipse plugin are buggy or simply misuse resources, 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 use.

Here is a quick start guide if you want to try the Jetty Servlet Container with Eclipse. See https://vaadin.com/web/jani/home/-/blogs/vaadin-for-everyone-how-to-get-started . Download VaadinProjectForAnyIDE.zip, this is an Eclipse project. Just ignore this Vaadin stuff and replace HelloWorldApplication.java with your own servlet and edit web.xml accordingly.

One more thing. With the Eclipse EE version, you can also try the J2EE preview server, which is actually the Jetty built into the Eclipse bundle. However, it also uses the WTP mechanism.

Answer 5

I also find that the stability and performance of Eclipse / WTP is somewhat worrying. I have been using Eclipse since mid-2003 and have been trying to use WTP from the very first releases.

At first, the quality was absolutely terrible, but for version 0.x, of course, I could not complain. Waiting for WTP to mature, I used MyEclipse, which seemed to be in order, but had its drawbacks (and partially based on WTP, inherited some of WTP).

When MyEclipse got heavier and heavier, slower and slower, and we ran into several stability issues, we switched to “pure WTP”. All that we used was really the main JSP / JSF editor and deployer.

Since WTP does not perform incremental deployment (at least not for the JBoss runtime), we added a separate server runtime from the JBoss tools. When we adopted Facelets, we also switched to the editor from the JBoss tools.

However, we face many problems that we also had with MyEclipse. There are inexplicable slowdowns, but much worse - stability issues. There are many inconvenient exceptions and crashes. A typical .log file on many different workstations that I reviewed is chockfull exceptions. A small selection of the last 10 exceptions in my journal:

one.

 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) 

four.

 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) 

Please note that these are only the last 10, there are many, many exceptions.

Random reaction: "Your Eclipse installation is corrupt! You have a local problem!" Yes, I may have a local problem, but this "local problem" seems to be widespread, since many of the Eclipse installations I tested seem to have this data in their logs.

I also have problems with deployments, for example, at the following link in different incarnations: http://community.jboss.org/thread/158611 These can be specific JBoss tools or it can be based on basic WTP or even Eclipse code. I do not know, but I know that this is an unpleasant problem. In each version of WTP and JBoss there is “something,” and each version of such a problem arises in a slightly different form.

Between stability issues, I can do some work, and I like the automatic completion and transition to the functions offered by editors (which prevents me from switching to a text editor and completely building on the command line), but I will surely enjoy the increased stability.

Answer 6

To date, the best way to speed up my projects is with pre-code, which I currently do not use. We have about 20 projects that make up our system, and when working on a specific problem, I concern only a specific subset of these java files. Compiling most of the code that I don’t touch and throw it into some .jar, then using it as a source instead of including projects turned out to speed up the situation quite a bit. I think this will help you if you have 4k + files. Each project has only a small build.xml that will make a jar of it.

Regarding slowing the mind in editing JSP. I have the same problems, it's just a dam. I have no more than 100 jsp files, but I have the same problems as you. My solution was to scribble money on hardware, and I must admit that I like to do: P.

Answer 7

To answer the following question: Do you have some best methods to speed it up, especially for medium sizes like ours?

Turning off validation and automatically building after saving files is a good start to improve performance.

Answer 8

I turned off the WTP JSP editor for the reasons you mentioned above: it just takes too many resources. A few more things you should consider:

• Edit JSP in a regular HTML editor. This means that you will not get code completion, which is good. IMO, mixing Java and HTML is a mistake in the first place, and the editor cannot fix it. Put all the Java code in the helper beans (which you can easily check) and just access the beans from the JSP. This should get rid of 99% of all <% %> %% <% %> tags and solve most of your problems already.

• Consider using Spring to be able to create more complex beans and inject them into your JSP using the following patterns:

  • How to insert Spring beans in SimpleTag jsp 2.0?

  • Use SpringBeanAutowiringSupport:

     <%! @Autowired private Bean bean; public void jspInit() { SpringBeanAutowiringSupport .processInjectionBasedOnServletContext( this, getServletContext() ); } %> 

• Try using a different virtual machine. WTP editors create a huge number of objects, and now all virtual machines (GC implementation) can do this equally well. If you use Sun Java, try JRockit or IBMs J9 . Also play with the GC settings. Increasing RAM will not help, because if you have problems with the GC, more RAM usually only worsens (because the GC will process more data).

• Pre-copy as much code as possible. You do not need to constantly open 4000 classes in the workplace. Cut your huge project into manageable pieces.

• Replace the JSP with simple Java servlets and use HTML rendering libraries such as rendersnake or use a programming language that plays nicer with HTML (like Groovy ).

• Get decent equipment. A new PC with a quad-core processor and 8 GB of RAM costs $ 1,000. If you save 10 minutes every day, the investment will be paid after 50 days (at the rate of 1 person costs $ 1,000 per day in total).

• Try MyEclipse , which has much better web editors. The JSP editor is better than WTP (for example, code completion works most of the time), but it is still sluggish.

Answer 9

WTP (3.2.3) is also slow for me. I believe that I found several ways to do this not so slowly:

• We use maven, so there is a target directory that contains a copy of all JSPs and some other XML. I found out that they are sometimes checked by WTP validators. But this is not necessary, so I excluded them from the scan (Project / Properties / Validation / XXX / Exclude Group /). (You should have the same effect when marking the target directory as derived, but this does not work for me several times ;-()
• I made a (not scientifically proven) observation that WTP seems to work faster with JSPX than with JSP files.

Answer 10

If you need barebones Java EE, then you will be better off with Netbeans, if you need everything except how to work, you better work with IDEA. It is so simple.

Answer 11

I can not comment, so I just put my comment in this answer.

You tried to increase Eclipse's memory allocation, I know that it was used to crash all the time when I used it on Mac OS X some time ago. It has a configuration file with a basic allocation of RAM, as soon as I modified this file and gave it an additional 128 megabytes of memory, it behaved better. Not sure if this will affect WTP, I comment more on the most basic Eclipse application.