Here Come The IDEs:

The visual software development environments that are so popular on Windows and the Mac are making their way to Linux. We took a look at several IDEs for programming in C/C++, Java, Perl, and Python.

In the Linux and Unix world, most developers are accustomed to a fairly standard set of command-line tools. gcc, gdb, emacs, or vi, etc. are the “one true way” to develop software. Meanwhile, the Windows and Macintosh worlds have always looked somewhat different. On those platforms, there often is no command line, and developers have become accustomed to working in a visual or Integrated Development Environment (IDE). Now that it is entering the mainstream, IDEs are becoming available for Linux as well.

An IDE is basically a collection of software development tools that are bundled together and which interoperate to make life easier for the developer. They typically provide a single interface to the following software components:

  • A program editor that has built-in knowledge of the syntax and structure of the programming language that you’re working in.
  • Support for build and project management infrastructure that is appropriate for the language and type of project you’re working on (such as Makefiles, the XML files used by Java, build tools such as ant and so on).
  • Integrated support for source code or version control systems such as CVS.
  • A compiler that’s appropriate for the language you’re working in and any support tools that it requires (linkers, loaders and so on).
  • A selection of support libraries, include files, classes, or jar files that are appropriate for the language and projects you’re working in.
  • A debugger that’s appropriate for the language you’re working in.

The beauty of an IDE is the tight integration between these tools. In most IDEs, compiling a program in one window will simultaneously display any errors in another. If compilation errors occur, you can click on any of them to jump directly to the line and file in which the error occurred. Similarly, many enable you to insert a function call and will automatically prototype the arguments to that function for you (thus reducing the chance you might accidentally swap parameter types or sequence).

One of the best features of open source efforts such as Linux is that there is an almost bewildering selection of free tools available. Of course, this means that many developers have already fallen in love with specific text editors, debuggers, compilers and so on.

For this reason, flexibility is a key issue to examine when comparing different IDEs. Do they have the capacity to easily integrate existing tools? Or, are they locked into the set of tools that the IDE provides? For example, I’ve used emacs as my editor of choice on a variety of platforms for the past 17 years. Can I easily use emacs as my program file editor within an IDE?

This roundup compares the most popular IDEs in the most popular languages available for Linux today. It also examines some contenders just appearing on the radar screen, which may make life easier for your next project. The table on pg. 40 provides an at-a-glance comparison of the features of the IDEs discussed.

Each IDE is compared to the others in terms of ease of installation, hardware and software system requirements, its memory footprint and performance when working on a sample project, its usability, and the libraries, components, or classes it includes (such as GNOME, KDE, or Qt, the Linux equivalent of Microsoft Foundation Classes).

The number of languages available for Linux and the number of IDEs available for each language make any roundup attempt a formidable undertaking. In our efforts to narrow the field, we’ve tried to select the best available and most widely used commercial IDEs and open source projects. Unfortunately, there are now more IDEs available than we can fit in one roundup, and you can be sure we’ll be looking at more of them in upcoming issues.

Metrowerks’ CodeWarrior

Figure One: Metrowerks’ project desktop dialog.

Metrowerks CodeWarrior is one of the oldest and best-established IDEs available for developing C, C++, and Java projects on the MacOS, Windows, and most recently, Linux. CodeWarrior is capable of producing binaries for these systems and a wide variety of other platforms, including the Sony Playstation, Playstation 2, the Palm OS, and Sun’s Solaris.

Figure One shows a sample project opened in Metroworks’ CodeWarrior for Linux. In theory, using CodeWarrior on a Mac, Windows, or Linux box should be an identical experience, with the exception of a few differences in the window managers on each platform.

For example, not all Linux window managers support drag and drop, so you may find that CodeWarrior is most easily used on Linux in conjunction with a desktop environment such as GNOME, KDE, or a more advanced window manager such as WindowMaker or Afterstep. In reality, the Linux version of CodeWarrior lags behind the Mac and Windows versions by a number of features that should have been present but were incomplete or not quite right.

