Choosing the right standard to support can be tricky, however. Two options available to the developer are to go with a proprietary technology like Microsoft's Visual Studio or an open-source technology like Eclipse. But how does a developer choose between the two standards? Let's take a look at the two, including the pitfalls and advantages of each.

Microsoft Visual Studio is one of the most widely implemented Windows development environments available today. Almost every engineer coming out of school is familiar with it, and it can easily be found at any software store. Using an embedded IDE based on Microsoft Visual Studio allows engineers to take advantage of a common interface, making it easier for Windows developers to transition over to embedded development. The plug-in application programming interface (API) is well-documented and easy to use, shortening development time. The software also includes a full-featured text editor, Windows compiler and Windows debugger. Third parties offer cross-compilers and debuggers.

While Visual Studio provides many advantages, it also has its downside. First, the software is not free. Either the tools developer will have to pay to include a copy with its own software, or it will be up to the customer to purchase Visual Studio. Second, while creating a plug-in is relatively easy, full integration is not. This is because Microsoft limits the access that plug-ins have to Visual Studio's resources, such as a plug-in of a new debugger. Finally, with no visibility into Microsoft's road map, and as Microsoft releases new versions of Visual Studio, the tools developer continuously faces the dilemma of whether the current version of the software will work with the new one. If caught unaware, the developer may be forced to pull resources from other projects to support the latest version of Visual Studio and to help integrate it into the current development environment. The developer must also decide whether to spend the resources to support both versions of the software or force its customers to purchase the upgrade. This may leave the end user with an environment that is no longer supported.

And while Visual Studio is very popular with Windows developers, it has yet to catch on with most of the embedded-tools vendors who, historically, have developed proprietary IDEs. There are tools, such as SourceSafe for release management, that work for both Windows and embedded developers, but there are few embedded-specific tools.

Eclipse is a Java-based, open-source IDE developed to provide a common platform for tools developers. Sponsored by IBM Corp. and maintained by the Eclipse Foundation, Eclipse has been available for about two years. Licensed through the Common Public License (CPL) and provided with open-source code, the Eclipse Software Developers Kit (SDK) offers key advantages over Visual Studio. First, the complete source code is available to developers, so plug-ins can be much more tightly integrated into Eclipse. Second, developers can distribute Eclipse with their tools and can standardize on a particular version, letting them control their own destiny. One of the only reasons to change versions might be to support cross-vendor solutions. And of course, it's free.

The Eclipse SDK comes with a basic set of tools for Windows development, including, among others, a text editor, C/C++ compilers and debugger. This creates an environment that is similar to Visual Studio but without all the bells and whistles that Microsoft has included. The tools developer can focus on either one piece of the IDE (such as adding an embedded compiler or debugger) or can create a full suite of tools, pulling together a feature-rich editor, cross-compiler and embedded debugger, depending on the scope of the project. If the end user likes the developer's suite, but prefers a different editor, for example, or if the user needs functionality that the tools vendor doesn't provide, the user simply finds a viable component and drops it in. The versatility of environments that Eclipse offers to the tools developer and end user is another way in which it stands apart from Visual Studio.

Also, because Eclipse is written in Java, it provides a graphical user interface that can be run from many different host operating systems, allowing tools developers to more easily support different hosts (a growing need as Linux hosts are becoming more popular with embedded developers). Of course, as Linux continues to gain popularity as a host operating system, tools developers will be pushed harder to support multiple environments. Originally designed for host development, Eclipse is gaining momentum in the embedded space and there have been initiatives to support it. Already, GNU (a recursive acronym for "Gnu is Not Unix") cross-compilers and versions of the GNU debugger are offered for Eclipse.

On the downside, Eclipse contains rigid build directories rules, making it difficult for developers to import legacy code with multiple directory trees. Depending on the project, restructuring these directories can be either a nuisance or a nightmare. New users are also faced with having to learn the new paradigm. While this may not necessarily be a difficult task, it does add to the user's typically hectic schedule, particularly if the user is also new to embedded development. Also, while the CPL is much more lenient than the General Public License and does allow vendors to sell proprietary plug-ins like embedded debuggers, enhanced text editors or cross-compilers, the tools developer must be very careful not to link the Eclipse libraries into their code. Once this happens, the source code becomes public domain and must be distributed with Eclipse, cost-free.

So which standard should developers choose? Visual Studio's major advantages are the number of people familiar with the software and its integration with Microsoft's Windows CE. If developers are working with or developing tools for Windows CE, Visual Studio has an advantage due to the tight integration via the .NET framework.

However, as Eclipse continues to gain popularity in the embedded space and more engineers become accustomed to using it, Visual Studio's advantage of familiarity is sure to fade. There is a growing trend in the embedded industry to move to Eclipse; many embedded real-time operating systems and tools vendors have already announced initiatives to add support. Eclipse is quickly growing, primarily because of the tighter plug-in integration, portability and cost advantages that it offers, making it a strong contender for the IDE of choice going forward.

In the end, choosing a standard comes down to a matter of different priorities for the developer and end user. For the end user it may be functionality, current support and the availability of third-party tools. For the developer, it's very likely going to be the integration, cost and control of the software's future.

Jeff Womble (jeff_womble@mentor.com) is a product manager for Accelerated Technology, the embedded systems division of Mentor Graphics Corp. (Mobile, Ala.).

See related chart