I often see people in newsgroups saying how wonderful Visual Studio is, and they often
claim it’s the “best IDE in the world”. Strangely enough, most go silent when I ask how
many other IDEs they’ve used for a significant amount of time. I’m not going to make any
claims as to which IDE is “the best” – I haven’t used all the IDEs available, and I know
full well that one (IDEA) is often regarded as superior to Eclipse. However, here are a
few reasons I prefer Eclipse to Visual Studio (even bearing in mind VS 2005, which is a
great improvement). Visual Studio has much more of a focus on designers (which I don’t
tend to use, for reasons given elsewhere) and much less of a focus on making actual coding
as easy as possible.
Note that this isn’t a comparison of Java and C# (although those
are the languages I use in Eclipse and VS respectively). For the most part, I believe C#
is an improvement on Java, and the .NET framework is an improvement on the Java standard
library. It’s just a shame the tools aren’t as good. For reference, I’m comparing VS2005
and Eclipse 3.1.1. There are new features being introduced to Eclipse all the time (as I write,
3.2M4 is out, with some nice looking things) and obviously MS is working on improving VS
as well. So, without further ado (and in no particular order):
When I hit Ctrl-Shift-T in Eclipse, an “Open Type” dialog comes up. I can then type in
the name of any type (whether it’s my code, 3rd party library code, or the Java standard
library code) and the type is opened. If the source is available (which it generally is –
I’ve used very few closed source 3rd party Java components, and the source for the Java
standard library is available) the source opens up; otherwise a list of members is displayed.
In large solutions, this is an enormous productivity gain. I regularly work with solutions
with thousands of classes – remembering where each one is in VS is a bit of a nightmare.
Non-Java resources can also be opened in the same way in Eclipse, using Ctrl-Shift-R instead.
One neat feature is that Eclipse knows the Java naming conventions, and lets you type just
the initial letters instead of the type name itself. (You only ever need to type as much as you
want in order to find the type you’re after anyway, of course.) So for example, if I type
“NPE”, I’m offered
Note that this isn’t the same as the “Find Symbol” search offered by VS 2005. Instead,
it’s a live updating search – as you type, the list is updated. This is very handy if you can’t
remember whether it’s ArgumentNullException or NullArgumentException and the like – it’s very fast
to experiment with.
There’s good news here: Visual Studio users have a saviour in the form of a free add-in
called DPack, by USysWare. This offers dialogs
for opening types, members (like the Outline dialog, Ctrl-O, in Eclipse), and files. I’ve only
just heard about it, and haven’t tried it on a large solution yet, but I have high hopes for it.
Sensible overload intellisense
(I’m using the word intellisense for what Eclipse calls Code Assist – I’m sure you know what I mean.)
For some reason, although Visual Studio is perfectly capable of displaying the choice of multiple
methods within a drop-down list, when it comes to overloads it prefers a spinner. Here’s what you get
if you type
sb.Append( into Visual Studio, where
sb is a
Here’s what happens if you do the equivalent in Eclipse:
Look ma, I can see more than one option at once!
For those of you who aren’t Java programmers, import statements are the equivalent to using directives
in C# – they basically import a type or namespace so that it can be used without the namespace being
specified. In Visual Studio, you either have to manually type the using directives in (which can be
a distraction, as you have to go to the top of the file and then back to where you were) or (with 2005)
you can hit Shift-Alt-F10 after typing the name ofthe type, and it will give you the option of adding
a using statement, or filling in the namespace for you. Now, as far as I’m aware, you have to do that
manually for each type. With Eclipse, I can write a load of code which won’t currently compile, then
hit Ctrl-Shift-O and the imports are added. I’m only prompted if there are multiple types available
from different namespaces with the same name. Not only that, but I can get intellisense for the type
name while I’m typing it even before I’ve added the import – and picking the type adds the import
automatically. In addition, organise imports removes import statements which aren’t needed – so if you’ve
added something but then gone back and removed it, you don’t have misleading/distracting lines at the
top of your file. A feature which isn’t relevant to C# anyway but which is quite neat is that Eclipse allows
you to specify how many individual type imports you want before it imports the whole package
import java.util.*). This allows people to code in whatever style they want, and still get
plenty of assistance from Eclipse.
Great JUnit integration
I confess I’ve barely tried the unit testing available in Team System, but it seems to be a bit of a pain
in the neck to use. In Eclipse, having written a test class, I can launch it with a simple (okay, a slightly
complicated – you learn to be a bit of a spider) key combination. Similarly I can select a package or a whole
source directory and run all the unit tests within it. Oh, and it’s got a red/green bar, unlike Team System
(from what I’ve seen). It may sound like a trivial thing, but having a big red/green bar in your face is a
great motivator in test driven development. Numbers take more time to process – and really, the most important
thing you need to know is whether all the tests have passed or not. Now, Jamie Cansdale has done a great
job with TestDriven.NET, and I’m hoping that he’ll integrate it with
VS2005 even better, but Eclipse is still in the lead at this point for me. Of course, it helps that it just
comes with all this stuff, without extra downloads (although there are plenty of plugins available). Oh, and
just in case anyone at Microsoft thinks I’ve forgotten: no, unit testing still doesn’t belong in just
Team System. It should be in the Express editions, in my view…
MS has made no secret of the fact that it doesn’t have many refactorings available out of the box. Apparently
they’re hoping 3rd parties will add their own – and I’m sure they will, at a cost. It’s a shame that you have
to buy two products in 2005 before you can get the same level of refactoring that has been available in Eclipse
(and other IDEs) for years. (I know I was using Eclipse in 2001, and possibly earlier.)
Not only does Eclipse have rather more refactorings available, but they’re smarter, too. Here’s some sample code
public void DoSomething()
If I select the last middle lines of the first method, and use the ExtractMethod refactoring, here’s
what I get:
public void DoSomething()
Note that second method is left entirely alone. In Eclipse, if I have some similar Java code:
public void doSomething() throws UnsupportedEncodingException
and again select Extract Method, then the dialog not only gives me rather more options, but one of them is
whether to replace the duplicate code snippet elsewhere (along with a preview). Here’s the result:
public void doSomething() throws UnsupportedEncodingException
Note the change to
doSomethingElse. I’d even tried to be nasty to Eclipse,
making the variable names different in the second method. It still does the business.
If I hold down Ctrl and hover over something in Eclipse (e.g. a variable, method or type
name), it becomes a hyperlink. Click on the link, and it takes you to the declaration. Much
simpler than right-clicking and hunting for “Go to definition”. Mind you, even that much
isn’t necessary in Eclipse with the Declaration view. If you leave your cursor in a variable,
method or type name for a second, the Declaration view shows the appropriate code – the line
declaring the variable, the code for the method, or the code for the whole type. Very handy if
you just want to check something quickly, without even changing which editor you’re using.
(For those of you who haven’t used Eclipse, a view is a window like the Output window in VS.NET.
Pretty much any window which isn’t an editor or a dialog is a view.)
Update! VS 2005 has these features too!
F12 is used to go to a definition
(there may be a shortcut key in Eclipse as well to avoid having to use the mouse – I’m not sure).
VS 2005 also has the Code Definition window which is pretty much identical to the Declaration
view. (Thanks for the tips, guys 🙂
Better SourceSafe integration
The source control integration in Eclipse is generally pretty well thought through, but
what often amuses me is that it’s easier to use Visual SourceSafe (if you really have to – if you
have a choice, avoid it) through Eclipse (using the
free plug-in) than
through Visual Studio. The whole binding business is much more easily set up. It’s a bit more
manual, but much harder to get wrong.
IDEs understand code – so why do most of them not allow you to see differences in code terms?
Eclipse does. I can ask it to compare two files, or compare my workspace version with the
previous (or any other) version in source control, and it shows me not just the textual
differences but the differences in terms of
code – which methods have been changed, which have been added, which have been
removed. Also, when going through the differences, it shows blocks at a time and then what’s
changed within the block – i.e. down to individual words, not just lines. This is very handy
when comparing resources in foreign languages!
Compile on save
The incremental Java compiler in Eclipse is fast. Very, very fast. And it compiles in the
background now, too – but even when it didn’t, it rarely caused any bother. That’s why it’s
perfectly acceptable for it to compile (by default – you can change it of course) whenever you
save. C# compiles a lot faster than C/C++, but I still have to wait a little while for a build to
finish, which means that I don’t do it as often as I save in Eclipse. That in turn means I see some
problems later than I would otherwise.
Combined file and class browser
The package explorer in Eclipse is aware that Java files contain classes. So it makes sense to
allow you to expand a file to see the types within it:
That’s it – for now…
There are plenty of other features I’d like to mention, but I’ll leave it there just for now.
Expect this blog entry to grow over time…