An introduction to Eclipse for Visual Studio users

Visual Studio and Eclipse compared and contrasted


All integrated development environments (IDEs) share similarities because they're all built for the same purpose. But they have differences, too. Some of these can be attributed to application domains, but others result from the IDE design.

Obviously, Microsoft Visual Studio and Eclipse differ: The Java™ programming language is different from C/C++/.NET, and Java was the first language supported by Eclipse. The two are also different because Eclipse aims to be an IDE for "everything and nothing in particular," introducing more generic and customizable features. Eclipse is also available on more operating systems. However, our intent is not to enumerate all the differences between Eclipse and Visual Studio.

Without being too philosophic about IDE design, this article presents the main differences between these IDEs. It's intended for anybody who has been using Visual Studio for a while and is beginning to use Eclipse. This article doesn't teach Java programming in Eclipse and doesn't focus on Java-specific features (a good tutorial is listed in Related topics). Rather, it discusses the differences in general.

The Eclipse workspace

Generally speaking, the Eclipse workspace serves the same purpose as a Visual Studio solution: It organizes top-level projects, folders, and files in a hierarchical structure. However, there are some major differences. A Visual Studio solution merely lists the projects it contains with their interdependencies, configurations, version-control information, etc.

The Eclipse workspace does much more than that. It manages most of the nonproject information, such as global preferences, windows layout, and search and navigation history. Eclipse can't start without a workspace, and you can't close a workspace the same way you can close a Visual Studio solution. Although it is possible to switch workspaces in Eclipse, many users use a single workspace that contains all their projects.

Project structure

Eclipse projects differ from Visual Studio projects in the way they interact with the underlying filesystem. In Visual Studio, a project isn't strongly connected to its layout on the filesystem: You can add a file from c:\temp\ to a project located in d:\work, and Visual Studio records the reference to a new file and opens it like any other file. Folders (like "header files") don't correspond to filesystem folders (internally, such folders are called filters).

In Eclipse, the structure of a project's elements must correspond to their layout in the underlying filesystem. For example, if the Eclipse project HelloWorld (see Figure 1) is located at c:\eclipse\workspace\HelloWorld, then README.TXT is located at c:\eclipse\workspace\HelloWorld\src\README.TXT.

Figure 1. A simple HelloWorld project
A simple HelloWorld project

Eclipse also wants to be in sync with the files under the project directory. If you delete a file or a folder in Eclipse, it disappears from the filesystem. However, when you add or delete the same file using Windows® Explorer, the related resource in Eclipse becomes out of sync, which may upset Eclipse during some operations. In such a case, you should manually refresh the project by choosing Refresh from the project's right-click menu. You can tell Eclipse to automatically synchronize with the filesystem by selecting Refresh automatically option in the Eclipse preferences.

Linking resources into Eclipse

The strict workspace structure was how things began. Although projects could be stored outside the workspace directory, early Eclipse versions couldn't even open an external file (today, you choose File > Open File). UNIX® users were lucky because they could emulate a flexible project structure using symbolic links, but Windows users didn't have such privileges. Today, Eclipse supports linked resources at the IDE level.

Linked resources in Eclipse behave much like UNIX symbolic links. For example, to add a large test input file to the project without copying it from its original location, choose File > New > File, and, in the window that opens, click Advanced (see Figure 2). After they're added, linked resources are decorated with a small arrow over their icons (see Figure 3).

Figure 2. Adding a linked file
Adding a linked file
Adding a linked file
Figure 3. Linked file in the HelloWorld project
Linked file in the HelloWorld project

Tip: Using linked resources to improve performance

Linked folders can be useful when you're dealing with large projects that reside on remote locations, such as file servers or ClearCase dynamic views. Although source files can benefit from being properly backed up and otherwise managed, there are few reasons to store the generated .class files on such remote storage. In projects with more than a few hundred source files, you can dramatically improve the performance of many operations if you store the generated files on the local machine.

In Visual Studio C++ projects, you can improve build performance by setting the intermediate directory to a local location. In Eclipse, you can achieve the same effect by using a linked output folder that points to a directory on the local machine.

