All Categories :
Java
Chapter 5
Third-Party Development Tools
by Rogers Cadenhead
CONTENTS
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.
The following development environments are described in this chapter:
- Symantec Café
- SunSoft Java WorkShop
- SourceCraft NetCraft
- Pro-C WinGEN for Java
- Rogue Wave JFactory
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:
- How important is graphical interface design
to your programs?
- Do your programs have to be completely
portable across platforms?
- What is your comfort zone with IDE tools?
- Do you want to program in other languages
at the same time?
GUI Development Tools
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.
Portability of Code
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.
IDE Experience
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.
Multiple Language Development
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 Bottom Line
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é.
System Requirements
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.
Overview
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 and Additional Information
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.
System Requirements
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.
Overview
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.
Pricing and Additional Information
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.
Figure 5.3: NetCraft at work.
System Requirements
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.
Overview
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.
Pricing and Additional Information
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.
System Requirements
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.
Overview
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.
Pricing and Additional Information
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.
System Requirements
Versions of JFactory are available for the following platforms:
- Microsoft Windows 95 and Windows NT systems running a 486
or better with 16M of memory, 25M of hard disk space, and the
Java Developers Kit version 1.0.2.
- SPARC Solaris 2.4 or 2.5 running UNIX with 25M of hard disk
space, an applet browser, JDK version 1.0.2, and X11R5. You must
have enough memory to run X11R5, the JDK compiler, and an applet
browser.
- HP-UX 10.01 systems with 25M of hard disk space, an applet
browser, JDK version 1.0.2, and X11R5. The memory requirements
are the same as for Solaris systems.
- IBM OS/2 Warp 3.0 systems with 25M of hard disk space, 4M
of memory not used by OS/2, a two-button mouse or pointing device,
and JDK version 1.0.2, build os2-19960412.
Overview
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.
Pricing and Additional Information
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
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/
MetroWerks CodeWarrior
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
Java WebIDE
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/
Kalimantan
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
Natural Intelligence Roaster
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++
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 Java Software Development Kit
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
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.
Contact
reference@developer.com with questions or comments.
Copyright 1998
EarthWeb Inc., All rights reserved.
PLEASE READ THE ACCEPTABLE USAGE STATEMENT.
Copyright 1998 Macmillan Computer Publishing. All rights reserved.
SHOPPING
JOB BANK
REFERENCE
JOURNAL
COMMUNITY
ABOUT US
