An introduction to Eclipse for Visual Studio users

Visual Studio and Eclipse compared and contrasted

Eclipse is a new world for Microsoft® Visual Studio® developers, and getting started with Eclipse can be confusing. New concepts, such as plug-in architecture, workspace-centric project structure, and automatic build can seem counterintuitive at first. Learn about these and other differences between the two environments, so that you can begin to feel at home with Eclipse.

Share:

Genady Beryozkin (mail@genady.org), Software Developer, Content Developer

Genady BeryozkinGenady Beryozkin is a software developer with more than nine years of experience. He used Visual Studio for various C++ and C# projects, and has been using Eclipse for Java development since even before its initial 1.0 release in 2001. In 2002, he created the RMI plug-in for Eclipse, which helps developers to effectively develop, debug, and run applications that use the Java Remote Method Invocation (RMI) technology. He holds a bachelor's (summa cum laude) and a master's degree in computer science from Technion, Haifa, Israel.



21 August 2007

Also available in Russian Japanese

Develop skills on this topic

This content is part of a progressive knowledge path for advancing your skills. See Open source development with Eclipse: Master the basics

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 Resources). Rather, it discusses the differences in general.

The Eclipse workspace

The workspace directory

The Eclipse workspace is a directory in the filesystem that contains a special .metadata subdirectory. The .metadata directory contains all the workspace's private information, such as settings, caches, etc. Normally, you shouldn't modify any files in the .metadata directory. The workspace directory is also the default location for new projects in Eclipse.

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

Origins of the Eclipse project structure

The strict correspondence between a project's structure and its filesystem layout was probably influenced by the mandatory correspondence between Java packages and their layout on the filesystem. In the Java language, the class p1.p2.p3.Class1 must reside in the directory p1/p2/p3.

Visual Studio languages (C/C++/C#, and even J#) don't mandate such a directory structure. Consequently, the correspondence between the project's structure and its filesystem layout isn't that strict in Visual Studio.

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
Figure 3. Linked file in the HelloWorld project
Linked file in the HelloWorld project

Tip: Using linked resources to improve performance

Using a linked folder as a Java output folder

To use a linked folder as a Java output folder for an existing project, you first need to make sure your project uses separate folders for source and .class files (if it doesn't, you need to move the source files to a separate folder). Then, open the Navigator view, turn off the automatic build, delete the old output folder, create a new linked folder with the same name, turn the automatic build back on, and rebuild the project with Project > Clean.

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 Resources 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 Resources 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 Resources) 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

Building non-Java projects

Automatic build is perfect for Java projects because the internal incremental compiler (Eclipse doesn't use javac) can handle small code changes quickly. Although builds run in the background, for project types (such as CDT projects), in which a small update can trigger lengthy compilation, you may prefer to turn off automatic build (Project > Build Automatically). You can then run the build manually (Project > Build All) or let Eclipse do the build before running an application.

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

Languages and entry points

Visual Studio languages (C++/C#) can have only one entry point per executable, which is determined at link time. The Java programming language allows multiple entry points (main methods) at compile time. The entry point is determined on the command line when the program is launched.

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

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 Resources) 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 Resources 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 Resources 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.

Newsgroups

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 Resources), 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 Resources).

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.


Conclusion

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 Resources), 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.

Resources

Learn

Get products and technologies

Discuss

  • Visit EclipseZone, an online community by and for Eclipse users.
  • Visit Planet Eclipse, a collection of Eclipse blogs.
  • The Eclipse Platform newsgroups should be your first stop to discuss questions regarding Eclipse. (Selecting this will launch your default Usenet news reader application and open eclipse.platform.)
  • The Eclipse newsgroups has many resources for people interested in using and extending Eclipse.
  • Participate in developerWorks blogs and get involved in the developerWorks community.

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into Open source on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Open source
ArticleID=247574
ArticleTitle=An introduction to Eclipse for Visual Studio users
publish-date=08212007