The New and Noteworthy stuff starts here. The best thing I see here is code folding, but there's probably something for everyone.

EclipseCon is running, so here are some reports from EclipseCon, as well as a new Eclipse Plugin site, Eclipse Plugin Central complete with RSS feed.

Also in Eclipse news, here is IBM's Proposed contribution to the Eclipse Web Tools Platform Project. This is the contents of a zip that was posted to the newsgroup -- making it a pain to reference. I hope that the whole system of passworded newsgroups will be done away with now that Eclipse is independent.

Today I was playing with the Eclipse on Mac OS X, and I wanted to move the workspace directory out of the Eclipse install directory. On the Windows version of Eclipse (and I assume the Linux version), you can specify the -data flag to the Eclipse launcher to do the job. Unfortunately, this doesn't work on the Mac. I posted a query to eclipse.tools.jdt and got instructions on what to do.

You'll have to edit the Info.plist file:

- do a Control-click (or right button mouse click) on the Eclipse application
- from the context menu select "Show Package Contents"
- in the new folder double click on "Contents"
- open the file "Info.plist" with your favorite text editor
- at the end of your file (after the "Eclipse" key) change the existing
  arguments or add a new argument (enclosed in a <string> </string> pair).

Be aware that there is already a "-data" argument.

If you want to have your workspace in your home directory, you can use a '~'
character as a shortcut for your home directory.

So with the following two arguments your workspace will be created in your
Document folder:
    <string>-data</string><string>~/Documents/workspace</string>

I've been hoping that the Eclipse folks would steal a feature from IBM's Websphere Studio Application Developer, which allows you to select a workspace directory from a dialog at startup. This plist editing on the Mac is a really good reason for doing the dialog. What if I wanted to switch among a few workspace directories?

Dave Johnson saw these screenshots of Whidbey and despaired of having such an easy to use environment in a Java based toolset. I don't know if Dave has seen the IBM WSAD version of the HTML/JSP editor, but it can do a lot of what the Whidbey HTML editor can do. If you select rendered HTML and switch to source view, it highlights the tags responsible. It works backwards that way too. Of course, it costs $$$, but so will Whidbey.

In other Eclipse news, codesugar is a new plugin that generates equals(), clone(), toString(), and hashCode() methods.

Eclipse is having its own convention. When you look at how many of the presentations are by IBM'ers, you have to wonder how successful Eclipse has been at attracting outside developers to the Eclipse core. Eclipse is definitely open source from a licensing point of view, but from a community point of view, the core still seems pretty closed. It takes time to build a community, and getting involved with such a big project is hard, so maybe I shouldn't be too hard on Eclipse just yet...

Changes are here.

Lots of new refactorings, and improved integration with CVS. The ability to edit files outside the workspace.

This probably old hat for lots of you, but I've been using a combination of Eclipse and SecureCRT to access CVS repositories over SSH (at least on Windows). JCraft's CVS-SSH2 plugin for Eclipse makes that unnecessary. It can to SSH public-key authentication, and works great.

The list of new features is here.

James Robertson has a report from Smalltalk Solutions 2003 about set of plugins for using Smalltalk under Eclipse. This is an interesting idea, although as James points out, this will probably never be as good as a native Smalltalk environment because the extensibility points are dictated by Eclipse's Java API. It certainly might get a bunch of people to try Smalltalk. On the other hand, if this kills off the native Smalltalk IDE's then what happens once people figure out what you can really do with Smalltalk? I have to agree with James that this probably isn't going to help Smalltalk. Next we'll be hearing about Eclipse for Lisp...

Paul's talk was an introduction to Eclipse, the goals of the Eclipse project and the Eclipse consortium. John Wiegand, the Eclipse PMC lead came by in the middle to give a demo. His demo was short and showed debugging of a hello world java program. Then he showed the C/C++ tools and did a similar debug exercise, showing that they use the same Eclipse interface (in particular to the debugger). I had never seen the C/C++ tools before (not that there was a lot different) although it was interesting that Eclipse can use gcc/gdb as the underlying compiler/debugger.

Paul was my second line manager when I worked at IBM. Now he's Mr. Eclipse, which cool. It was even cooler that he still remembered me after all these years. We got to catch up a bit on people that we know and so forth. We started talking about Eclipse, and he introduced me to John Wiegand, which was also cool. I told him about my experiences with Eclipse in the field, and how I've given a number of impromptu demos of Eclipse at SeaJUG. I talked with the two of them about two issues: 1) how to explain Eclipse to hackers (emacs/vi hackers in particular). I related how it takes a little explaining to get my hacker friends to understand why Eclipse is so powerful and has the potential for so much more. 2) Integrating Jython as a scripting language / interactive shell for Eclipse. This would be really cool because you get get at all the Eclipse internals so you could write scripts that would perform series of actions. More on this in the next post. It was good to catch up with Paul again, and I appreciated the chance to talk about the Eclipse project goals in person. I've been concerned about the level of outside participation in the core Eclipse components, and the guys told me that they want to encourage it, but that its hard code for people to get into because its the internals of the compiler. They have been getting good contributions for SWT.