Installing CodeWarrior is as easy as inserting the CD, mounting it, and running an install script. CodeWarrior comes with some example projects and a nice tutorial that walks you through importing an existing open source project. At a minimum, system requirements include a Pentium K6 or better processor, 64 MB of memory, a minimum of 40 MB of disk space, and Red Hat 5.2 or better. Our own testing was done on a Pentium II laptop with 500 MB free disk space, 96 MB of memory and running Red Hat 6.2.

After starting CodeWarrior, a small menu bar appears from which you can define a new project, open an existing project, and so on. Creating a new project or opening an existing project requires navigating through CodeWarrior’s file and directory selection dialog boxes, which we found to be somewhat tedious under GNOME. These were an endless series of “Select Directory” and “Open” dialogs until we managed to locate the directory where we’d placed our working copy of the example files. CodeWarrior begins its directory selection dialogs relative to the location where it’s installed, not your working directory, and there didn’t seem to be an option to override this.

IDE Metrowerks 6 Editor
Figure Two: Editing files in Metrowerks’ bundled editor.

Once you’ve managed to create a new project in a familiar location, you can quickly reopen it using the “Open Recent” command on CodeWarrior’s “File” menu. Subsequent opens are relative to the directory where you’ve already opened a file or project, but it’s a pain to always have to start new projects “miles away” from where you want to be. Once you’ve opened a project, it’s easy to open and edit any of the files associated with that project by double-clicking, which opens the files in the editor that is bundled with CodeWarrior, as shown in Figure Two .

CodeWarrior’s documentation takes a radically new approach to being irritating. While Metrowerks seems to offer a fair number of potentially useful paper documents, you don’t get them with the product. The only printed document that came with our review copy of the product was the “Code Warrior: Targeting Red Hat Linux” document, which covers installation and provides tutorials to help you get started. To get any of the other documents, you have to buy them separately. One of the documents mentioned in the tutorial doesn’t even seem to exist, which is unfortunate since it promised to cover using the IDE. The absence of detailed, printed documentation is a major obstacle to actually diving in and using CodeWarrior for serious development work. Even more unfortunately, the tutorials are somewhat less than accurate for both CodeWarrior on Linux version 4.0 (which they are currently shipping) and version 6.0 (which they will soon be shipping).

CodeWarrior 6.0 supports importing existing projects’ Makefiles into a CodeWarrior project, while version 4 did not. Either way, clicking on errors generated during the compilation process didn’t jump to the location of the error. Even when using CodeWarrior’s own editor, it was necessary to manually open the file in which the error occurred and find the correct line.

We were subsequently able to plug our favorite editor (emacs) into CodeWarrior by selecting a “Use External Editor” checkbox from a project settings screen, whereupon it used the value of the EDITOR environment variable in the shell from which we’d started CodeWarrior. Unfortunately, there was no way to train CodeWarrior to use the right commands from the external editor to do its “find the right line” magic.

In light of these frustrations, we were forced to conclude that while possessing many potentially promising features, CodeWarrior for Red Hat Linux is not yet ready for prime time.

CodeForge’s C*Forge

Figure Three: C*Forge’s primary project dialog.
Figure Four: C*Forge’s project desktop dialog.

C*Forge is an IDE that packs a surprising number of configurable options and supported platforms into an easy-to-use development environment. The apparent simplicity of its interface and development environment, and the richness of the configuration options that it supports, makes it an IDE in classic Unix style.

C*Forge comes in various flavors, which together support the integration of Linux compilers and environment variables from “A” (Absoft FORTRAN) to “Y” (Yacc), including integrated support for open source documentation tools such as TeX and SGML. Customization options are easily accessed at any time through an icon-oriented project bar and standard menu items. Figure Three shows C*Forge’s “Open Project” interface.

The IDE interacts with the user via two primary windows — the project window and the project desktop window. The latter is a window that makes it easy to define dependencies because of its use of drag and drop. As with CodeWarrior, you may therefore find that C*Forge is most easily used on Linux in conjunction with a desktop environment such as GNOME or KDE or with a more advanced window manager such as WindowMaker.

CodeForge’s C*Forge supports a large number of subprocesses that can be executed from within the IDE. These include a compiler, a debugger, and an editor (no surprises there!), as well as tools for comparing two versions of files (diff) and process status tools that can help you determine if your current project has hung or if it is looping.

