Does anyone remember the days when there was a virtual cornucopia of development tools? Well, the latest bounty is even larger. But when it comes to integrated development environments (IDEs), an interesting consolidation has occurred. While the number of unique IDEs continues to shrink, IDE sophistication is on the rise.
It's becoming increasingly difficult to start a brand new IDE from scratch. Likewise, it's more difficult to maintain a unique IDE that supports a range of hardware and software platforms without a significant amount of money to continually fund its development. Still, plenty of room exists in the market for unique IDEs that target specific environments. Not surprisingly, more general IDEs that are open to thirdparty plug-ins continue to rise to the top. Some, such as Microsoft's Visual Studio and Green Hills Software's Multi, have a long track record of formal agreements with a number of third-party solution providers.
On the open-source side of things, Eclipse has garnered a surprising share of third parties that have created plug-ins as well as companies that have used Eclipse as the basis for their own IDE (see "A Total Eclipse," p. 54). Wind River is just one of many major vendors that has migrated from their proprietary IDEs to Eclipse.
Taking in the lay of the IDE land isn't as easy as it sounds. The wide range of features an IDE has and the support it provides make developing an IDE a difficult task. One way to approach it is via the target operating system or platform and the programming language involved (Fig. 1).
Most developers are familiar with Microsoft's Visual Studio. It handles a wide range of programming languages (due to Microsoft's support in addition to numerous third-party compiler providers), but its target platform is the Windows environment. Such linkage between an IDE and the primary vendor's platform isn't uncommon.
Although Eclipse is shown in the upper right of the software graph, specific implementations from a variety of vendors tend to fit other areas. MontaVista's DevRocket Eclipse-based IDE specifically targets MontaVista Linux. TimeSys takes a similar approach, but it customizes it even further with its LinuxLink Web-based configurator. Likewise, vendors such as AdaCore contain Eclipse plug-ins that target a range of platforms, yet they're specific to a particular language. In this case, it's Ada.
Looking at IDEs from a hardware perspective significantly changes the distribution (Fig. 2). Eclipse covers a broad range, mostly because of the number of companies that use it. Some individual companies use Eclipse-based solutions to cover their range of processors, like Freescale and its CodeWarrior product. But coverage by other vendors often isn't as broad. This view of IDEs highlights some of the more vendor-specific solutions like that in the DSP area, where Analog Devices' VisualDSP addresses the company's collection of digital signal processors (DSPs) and digital signal controllers (DSCs). The same is true for Texas Instruments' CodeComposer Studio.
As with VisualDSP++, CodeComposer is useful only for a specific set of hardware platforms; it doesn't apply to a GPU such as the Intel Pentium M. Microchip's MPlab handles Microchip's DSC and microcontroller offerings, so it's slightly higher on the chart due to the microcontroller support.
Keil and IAR primarily target the assembler, C, and C++ languages, which keep them together in the software view of the world. But they also tend to cover the same area in the hardware world.
THE COMPLEXITY CHALLENGE IDEs tend to consist of at least an editor, a compiler tool chain, and a debugger. In the hacking days of yore, even this combination was viewed with disdain by "real" programmers who did everything from editing to debugging via a command line interface.
It's still possible to do this, but many more management, design, and diagnostic aspects are in play as programming projects become more complex. IDEs have risen to this challenge, but also at the cost of growing complexity.
Project and source-code management are mainstays within IDEs. Linkages to programming frameworks are integrated into the editors and help systems. Even bug tracking is integrated into the build and debugging process.
Initially, IDE vendors took it upon themselves to implement all of these features. The task is daunting, though, even for large companies such as IBM, Microsoft, Sun Microsystems, and Wind River. It was clear that embracing third parties was going to be the wave of the future, and it would require a plug-in architecture. The big question was how open this process would become.
Reprints
