by Rogers Cadenhead
When the Java programming language was introduced in 1995, the only development tool available was the Java Developers Kit (JDK) from Sun. This set of command-line tools makes it possible to write, compile, and debug Java programs. However, the JDK is a far cry from the software used to write programs in languages such as Visual Basic and Borland C++. These languages make good use of integrated development environments.
An integrated development environment (IDE, pronounced I'd ) is software that combines several development tools into a single, cohesive package. The assortment usually includes a source code editor, compiler, debugger, and other utilities. These tools work together through the development process; most packages use windows, drag-and-drop, and other graphical elements. The goal is to make software design faster, more efficient, and easier to debug.
Many IDEs make use of rapid application development (RAD) methods in their approach. RAD is a broad strategy to use tools such as an interface designer and prototyping to speed up the design process. For most of the Java programming environments that have been released, the RAD tools in evidence are graphical user interface builders. Some of these have a direct connection from the interface design tool to the source code so that you can design a component such as a button and go directly to the event-handling code to make something happen when the button is clicked.
As further evidence of Java's enormous popularity, the number of Java development environments has gone from 1 to more than 40 in a matter of months. Although many of these programs are in early beta release or are unreleased in any form, several have reached the market.
This chapter focuses on some of the environments you are most
likely to have heard about and seen available at retail outlets.
As you evaluate each to see whether any of them fits your own
programming needs, you will become better prepared to choose from
among the on-rushing march of IDEs becoming available.
| Note |
A frequently updated list of Java IDEs, with reviews and notes regarding these tools, is presented at the following URL: http://www.cybercom.net/~frog/javaide.html |
The following development environments are described in this chapter:
You learn about the features of each environment, the systems they can run on, and some factors to consider when choosing which to use. Other Java development environments such as Microsoft Visual J++ are described briefly, to provide a full picture of the choices available to you.
When you are evaluating an integrated development environment for any language, you should ask yourself some questions about what you need to have on hand when you're ready to develop a program. Although this approach is true for any language and any environment, you should consider some specific issues related to Java's unique programming features (such as portability). Ask yourself the following questions:
The popularity of windowing systems is well established; users have begun to shy away from software that does not make use of these features. Although some of us grizzled veterans have an Amish-like love of the old ways-DOS utilities, the command prompt, batch processing, 1970s dance funk-most users today expect their software to have features such as mouse control, point-and-click, and resizable program windows.
Because these requirements make graphical user interface design an important element of most Java programming, it is important to select an IDE that is strong in this area.
Most Java IDEs are distinguishing themselves from each other by their approach to interface design and the functionality possible from within the interface development tool. Also, software such as Rogue Wave's JFactory is primarily an interface builder rather than an entire IDE.
Most Java interface builders work in largely the same way-like a painting program. You start with a blank form and a palette of user interface components. These components are usually abstract windowing toolkit (AWT) objects, and the interface builder generates AWT code that can be modified by a programmer who is fluent in dealing with the toolkit. Some IDEs, such as SunSoft Java WorkShop, introduce a layer between the AWT and the programmer's source code. The goal of a layer such as this is to make it easier to deal with windowing and interface issues. The IDE handles things behind the scenes so that the programmer can concentrate on larger issues.
For some programmers, especially those who spent a lot of time learning the intricacies of the AWT, this may not be an attractive feature. Others may be more interested in the power offered by these interface builders or may be ready to leave the complexity of the AWT behind.
One of the nicest features of these interface builders is their capability to generate event-handling code at the same time they create a user interface component. Anyone who has used Visual Basic is familiar with this approach: You plunk down a text field where you want it on a dialog box, double-click the text field, and then begin entering the source code to control how it operates.
One of the features to watch for when choosing an IDE is whether it produces code that is fully compatible with the Java class library. Several of the development environments such as Café and Java WorkShop come with their own versions of the JDK instead of using an existing implementation of the JDK.
This usually does not matter because one of the goals of any Java IDE is to take advantage of the language's ability to be portable across any platform. Many development environments such as SourceCraft NetCraft work entirely within the JDK, and they create software that does not enhance those features with proprietary extensions.
Others environments, such as Microsoft Visual J++, add features that require new classes. J++ (formerly known under the code name Jakarta) has extensions to the Java language that are specific to the Windows operating system. For an applet or application designed with Visual J++ to be fully portable, it must not make use of these extensions. Because this IDE is just now becoming available, it remains to be seen whether the advantage of extended features makes up for the significant disadvantage of platform specificity. This issue is hotly debated within the community of Java developers because many believe that the continued growth of the language depends on its ability to stay cohesive and fully cross platform.
An interesting side issue to the portability question is that most Java development environments are not cross platform themselves-even when the IDE is touted as being a Java program. All the major IDEs that have been introduced to date are offered for specific platforms-primarily because of the use of native code.
One element of IDE use that sometimes gets lost in the shuffle is the skill level required to use one. If the idea of an IDE is to improve your programming, this can't happen if you can't figure out the IDE! An integrated development environment is a complex type of software. It often makes use of a multiple-document interface where you can have several windows open at once and be faced with a dizzying array of options.
For experienced programmers, this functionality is a great boon. You want to have as much power in your control as possible. A new programmer can easily get lost in the IDEs that are available-especially if the programmer is still learning the language. When you are busy clearing out space in your brain for a new programming language, you shouldn't have to find room for an IDE at the same time.
Several of the IDEs available for Java are more suited for the code warrior-the multilingual veteran who can throw around jargon like OOP, MUMPS, and male-female connector with the greatest of ease. However, a few of the development environments are more suited for the newcomer because their interface is more approachable and less complex.
The best example of this kind of interface is Java WorkShop from SunSoft-it uses the familiar Web browser interface. People coming to Java from a limited programming background-such as HTML developers looking to upgrade their skills-can find this kind of IDE more suited to their tastes.
There is a trade-off for this ease of use, of course. An environment like Java WorkShop may require more steps to get a task done-either because the functions are not immediately available or because they may not offer some of the functionality of a more complex IDE.
Another factor regarding the use of an IDE for some programmers is its use with other languages. Several of these environments, including MetroWerks CodeWarrior and Borland 5.0 C++ IDE with Java Enhancements, are designed to handle more than one language or are fully equivalent to the company's other development tools.
If the IDE is a complex one (as these are), you learn how to use it and don't have to learn another when you shift gears and program in a non-Java language.
Also, if you write native methods for use in your Java programs, you can use some multilanguage IDEs to write that code. The Borland 5.0 Java environment comes with a C and a C++ compiler, so native methods can be written alongside Java methods in an integrated manner.
The goal of an IDE is to make you a better programmer. As Java developer Chuck McManis wrote in his August 1996 JavaWorld column, "I rate the IDEs by my ability to get productive work done while using them."
As you go over the details of the software products discussed in the following sections, you get a clearer picture of how each environment can help you. Given the number of IDEs already available for Java, you should be able to match one with your skill level, programming tasks, and personal taste.
If not, as the Amish coder might tell you-there's always the JDK.
You can match it with word processors, custom interface builders,
and other single-feature design tools to create a personalized
IDE.
| Caution |
If you are downloading tryout or beta copies of several IDEs-as I did in the course of preparing this material-be advised that these rival products may not coexist peacefully. Many Java development tools make use of environment variables such as CLASSPATH and JAVAHOME, and they are not happy if another software tool has claimed these variables for its own purposes. As an example, Café and Java WorkShop are the Prince Charles and Lady Diana of software-they should be kept apart for the benefit of everyone involved. If possible, de-install one IDE before installing the next one on your system and make sure that your bootup files are cleaned out as well. If you need more than one IDE active on your system, you can establish multiple configuration files that are executed when a particular environment is used. |
Symantec Café, released in March 1996, is the first development environment that became widely available for Java programming after the JDK. Symantec calls it an integrated development and debugging environment (IDDE), but the added D doesn't make it different than most IDEs-the others usually include a debugger, too.
Café is based on Symantec's C++ environment, but Café is a standalone product that does not require a C++ platform to run.
Figure 5.1 shows an example of Café at work.
Figure 5.1: A screen capture of Symantec Café.
Symantec has released versions of Café for the Microsoft Windows 95, Windows NT 3.5x, and Macintosh systems.
For Microsoft users, an Intel 386 processor and 8M memory are required, but a 486 or better and 16M memory are recommended. A VGA monitor is needed, but Symantec recommends that an SVGA monitor be used if available. The software, and all its sample files and Help files, requires 60M of disk space and a CD-ROM drive.
For Macintosh owners, a Power Macintosh, 68030, or 68040 Macintosh is required, and 16M memory is recommended. The full installation of the software requires 30M of disk space.
Café incorporates the JDK into its release with a full implementation of the Java class libraries and source code samples. You do not have to have the JDK before installing Café. In fact, it is prudent to de-install the JDK before implementing Café to avoid system conflicts between the two.
Café is a sophisticated IDE that offers an excellent source editor with color highlighting of syntax, an editor for class and hierarchy modification, a Studio tool for interface design, and numerous example applets.
Because it has been on the market for a long time relative to its competitors, Café has the advantage of being more robust than some other IDEs. Café also has been documented more completely in books such as Teach Yourself Java in Café in 21 Days, available now from Sams.net Publishing.
To aid in the design of a class hierarchy, Café has a class editor for navigating through classes and editing class methods, and a hierarchy editor for viewing and modifying Java class relationships. Changes in the source code that affect the class hierarchy can be seen as the program is being written, instead of requiring that it be compiled before changes are reflected in the hierarchy. You can also change the source code from within the class editor-clicking the function or method within a class brings up its source code in a window that can be used to edit the code.
With AppExpress, the process of creating a skeleton Java program speeds up. This and several other Express Agents-Café's term for wizards-make it easier to begin projects and new programs.
In the source editor, Java syntax is highlighted, making it easier to spot typos and other errors immediately. The editor can be customized to behave like several popular programmers' editors such as Brief, Emacs, and Epsilon. The editor also uses standard Windows cut, copy, and paste commands.
With Café Studio, designing a graphical user interface for your Java programs can be done in a visual, drag-and-drop manner. Studio enables programmers to develop the dialog boxes and other visual elements visually, and it creates event handlers for these components automatically. There's also a menu editor with an active window in which you can test the menu. These resources are saved in separate .rc files that can be edited later (just as source files are edited); the .rc format is compatible with other design tools that generate .rc files.
One interesting aspect of Café Studio is the ability it gives you to design a form and dictate exactly how it looks. With the JDK and its abstract windowing toolkit, graphical user interface designers have to allow their work to be changed depending on the platform the applet or application was running on. This approach is similar to the way HTML can be modified to fit the large number of platforms used on the World Wide Web. It's an approach well suited to cross-platform design.
With Café Studio, programmers can choose to use one of these variable layout managers or to dictate the position and size of all interface elements.
When you're ready to compile a program, Café provides the option to use Sun's JDK compiler or the Café compiler, which operates more quickly than the current JDK version.
The Café debugger provides several different ways to temporarily halt the execution of code, including a quick-breakpoint feature for a one-time run that stops at a specific line. The debugger also enables a large amount of control over threads in multithreaded programs. During debugging, a watch view can be used to monitor the contents of variables.
The environment of Symantec Café is highly customizable-all toolbars and palettes can be resized and placed where you want them on-screen. Several windows can be open at the same time, making it possible to view the object hierarchy while entering source code and using the form editor, for example.
There are 54 sample Java programs included with Windows versions of Café and more than 90 with the Macintosh version. Many of these are duplicates of the sample applets Sun offers with the JDK or on its Web site at http://java.sun.com.
Pricing is subject to change, of course, but the most recent retail
price for Café, quoted on the company's Web site, is $299.95
for Windows users. An introductory price of $99.95 is currently
being offered to Macintosh owners for 90 days-an offer that is
to be followed by a $299.95 price. Café can be purchased
from Symantec's Web site in addition to retail and mail-order
outlets.
| Tip |
Some folks might not have to buy Café at all-customers who bought Symantec C++ from December 1, 1995, to March 1, 1996, are entitled to a free upgrade to Café. |
The home page for Symantec Café is at the following URL:
http://cafe.symantec.com/
The customer service number for the company is (800) 441-7234, and its e-mail address for Java-related comments and questions is javainfo@symantec.com.
SunSoft Java WorkShop, the development tool offered by the language's home team, is scheduled for release in the Fall of 1996 and may already be on the market as you read this.
According to its designers, the IDE is written almost entirely in Java, and its development has been used to help improve the Java language. The mindset at Sun is that committing to such a large-scale undertaking in the company's own language gives them insight into the issues other developers are facing and reveals any kinks in Java that still have to be straightened out.
However, all that talk doesn't benefit the developer looking for a tool to write software. Java WorkShop is evaluated here on the basis of its applicability to this task.
Figure 5.2 shows an example of Java WorkShop in use.
Figure 5.2: Java WorkShop in use.
Versions of Java WorkShop are available for the following systems: Microsoft Windows 95, Windows NT 3.5.1, SPARC Solaris (2.4 or later), and Intel x86 Solaris systems.
Microsoft Windows 95 and NT systems must be running a 90-megahertz Pentium or better with 16M of memory and 45M of hard disk space. Solaris systems must have 32M of memory, 45M of disk space, and an OSF/Motif 1.2.3-compliant windowing system. The recommended display resolution to use with Java WorkShop is 800¥600 pixels.
Java WorkShop comes with its own modified version of the JDK, so it cannot be used in conjunction with an existing installation of the kit. Like Café, Java WorkShop requires that any existing JDK copies be de-installed before you can install and run WorkShop correctly.
Java WorkShop, one of the most approachable IDEs for a novice programmer, uses a Web interface to offer the following features: a source editor, class browser, debugger, project management system, and Visual Java (a tool for the visual design of a graphical interface and an easier means to create windowing software). WorkShop is fully detailed in Teach Yourself SunSoft Java WorkShop in 21 Days, available now from Sams.net Publishing. (This is a book I can personally recommend-I coauthored it!)
Although still in beta release as of this writing, Java WorkShop has been available long enough to assess the kind of functionality it will offer when it hits the market. The most striking difference between it and other IDEs is its interface. Java WorkShop looks more like a Web browser than a programming development environment. It is a Web browser, in fact-users of Sun's HotJava browser will recognize elements from that software in the design of WorkShop. In addition, you can view any Web page while working in Java WorkShop.
Java WorkShop's browser interface is easier to use for programmers who are unfamiliar with IDEs and similar software; the browser interface is frustrating to some of those who are comfortable with these tools.
WorkShop has a source browser for viewing a class hierarchy, public methods, and variables. The browser creates HTML pages in the same format as HTML documentation generated by the JDK's javadoc utility.
The WorkShop source editor is still in an early stage of development and lacks some of the cut-and-paste functionality of other, more established editors. The editor works in conjunction with WorkShop's debugger-compile errors create links directly into the source editor for fixing. The WorkShop debugger provides breakpoints and other methods of debugging.
The Visual Java feature provides a way to graphically design an interface, much as Café Studio does. Visual Java enables programmers to develop dialog boxes and other visual elements and automatically creates event handlers for these components. There's also a menu editor. Resources are saved in separate .gui files that can be edited later, just as source files are edited.
In its current release, Java WorkShop requires the use of runtime classes that make Visual Java work, but developers have said that this will not be the case when the software hits the market.
The environment is not customizable in the way Café is, but the Web interface makes it easy to integrate other tools and programs into WorkShop. The program is a collection of Web pages with Java programs embedded in and around them. You can go to a different page from within Java WorkShop as easily as you can enter a URL in a Web browser. This approach makes it possible for a user to create original pages of Java development tools that can be linked to WorkShop pages. This arrangement may be unusual for someone accustomed to development environments written as cohesive, single-executable files that can't be changed (as most are). However, it suits the spirit of Java-independent programs linked together by HTML pages, which can be modified as individual elements without affecting the other parts of the whole.
When it is released, SunSoft Java WorkShop is expected to retail for $295. While it still is in beta release, the software can be downloaded freely for evaluation. For more details, and the opportunity to download a beta release, visit the following URL:
http://www.sun.com/sunsoft/Developer-products/java/index.html
The customer service number to use for the company is (800) 786-7638 (SUN-SOFT) in the United States, or (512) 434-1511 elsewhere. The company's e-mail address for comments and questions is sunsoft@selectnet.com.
SourceCraft, the developer of the ObjectCraft development environment, is making its NetCraft Java IDE available as freeware. For those unfamiliar with the term, freeware is software available for no cost as long as you comply with the developer's terms and conditions for use.
This fact makes NetCraft attractive if cost is a criteria, obviously, but the IDE still must be well designed or you will pay in terms of lost time and efficiency.
Figure 5.3 provides a look at the NetCraft environment.
Versions of NetCraft are available for Microsoft Windows 95 and Windows NT 3.5.1 systems running a 486 or better with 8M of memory. NetCraft comes bundled with the current version of the JDK; SourceCraft also makes NetCraft available for download without the JDK if you already have the JDK installed.
SourceCraft NetCraft is somewhat less ambitious in its approach than other IDEs because it has a smaller set of available features. However, it is a fully featured replacement for the JDK, and it creates Java programs compatible across all Java implementations. NetCraft has an editor, a class inspector, a user interface designer, and a compiler.
NetCraft is an IDE that can be used for any type of Java applet or application. In its approach to the software, SourceCraft focuses on Java's applicability in intranet environments.
The Package Inspector, part of NetCraft's system for organizing projects, includes a way to browse the methods used in a class. NetCraft also has a Class Inspector for looking at the following aspects of a class: its position in the hierarchy, its methods, and its variables. When you are looking at a method with this tool, you can view the source code of the method and how it is used in a program.
NetCraft, like Café and Java WorkShop, includes a way to visually develop a graphical user interface. The NetCraft UI Builder generates Java code that uses the abstract windowing toolkit as its raw material, so the code does not rely on any new classes introduced with the development environment. When you create an interface component, NetCraft generates source code for that component, complete with a TODO comment line where the event-handling code for that component is placed. It's a simpler approach than some of the alternatives and a programmer comfortable with the AWT should be comfortable with it.
The source editor uses Windows cut-and-paste commands and is similar to other small word processors with which you are probably familiar. And the NetCraft UI Builder is not much more difficult to use than a word processor. Although the components in the release available at this writing have the odd habit of moving around a little when clicked, a nice feature of the Builder is its ability to set the specific coordinates (height and width) of a component by entering numbers into text fields. This approach makes it easy to bring wandering components in line with each other.
The environment is simpler to use and master than other IDEs. However, this may be a problem when you are developing sophisticated programs with numerous windows and interactions; some of the tools you need to manage this software are not available in NetCraft. Its strength for use with complex programs depends on where SourceCraft, the maker of other development tools, plans to go with this freeware product.
For basic tasks and applets, NetCraft appears to be a good substitute for JDK users seeking to migrate to a graphical interface. Because it is free, it is a fitting place for novices to start when choosing a Java IDE.
For more details, and the opportunity to download NetCraft at no cost, visit the home page for NetCraft at the following URL:
http://www.sourcecraft.com:4800/about/netcraft/
The customer service number for the company is (617) 221-5665; the company's e-mail address for comments and questions is edc@sourcecraft.com.
WinGEN for Java, development software from Pro-C, is an IDE designed with the nonprogrammer in mind. The focus is on automatically generating code so that HTML designers and other programming novices can develop Java applets and applications. The graphical interface of a program can be developed using drag-and-drop features; elements such as animation can be introduced without writing a single line of code. The IDE calls the Java Developers Kit from within WinGEN to compile and run programs.
Figure 5.4 shows a look at the WinGEN environment.
Figure 5.4: WinGEN for Java at work.
Versions of WinGEN are available for Microsoft Windows 95 and Windows NT 3.5.1 systems running a 486 or better with 8M of memory and 10M of hard disk space. Unpacking WinGEN Lite, the evaluation edition of the software, requires a program that can unpack ZIP files into long filenames. (For users of Windows systems, the Windows 95 operating system introduced filenames longer than eight characters and a three-character extension.) If you use a ZIP unpack program that does not support long filenames, files are not named correctly and the setup will fail. WinGEN includes the current version of the JDK, which must be installed before WinGEN is installed so that the IDE will function.
WinGEN augments the existing JDK rather than replacing it, enabling you to run the compiler and interpreter from within WinGEN rather than using the JDK's command-line tools.
As software that strives to put nonprogrammers to work developing Java applets and applications, WinGEN puts its emphasis on its point-and-click approach to the creation of graphical user interfaces. Many simple user events can be created through WinGEN without writing any Java code; graphics and animation features can also be created without programming.
The user interface is designed in a manner that should be familiar to programmers who have used other GUI design tools-especially Visual Basic developers. The version currently available is a bit difficult to use when it comes to aligning components (because of the lack of a snap-to-grid feature). Otherwise, laying out things such as text fields and labels is easier than doing so in some other IDEs.
The IDE takes a resource-centric view of development. Instead of starting from the code and using it to create things such as menus and dialog boxes, you start with the menus and dialog boxes and use them to generate the required code. One feature missing from WinGEN is the ability to see the interface before any code has been generated. The Java program that uses the interface must be compiled and run in order to see how the interface will look.
The commercial version of WinGEN for Java includes some features not commonly available in other IDEs at this time, such as support for specific types of ASCII text databases and tables.
A system called CodeHooks handles advanced programming-for writing Java code to handle special circumstances that WinGEN can't handle. These hooks-blocks of code that accomplish specific tasks such as a special event handler-are kept separate from the code WinGEN automatically generates. This separation of code enables programmers to change the GUI and plug CodeHooks back in without reentering any code.
WinGEN is an interesting approach that can be especially useful in the development of simple applets and applications or as a tool for Java novices. Although the lack of a debugger, source browser, and other features might limit its use, the IDE still is in an early phase of development and may yet implement some of these tools.
The retail price of WinGEN is listed at $349, but it can be purchased online for $199. For more details, the opportunity to download WinGEN Lite at no cost, or to purchase the full version online, visit the home page for WinGEN at the following URL:
http://www.pro-c.com/products/wfj/java.html
The phone number at Pro-C for inquiries related to the software is (813) 227-7762; the company's e-mail address for comments and questions regarding WinGEN is support@pro-c.com.
Unlike most of the development tools being introduced for Java, JFactory is being offered as an interface builder rather than an IDE. However, because JFactory enables the placement of event-handling code from within the program and also provides a way to compile and test programs during development, it's close enough to a full IDE to be worthy of consideration. Although JFactory can be used in conjunction with any editor and Java compiler, a default editor is provided and JFactory is initially set up to use the JDK compiler.
Figure 5.5 gives you a look at the JFactory environment.
Figure 5.5: Rogue Wave JFactory at work.
Versions of JFactory are available for the following platforms:
JFactory is a sophisticated interface builder based on zApp Factory, a multiplatform C++ application framework from Rogue Wave. The software has a large number of features that facilitate rapid application design, and the product benefits from the experience Rogue Wave has accumulated with its other programming tools. The primary offering of JFactory is its visual, drag-and-drop editor for interface creation. This graphical user interface developer is head-and-shoulders above many of the other visual development tools currently available.
The JFactory software is not considered to be a full IDE because it does not provide its own compiler, debugger, or other tools. However, JFactory's visual editor is so easy to use, and so capable, that it may compensate for the loss of some integrated development offerings. This open environment, a trait of Rogue Wave's programming software, enables any compiler or debugger to be used from within JFactory.
At any stage in the development process, you can test the interface you have created. Another useful feature is that custom components can be integrated easily into the toolbar alongside standard components such as text labels, text fields, and radio buttons. One thing JFactory offers that sets it apart from most other IDEs is the ability to import .rc and .dlg files created with other programming environments.
A lot of the source code associated with interface components is generated automatically by JFactory. Custom code that must be added is protected from modification so that you can change the interface afterward without overwriting your changes to the source code.
JFactory has a robust system for creating the interface: You can use drag-and-drop and mouse movements to place components, and you can also place components with numeric input. The height, width, and (x,y) coordinates of a component can be set from a properties dialog box. This approach makes it much easier to cure the problem of wandering components that are difficult to align correctly.
When a menu, window, or dialog box has been created, you can save it in an object library for reuse with other programs.
If the lack of tools such as a class browser and integrated debugger are not detrimental to your programming tasks, JFactory may be an excellent choice for your needs.
JFactory retails for $195; a multiplatform package that includes the Microsoft Windows, UNIX, and OS/2 versions is available for $390. For more details and the opportunity to download a demo version or to purchase JFactory online, visit the home page for JFactory at the following URL:
http://www.roguewave.com/products/jfactory/jfactory.html
The e-mail address for comments and questions regarding JFactory is support@roguewave.com.
The following products for Java development cannot be described fully here (because they are not yet available or for some other consideration). However, they're profiled here so that you can get a fuller picture of the IDEs that will be available to you.
Borland C++ 5.0 with Java Enhancements is a C++ development environment that has been extended to include Java programming tools. The advantages of this approach are multilanguage development within the same environment for native method use, the ability to program in three languages (C, C++, and Java) without learning three IDEs, and software that has become robust from several years of use by the C and C++ development community.
The home page for Borland's Internet development tools is given here:
http://www.borland.com/internet/
CodeWarrior is one of several IDEs that have been made available in prerelease or beta form for Macintosh Java development. CodeWarrior is a multilanguage development environment with an introductory version called Discover Programming with Java that is intended for novices. CodeWarrior can be used to develop programs in C, C++, ObjectPascal, and Java.
The home page for MetroWerks CodeWarrior 9 is at the following URL:
http://www.metrowerks.com/products/announce/cw9.html
The Java WebIDE development environment is worth looking at to see what's being attempted: A fully Web-based programming tool that doesn't require downloading. You run it off the Web page over the Internet, which is how many software packages will be run as Java development matures (according to the language's adherents). WebIDE is an experiment that does not supplant a more traditional IDE at this time, because it offers only source creation, compilation, and syntax highlighting in its present incarnation. However, as more tools are added, it will become more interesting. WebIDE is one of the only development environments for Java that attempts full cross-platform support. Its home page is at the following URL:
http://www.chamisplace.com/prog/javaide/
Before it was christened as Kalimantan, this IDE was one of several Java-related products that staked a claim to the name Espresso. The developers have been kind enough to offer links to the other Espressos, so the Kalimantan Web page is a good place to sort out any Espresso confusion you may have. Kalimantan is another cross-platform IDE. It has been tested for use with Solaris 2.4 and up, as well as Windows 95 systems. Kalimantan's current beta release includes only an inspector to look at the values of internal variables and a debugger, but it is bundled with the teikade suite of utilities from PFU Limited. This suite includes a class browser that is familiar to those who have used class browsers with the Smalltalk programming language. The home page for Kalimantan is at the following URL:
http://www.real-time.com/java/kalimantan/index.html
Roaster was made available to developers in January 1996, making it the first Java IDE for the Macintosh. The current version at this writing is Developer Release 2.1. The Roaster Professional Edition includes a visual interface builder, compilation that can be targeted for Macintosh or Microsoft Windows systems, and an extended class library. The Sams.net book Teach Yourself Java for the Macintosh in 21 Days was written for the Roaster environment. Details on Roaster are available from the following URL:
http://www.natural.com/pages/products/roaster/index.html
Microsoft Visual J++ is just becoming available in beta release as of this writing, but the company developing Visual J++ makes the product worth keeping an eye on. Visual J++ is Microsoft's machine-proprietary answer to Java development. It features extensions to the Java class library that are specific to Microsoft's operating system. It integrates Java with the component object model (COM) integration through Microsoft ActiveX and is integrated with the Internet Explorer browser that implemented Java with its 3.0 release.
Details about Visual J++ can be found at the following URL:
http://www.microsoft.com/visualj/
Microsoft has recently released a Software Development Kit (SDK) for Java programming. The Microsoft Java SDK is not an IDE, but instead is a package that includes Microsoft's implementation of the Java language for 32-bit Windows machines, a special just-in-time (JIT) compiler that makes Java applications execute more quickly, and other platform-specific enhancements.
Like Visual J++, the Java SDK offers improvements for Microsoft Java programming at the cost of platform independence. Some of the SDK's offerings (such as 3D programming through DirectX) offer new features that aren't readily available in other implementations.
Microsoft has an extensive Web site that promotes its approach to Java development and its tools for programming. The current version of the Java SDK is available at the following URL:
http://www.microsoft.com/java/sdk
Cosmo Code is an integrated development environment for Java that runs on Silicon Graphics IRIX operating system versions 5.3 and 6.2. The product includes a compiler, interpreter, debugger, and a class browser. The compiler can create machine-independent code, symmetric multiprocessing on SGI systems, and can create executable native code files. The Cosmo Code home page is available at the following URL:
http://www.sgi.com/Products/cosmo/code/index.html
As you have probably discovered by this point, the decision about which IDE to use depends on your programming experience, personal taste, and the tasks you have to accomplish with your software creations.
Because developments occur at such a rapid pace in regard to Java (a trend that will continue for the foreseeable future), it is worthwhile to use the Internet to keep up with changes. As stated earlier, one Web site has been established to offer the latest news on IDEs, links to reviews, and a full listing of announced software. It's available at the following URL:
http://www.cybercom.net/~frog/javaide.html#reviews
The Java newsgroups such as comp.lang.java.misc and comp.lang.java.programmer are another way to get a range of user opinions on the IDEs you are considering. Many IDE developers also participate in these forums, including the folks who created Café and Java WorkShop.
Most of the IDEs that have not yet reached the market can be downloaded as beta versions over the World Wide Web. You ought to make use of this availability before you choose a development environment. It's a hassle to install the software and de-install its rivals, but even if the IDE doesn't suit your needs, it gives you a much better idea about what you do need in a development environment.
When it comes down to choosing the right one, it's what IDE do.