Electronic Design

Anatomy Of An IDE

The Eclipse plug-in architecture makes it a general-application platform.

Developers have found Eclipse to be a great IDE for application development, but its modular, microkernel design equally suits it for applications unrelated to programming, like system management. Looking inside the Java-based Eclipse environment shows how it's more like an operating system than a simple application. Initially used as a Java integrated development environment (IDE), it has now exceeded this task through its plug-in architecture. The Eclipse C/C++ Development Tools (CDT) project added C/C++ application development support, but this is just the tip of the iceberg. Cobol is on the horizon, and more language tools are coming.

IBM (www.ibm.com), TimeSys (www.timesys.com), and QNX (www.qnx.com), among other companies, have used Eclipse for commercial system development tools where application development is just a subset. Eclipse's liberal Common Public License (CPL) allows commercial products to be created without royalties. The resulting product can be open or closed source.

Companies have been approaching Eclipse from three directions. The complete-system products already mentioned is one. Another is as a plug-in provider. A large number of open-source projects and commercial companies are providing Eclipse plug-ins. These tend to target application developers. For example, there are over half a dozen source-code management plug-ins for Eclipse.

The third approach is to use Eclipse as an application platform. In this case, the development plug-ins probably wouldn't be used. Application-specific plug-ins would replace them. This method offers many advantages to application developers. First, it provides a well defined platform to build an application. Second, its plug-in architecture makes third-party enhancements possible. An added benefit is a well documented plug-in architecture. Obviously, Eclipse doesn't suit all applications, but it may be the best choice when modularity is a key benefit.

Eclipse runs on top of a Java virtual machine, making it very portable. A wide range of operating systems and processors support it. The Eclipse platform runs on a small microkernel that sets up the environment and handles the various plug-ins. The base interface handles many development oriented tools like a debugger or Ant, a makefile system. However, these aren't required for using the Eclipse platform, just the Eclipse IDE. Tools like version control, team management, and online help can be beneficial to many non-IDE applications.

Typically, an application and the Eclipse IDE take advantage of the workbench interface. This is built on Standard Widget Toolkit (SWT), which provides a generic low-level graphics and widget set. JFace is a user interface framework built on SWT. The Java Development Tools (JDT) include plug-ins, such as editors and compilers, and may not be needed for some applications built on Eclipse.

The plug-in architecture is very flexible. The basic plug-in is described by an XML (eXtended Markup Language) file called plugin.xml. Each plug-in has its own directory. Plug-in fragments use the same XML file and directory hierarchy. This permits plug-ins to be easily customized and support different languages.

Although written in Java, a plug-in can be the front end to native applications. The plug-in architecture enables plug-ins to work with each other through exported interfaces. Additionally, the interface mechanism provides plug-ins access to the Eclipse application programming interface (API). It is now up to developers to take advantage of Eclipse as a platform, not just as a tool.

See associated figure.

Hide comments


  • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.