C*Forge is essentially a Makefile builder, making it easy to define dependencies and file interactions, which can be very handy when creating large projects.

KDE’s KDevelop

Figure Five: KDevelop’s new project dialog.

KDevelop is an IDE for creating GUIs for the GNOME and KDE desktop environments, as well as desktop-independent user interfaces that use Trolltech’s Qt GUI library. Qt has occasionally received a bum rap due to the fact that it was not originally made available under the GNU GPL. As a matter of fact, this was one of the points that led to the development of GNOME as an alternative to KDE (which uses Qt). With Qt version 2.2, the library is now available under the GPL, and Open Source projects that use it must themselves be GPL. “Closed Source” projects that use Qt must still pay a licensing fee. Take that, proprietary software vendors!

Given that KDevelop is a GUI builder for rich, elegant user interfaces, it’s not surprising that KDevelop provides the richest IDE of those that were tested for this roundup. What is somewhat surprising, and pleasantly so, is the fact that KDevelop comes with a number of complete, thorough tutorials for both developing GUIs and using KDevelop.

These tutorials include a “User Manual to Kdevelop,” the “Kdevelop Programming Handbook,” “KDE Application Tutorials,” the “KDE Library Reference Guide,” a “KDE 2 Developer’s Guide,” and a C/C++ Reference Manual. The manual discusses KDE 2 features that are a superset of the standard KDE/Qt libraries.

KDevelop encompasses a number of other features that we had originally expected to find in most of the IDEs we tested, but did not. For example, during project development, KDevelop provides both GUI templates and syntax highlighting, with keyword help (via glimpse or htsearch) just a right click away. The number and scope of the GUI templates provided by KDevelop’s Application Wizard is stunning; they include KDE, Qt, and GNOME applications with:

  • A simple (empty) main widget
  • Session-management, a menu bar, a toolbar, status bar, and a code frame model that intrinsically supports document views
  • The same as the previous template, but also including OpenGL (Mesa) support
  • Session-management, a menu bar, a toolbar, status bar, and automatic support for KDE 2 MDIs (Multiple Document Interface)

While working on KDE and Qt projects, KDevelop provides a whizzy-tabbed interface that lets you quickly switch between viewing messages to windows containing stdin, messages to stdout, and breakpoints settings/ status/information.

The easiest way to summarize KDevelop is that it appears to provide support for “lib_kitchen_sink.so” for KDE and Qt graphical user interfaces. It is truly stunning as both an exemplary piece of open source software and an IDE with an amazing number of bells, whistles, and other pretty neat features.

IBM’s Visual Age for Java

IDE VAJ Startup Screen
Figure Six: The startup dialog for IBM’s Visual Age for Java.
Figure Seven: Initial IDE for IBM’s Visual Age for Java.

There seems to be some debate as to the status of IBM’s Visual Age for Java. While IBM’s marketing personnel insisted that the product was out of Beta and ready to ship, while the IBM developers we spoke to believed that the product was still in Beta. In any case, our review copy arrived with a photocopied label on the CD, suggesting to us that if the product is now out of Beta, it may have happened rather recently…

Regardless, Visual Age for Java (VAJ) is an incredible consumer of disk space, requiring storage in its “repository” for all past, present, and versioned Java projects. Each time a development team using VAJ as an IDE saves source code, or compiles it into byte codes, the source code for the relevant classes and the bytecodes are saved in the repository. Saving bytecodes that are easily compiled seems aberrant and is a sure-fire consumer of excess disk space.

VAJ starts up displaying the dialog in Figure Six (pg. 43), which provides you with a choice of places to start. In its defense, VAJ delivers a nice selection of starting locations, ranging from creating a new applet, class, or interface to working with a class or interface that you’ve already begun, or going to the Workbench.

VAJ also comes bundled with a large number of libraries, such as “BasicLook&Feel,” “(Java)Bean,” “StyleSheet,” and “Swing classes and utilities,” which make it easy to create GUI designs of various sorts. The package also comes with a nice tutorial application (which can be found under “Getting Started” in the online help — unfortunately, this tutorial is online only).