Scott Stirling has a post outlining ways that he uses Eclipse to manage projects which are broken up into multiple Eclipse projects.

It was two ApacheCon's ago that I sat in Greg Stein's presentation on Subversion, and I've been waiting expectantly as the Subversion team has gotten closer to beta.

Today I saw a posting for Subclipse, which allows Eclipse to use Subversion as a version control system. Subclipse is based on the Svn-Up project, which uses JNI to talk to the Subversion C libraries. While this isn't the optimal implementation for Eclipse (using the Eclipse DeltaV and WebDAV support -- or more likely hacking it up to spec, would be better), it's a lot better than nothing. One side-effect of the JNI implementation is that the plugin is tied to specific versions of the Subversion libraries. All in all, a very welcome project.

This week's issue of the Java Specialists Newsletter is about appending strings. This should be old hat to seasoned Java developers. However, there was one interesting part in the middle of the newsletter. Kabutz discovered that the Eclipse Java compiler generates code that is much more efficient than the code generated by javac. He wonders if Eclipse is using jikes to compile Java, which is false. Eclipse has its own incremental Java compiler written in Java. I wonder how many other places there are where one compiler beats the other...

Werner Ramaekers tells how one of the JBoss developers has modifed Jasper to call the Eclipse JDT compiler instead of javac, resulting in HUGE speed improvements. It is nice to see more technology leaking out of Eclipse and into other projects. SWT was the obvious example of this, and I think that the JDT compiler has the potential to do this - after all it's an open source extendable incremental Java compiler -- a great testbed for compilation experiments.

Carlos responded to my response (Carlos, I was at the IBM Center for Java Technology in Silicon Valley -- I was part of the team that brought you XML4J, now known as Xerces-J.):

The Eclipse environment in the programming language arms race is equivalent to those JDAM GPS guided bombs. These weapons are cheap, it changes the battlefield in a revolutionary way. So the next time someone argues to you that C# has a nice syntactic feature, show him how Eclipse makes that irrelevant.

As interesting proof of that claim, this morning Simon Fell said:

I think now more than ever, Microsoft's competition is closing in on area's that MSFT has in the past been way ahead of everyone else. For example, development IDE's, for a long time Visual Studio was way ahead of anything else, but now Eclipse gives it a serious run for its money, I find there are features in Eclipse that I miss when I switch back to VS.NET, and that it makes me a more productive Java programmer than VS.NET makes me a C# programmer (although I find the CLR's BCL to be more productive than the Java 1.4 class library).

The reason for this is that Eclipse is not just a text editor. It understands programs. The builtin compiler generates a bunch of data structures that are kept around and fed back into the editor/searching whatever. This is where the power comes from.

Eric Foster-Johnson has a great post on how to get started with Eclipse. I've added it to my own Eclipse Quickstart page.

The Eclipse 2.1 build is now available. There is a long description of what's new. Major features for me include:

• Emacs key bindings
• New Ant view and editor
• Linking to external files and directories (so others will stop harping on this)
• Linked rename
• More and improved refactorings
• Add Delegate Methods dialog

JBoss-IDE 1.0.1 is out. It integrates nicely with Eclipse 2.1M5 and no longer uses an installer -- it uses the regular Eclipse Update manager. JBoss-IDE provides XDoclet support and support for managing (starting/stopping/debugging) JBoss servers.

I filed Eclipse bugs for some of the wishes that I mentioned in yesterdays post, and this morning I had a bugzilla dialog with the Eclipse folks on one of the features. I wanted the ability to commit from the differences UI. I've mostly been using Eclipse's CVS functionality via right clicks on files and packages in the Java Package view. Turns out that the Synchronize with repository view allows you to do what I want. I just never used that view before.

For those interested in how to do it, here's the steps:

1. From the Java Perspective right click a file/package and select Team->Synchronize Outgoing Changes
2. To compare the version you're check in with what's in the repository, expand the folders containing the resource you're interested in checking in
3. Double click the resource to open the Java Structure Compare and Java Source Compare
4. Read what you've changed
5. Go back to the Struture Compare and right click, then select "Commit"

Voila! Now that's what I call tech support - via bugzilla no less.

The last thing is that the Synchronize view comes up squished into the same pane as the tasks and console. To fix this, right click on the title of the Synchronize view and select "Fast View" to put it over in the Perspective bar on the left.

I just discovered an Eclipse plugin that can display the call graphs into a method and out of a method. This is a piece of functionality that I've been hoping would get into Eclpse, so I'm happy that this plugin has made its appearance.

Other things I wish Eclipse would do:

• Code folding - this keeps getting put off
• Refactorings
• Convert parameter to field (and the reverse)
• Convert to inner class
• Split pane editing
• Ability to commit files from differences UI
I like to check in by doing a diff and then writing the comments from the diff. It'd be great if I could select the filename in the structure compare view and be able to commit from there.
• Javadoc checking
Last time I used Netbeans, there was some code that would walk all the Javadoc comments to make sure they weren't empty
• Ability to name versions within the local history