See Related topics for additional information, including how to use variables to define platform-dependent link targets, such as using a temporary directory at /tmp on UNIX and at c:\temp on Windows.

Reducing clutter with working sets

As mentioned, many developers load all their projects into a single Eclipse workspace. It's convenient, but it can sometimes create too much clutter. In addition to closing unnecessary projects, you can define working sets: groups of elements (projects, folders, classes, etc.). Eclipse can use working sets in different views (such as Package Explorer) and operations (like searching). See Related topics for additional information.

The local history

One of Eclipse's coolest features — and one that Visual Studio doesn't have — is the local history. Each time you change a file, class, or method, Eclipse records the change in its local history. Then, you can compare a file to what it was a few minutes, hours, or days ago. If a file is deleted, invoking Restore from Local History from its parent's context menu can bring it back.

The local history isn't a version-control replacement. It's more like a super-undo engine with configurable limits for the number of history days and the allotted storage capacity.

Building projects

Contrary to the Visual Studio approach, in which a project has a single project type (C++/C#/J#), Eclipse projects can have zero, one, or multiple natures. For example, Java projects in Eclipse have a Java nature, and Dynamic Web projects (created using Eclipse WTP; see Related topics) have a Java and a (metaphoric) Web nature. A project nature defines a list of builders that run when the project is being built. For example, the Java nature adds a builder that compiles Java source files into .class files, and the Web nature adds a builder that validates the XML and HTML files.

Building projects automatically

At their first encounter with Eclipse, many look for the Build command. But to their surprise, either they can't find it or they find it's disabled. That's because unlike Visual Studio and some other IDEs, Eclipse has an automatic build feature. In Java projects, every time a Java file is modified, Eclipse compiles the relevant files, including files indirectly affected by the change. Automatic build is a great way to quickly discover compilation errors that affect other files. Many operations, such as Java search, rely on these build results.

Customized builds

Often — mainly for C++ projects — Visual Studio projects use custom build steps to perform nonstandard build tasks. Custom build commands are plain command-line instructions in Visual Studio projects. Eclipse, on the other hand, can run stand-alone programs and Ant build scripts. For example, you can use an Ant script to build and deploy a Java Archive (JAR) file containing the project's classes whenever a project is rebuilt. An editor for Ant's build.xml files is included.

You can configure custom project builders on the Builders page in the project's properties window, and you can define and run global scripts by choosing Run > External Tools.

Run and debug

Eclipse doesn't have the notion of startup projects, as does Visual Studio. The difference can be attributed to language differences, but Visual Studio further restricts its users by generating a single executable per project and allowing different launch parameters, such as command-line arguments, only for different project configurations. Managing multiple configurations just for the sake of having different command-line arguments is a bad idea in most situations.

Eclipse uses launch configurations to collect the parameters used to launch an application. For Java programs, the main class name and the command-line arguments are such parameters. You can have separate launch configurations for any class with a main() method in the project. A new configuration is automatically created when you launch an application with a new main class using the Run > Run As command. You can also use the Run window (Run > Run) to create and delete launch configurations.

By default, launch configurations are local to the workspace and aren't part of the project, which means they aren't shared with other team members. To save the launch configuration in the project, use the Common tab of the Run window, as shown below.

Figure 4. Changing the location of launch configuration
Changing the location of launch configuration
Changing the location of launch configuration

The Debug perspective

Eclipse has no debug mode — just the Debug perspective you can switch to and from. The main Debug view lists all the programs being run or debugged and lets you debug several programs at the same time, which is a little more difficult to do in Visual Studio. Read "Debugging with the Eclipse Platform" (see Related topics) to learn more about the debugging features Eclipse has to offer.

Eclipse plug-ins

In addition to being a great free open source Java IDE, the most important feature of Eclipse — which accounts for much of its success — is its open extensibility architecture. Most Eclipse features can be extended or are accepting contributions from plug-ins. In fact, many Eclipse features use the same extensibility architecture that is available for the general public.

The business-friendly open source license Eclipse uses encourages the development of commercial and open source plug-ins. No wonder more than 800 plug-ins are listed on the official plug-in marketplace at Eclipse Plugin Central.

In addition to plug-ins, which integrate into an existing Eclipse installation, some companies have built full-featured IDEs on top of Eclipse, including all IBM® Rational® tools, CodeGear JBuilder 2007, and Genuitec MyEclipse. Typically, these products offer tools for modeling, Web development, and visual design. See Related topics for products and plug-in directories.

Additional Eclipse projects

The basic Eclipse software development kit (SDK) contains only the Java IDE. Toolkits for other languages (C/C++, PHP), modeling tools, and additional extensions are being developed under the Eclipse umbrella and can be installed as Eclipse plug-ins. See Related topics for more information about Europa, the latest simultaneous release of the top 21 Eclipse projects in 2007, and Callisto, the previous release of top 10 projects in June 2006.

The Update Manager

Whenever you download Eclipse for the first time or as an upgrade, you get a plain compressed file you extract into an empty directory, with no installer to perform any configuration or to create a desktop shortcut. However, for plug-ins, Eclipse has the Update Manager (Help > Software Updates), which manages both installations and updates. It can also enable and disable plug-ins, similar to what the Add-in Manager does in Visual Studio.

The Update Manager installs or updates plug-ins from update sites (either local or on the Web). To install new plug-ins, you must find the update site URL on the vendor's Web site and manually enter it in the Update Manager window. (Some vendors have built full-featured installers that interact with the update manager behind the scenes.)

To a lesser extent, Eclipse supports installing plug-ins by manually copying them into the appropriate directories. This method isn't recommended, and it can cause inconsistency in the Eclipse configuration. See "Basic troubleshooting" for more information.

When you need help

If you're new to Eclipse, you'll probably have some questions. And after using it for a while, you may discover a couple of bugs or may wish to suggest new features. This section surveys the different support options.

Basic troubleshooting

Everybody knows that sometimes, the IDE can misbehave. With Visual Studio, you can reset everything to the factory state by typing devenv /setup at the command prompt. Eclipse provides a similar command-line switch. Running eclipse.exe -clean at the command line rebuilds most information about the installed plug-ins. The -clean option may be useful if you've installed a new plug-in and it refuses to show up.

When Eclipse misbehaves, you may also want to check the error log. To open the Error Log view, choose Window > Show View > Error Log. The raw log is located in the <workspace dir>/.metadata/.log file.


If you've been working with Microsoft products, you know that you can get help on the Microsoft Developer Network (MSDN) forums and newsgroups. The Eclipse community has its own newsgroups (see Related topics), and many Eclipse regulars are there to help you out.

Report bugs and ask for new features

Unlike the Microsoft feedback feature on the Microsoft Connect Web site, which is aimed at providing customer support, Eclipse Bugs is the actual bug-tracking system used by Eclipse developers. With Eclipse Bugs, you can not only search, report and vote on bugs but also add yourself as a CC on somebody else's bug, see who is assigned to fix it, learn the version in which it should be fixed, and much more. You can post feature requests using the same interface (see Related topics).

Premium support

In addition to the open source spirit of Eclipse Bugs and community help, some companies need a commercial level of support for their development teams. If you purchase a product that is built on top of Eclipse, its vendor should provide support for the product, including the underlying Eclipse components. If you use the basic Eclipse SDK, you can check the IBM Rational Elite Support for Eclipse program with a worldwide 24x7x365 support plan.


We have discussed how Eclipse approaches some common IDE principles and tasks. The workspace-centric approach and project structure on one hand and the great flexibility of the UI design and launch configurations on the other make Eclipse unique in its IDE design. And the open-extensibility architecture makes Eclipse a platform for a great variety of third-party plug-ins and products.

If you haven't done so yet, read the "Eclipse for Visual Studio developers" tutorial (see Related topics), which gives a good introduction to Java development in Eclipse. However, Eclipse isn't all about the Java programming language. Check the Callisto and Europa releases for additional Eclipse projects, such as the C++ IDE. Then visit Eclipse Plugin Central and download some popular Eclipse plug-ins.

Downloadable resources

Related topics


Sign in or register to add and subscribe to comments.

Zone=Open source
ArticleTitle=An introduction to Eclipse for Visual Studio users