IBM’s VAJ can generate a template application for you, which provides a good starting point for your own Java applets, running either in a browser or standalone. Additionally, the IDE has some nice features, such as Java packages and being able to jump to and display variable and structure definitions, and it will even display the versions of the classes and Beans it provides.

Interestingly enough, though VAJ doesn’t support plugging in the editor of your choice, a downloadable tool (from http://www.paul-software.de) lets you do exactly this. This comes with a temporary license but costs real money if you want to use it long-term. (And for many of us, it’s worth a few dollars to use emacs with just about everything.)

In the end, we found the top-heavy, disk-hogging nature of VAJ to be somewhat unpleasant. For example, exiting from IBM’s VAJ takes quite a while as it updates your workspace. However, the top-heaviness seems to stem from the fact that all IBM Visual Age products are based on the IBM “Workbench” tools, which are themselves somewhat top-heavy. While having a standard set of tools across development environments has some definite advantages, top-heaviness is not one of them.

Sun Microsystems Forte for Java

IDE Forte Startup Screen
Figure Eight: The Forte startup blurb.
IDE Forte for Java
Figure Nine: The Forte GUI.

Forte is Sun Microsystems’ Java IDE, which is free but not open source. Forte provides access to all of the classes you’d expect from a Linux port of a Unix IDE, such as the Swing classes for GUI construction. Figure Eight shows the Forte window that is displayed as the tools initialize — the messages in the center of the window echo each step of the process so you know exactly what’s going on.

Forte is a robust IDE that automatically creates a default project that is a breeze to browse through and add classes to. As you can see in Figure Nine, Forte features separate windows for editing text, GUI editing, browsing objects, running applications and debugging.

Forte also provides a separate window that you can redirect output to during the GUI building process. The debugger window is especially interesting, as it makes it simple to set breakpoints within your Java code.

If you can overlook the fact that it does not make it easy to plug in your own (i.e., non-Sun-Microsystems’) preferred tools (such as your favorite text editor and debugger), then Forte is an elegant and powerful GUI builder. Given that it’s entirely free, it’s really hard to beat.

Of course, it would be nice to get the source, but hopefully Sun will get with the program soon enough.

Kylix – Borland’s New IDE


Kylix is the code name for Borland’s (now known as “Inprise”) port of their Delphi Pascal programming environment to Linux, with a little bit of their C++ Builder product thrown in.

IDE kylix
Figure Ten: Kylix’s GUI.

We installed Kylix onto a fairly stock Red Hat 6.2 test system running GNOME and enlightenment. While keeping in mind that the copy we received was very much a Beta, our initial install of Kylix was still slightly painful, requiring us to upgrade to new versions of glibc, libjpeg, and enlightenment. The first two of these are necessary in order to install Kylix, while the new version of enlightenment is required in order to take advantage of all of the GUI features that are available under Kylix.

Thankfully, the Kylix Beta CD includes RPMs for a suitable version of libjpeg (which is Linux- distribution-independent) and glibc (for Red Hat 6.2, Red Hat 7.0, Mandrake 7.2, and SuSE Linux). The CDs did not include the appropriate version of enlightenment. As a side note, the suggested minimum version of enlightenment (1.6.0) doesn’t even appear to be available in RPM format for RH 6.2 systems — at least I could not find it at http://www.rpmfind.net.

Ever since the TurboPascal days, Borland’s compiler products have delivered blindingly fast code, and they are continuing with this approach to application development for Linux with Kylix. While Kylix works under either the GNOME or KDE desktop environments, or under any X11 Window manager, it comes with GNOME and KDE menu enhancements that require a restart of the X Window System in order for them to become visible.

The Kylix GUI, shown in Figure Ten (pg. 46), demonstrates Kylix’s commitment to Rapid Application Development (RAD) under Linux by providing a forms/graphics editor, a code editor, an integrated debugger and an editor that even provides emacs key bindings (hooray!).

Kylix includes an early version of Borland’s VCL (Visual Component Library) called CLX, which provides Kylix users with an abstract component framework for Linux. The suite includes DataCLX, which provides quick connectivity to databases, and NetCLX, which provides quick connectivity to the Apache Web server. In future versions of Kylix, Borland plans to include Visual VCX, an abstraction that is used for drawing graphics using both the Qt libraries and GTK’s GDI, while simultaneously hiding the details of both from developers.

Borland’s inclusion of CLX and Visual CLX simplifies porting applications developed using its Windows products to Linux, which is a pretty good thing for all parties concerned. Existing Windows Delphi developers and developers who are new to Linux will appreciate Kylix’s attention to providing abstractions for database and drawing primitives on Linux.

Even in Beta, Kylix provides a full-featured IDE that should delight all Linux developers, not just new ones — but it should especially make life much simpler for those who are familiar with Windows and who are “crossing the chasm.”

In short, we believe that Kylix is a true RAD tool. That is, it should “Rapidly Accelerate Deployment” of Linux in the more traditional corporate enterprise.

Komodo – ActiveState’s Mozilla-Based IDE


Komodo is ActiveState’s new cross-platform IDE for Perl, Python, and JavaScript development. This means that the program can run on both Linux and Windows platforms. (Part of ActiveState’s corporate mission is to deliver both Perl and Python to the Windows platform.)

IDE komodo
Figure Eleven: Komodo’s GUI.

Actually, one of the most interesting aspects of Komodo is the fact that it is based upon the Mozilla Web-browser framework. Yes, you read that right — ActiveState has turned Mozilla into an IDE and has done a pretty good job of it.

To be sure, Komodo is still Beta software and, as such, has a few warts, but all of these are covered in detail in the release notes and README file. If you’re downloading Komodo, make sure you get the Komodo-1.0.0-tp3-15077 release or better. We encountered a few problems getting earlier technology preview releases running on our test systems.

As illustrated in Figure Eleven, Komodo has a nice, robust interface that makes it easy for even novice developers to get started. It provides you with a startup dialog that allows you to automatically create a sample project using your choice of Perl, Python, or Javascript with an XML driver file.

Once you’re successfully in Komodo, you will find that it has some great features, such as a debugger that works via regular expressions. Why hasn’t the Linux community come up with something like this before? To some extent, Komodo is the next-generation follow-up product to ActiveState’s ActivePerl and ActivePython projects. In light of that, it is no surprise that Komodo would provide features that enable you to monitor the execution of Perl and Python applications, making it easy for you to debug them at will.

If you’re designing Perl, Python, or Javascript applications, ActiveState’s Komodo should fascinate and inspire you with its tremendous power and capabilities. The only clues that this is a Beta release are the lists of defects and their associated limitations that are supplied in its release notes and README files. Some of these are fairly major, such as the lack of integrated support for printing and some occasional confusion regarding breakpoints.

Regardless, based on what we saw, the final product should be impressive. Even more impressive is the incredibly creative use that Komodo makes of the Mozilla project. ActiveState has contributed substantially to the Mozilla development effort as a result of their work on Komodo, and the two projects together are ringing endorsements of the power of Open Source.

If we could make just one request to the Komodo development team at ActiveState, it would be to please allow Linux folks to plug in our text editor of choice. We Linux developers can be really opinionated about which tools we like to use.

The Unintegrated Development Environment: The Standard Linux Software Development Tools

IDE emacs
Figure One: emacs — the “real man’s” IDE.

One of the design goals of Unix since its inception has been to provide a large number of relatively small tools, each performing a specific function. These tools then communicate and interoperate with each other through pipes or subprocesses.

A classic example of this is the emacs text editor. Though not really a “small tool” by anyone’s standards, emacs is an “environment” that lets you tie together many small tools and, in many ways, provides a similar environment to the IDEs we’ve looked at in this roundup.

Besides emacs, Linux also comes with a number of other software development tools that make life easier for programmers. From make (a tool that basically invokes other tools) to gcc (the GNU C-Compiler) to gas (the GNU Assembler) and gdb (the GNU debugger), all of Linux’s open source development tools can be “integrated” (to a degree) and used together to write, test, and debug your code.

For example, emacs supports language-specific editing modes, and it’s easy to open a subshell to run make to build and execute software development projects. Figure One shows emacs running in exactly this configuration — one buffer displaying a C program module, one buffer displaying the associated Makefile for the project, and a third displaying a subshell in which make has been run to compile a module.

Together, these tools represent an extremely powerful software development system that can rival any commercial development suite on the market. In fact, many old-school developers will tell you that emacs (or vi), gcc, and gdb (etc.) represent the “real man’s software development environment.” Even so, they are not designed to be quite as slick, integrated or graphical as the GUI-based IDEs that are now making their way onto Linux.

Metrowerks CodeWarrior CodeForge C*Forge KDE KDevelop Sun Microsystems Forte for Java
Cost $169 $50 personal/$150 professional Free; Open Source Binaries free; No source available
Linux Platforms x8/ PPC x86/PPC/Alpha x86/PPC Red Hat
Languages or Environments Supported C/C++ (V4.0) C/C++/Java (V6.0) C/C++/Java C/C++ Java
Packaging RPMs installed through script Single huge RPM RPM RPM
Compilation Necessary No No No No
Customer Support Available Support URL and mailto provided; online CodeWarriorU E-mail only Internet Internet
Automatic Support for Makefile Import No (V4.0)/Yes (V6.0, though only “simple” Makefiles supported) Yes No No
Bundled with Editor/ Uses EDITOR Environment Variable Metrowerks own editor; the same for all supported platforms/Yes Yes (custom SMED editor)/No Yes — built-in support for KWrite and emacs/No Yes/No
Integrated Debugger No Yes — expects gdb but comes with ddd, a gdb GUI front end No — expects gdb Yes
User-Selectable Debugger Expects gdb No No No
Bundled with Compiler Yes No No — expects gcc, g++ Yes — expects fastjavac
User-selectable Compiler Expects egcs (and includes source) No No Yes
Integrates with Version Control Software V4.0 supports a product called VCS from Latitude. V6.0 supports CVS Yes — CVS, RCS, and VCS No No
Does Keyword-level Help No No Yes — requires glimpse or htsearch Yes
Jumps to Structure and Variable Definitions and Declarations Jumps to foo, where foo is main function in file foo.c no jumps to structure/variable defs No Somewhat — separate window and grep for #include files Yes
Does API Autocompletion No No Yes No
Allows for Custom Processing Steps None in V4.0. V6.0 enables scripts to run before and after compilations, allowing for custom processing Yes — via shell escapes and integrated support for FLEX, REXX (!), etc. No No
IDE Interface Provided X Window System X Window System X Window System X Window System
Demo Available By request By request Yes — free Yes — binary is free
Distribution Media CD (can request time-limited evaluation) Download (by request) Download Download
URL CodeWarrior C*Forge KDevelop Forte

IBM Visual Age for Java ActiveState Komodo (Beta) Borland Kylix (Beta)
Cost Price not yet determined Free $1,199 (Server); $99 (personal — eventually)
Linux Platforms Red Hat Red Hat Red Hat/Mandrake/SuSE
Languages or Environments Supported Java Perl/Python/Javascript Pascal (!)
Packaging Proprietary Proprietary Proprietary
Compilation Necessary No No No
Customer Support Available Internet, IBM (eventually) Internet via mailing list (while in beta) Internet via mailing list (while in beta)
Automatic Support for Makefile Import No No No
Bundled with Editor/ Uses EDITOR Environment Variable Yes/No Yes/No Yes — offers emacs key bindings/No
Integrated Debugger Yes Yes – for all languages Yes
User-Selectable Debugger No No No
Bundled with Compiler Yes No Yes
User-selectable Compiler No No No
Integrates with Version Control Software Intrinsic in “save workshop” model No No
Does Keyword-level Help No No — but Perl/Javascript/Python help available No
Jumps to Structure and Variable Definitions and Declarations No No Yes
Does API Autocompletion No No No
Allows for Custom Processing Steps No No No
IDE Interface Provided X Window System X Window System X Window System
Demo Available Yes Beta Technology Preview 3 (Beta)
Distribution Media CD (eventually) Download (Beta) Download (Beta)
URL Visual Age Komodo Kylix

Bill von Hagen is president of Move2 Linux.com. He can be reached at wvh@movetolinux.com.

Comments are closed.