PARTS FOR JAVA is an expensive, yet extensive, offering from ObjectShare geared toward developing Java
applications as a set of interactive "beans." Thus, it adheres to Sun's increasingly used JavaBeans
standard that all objects used within an application are reusable components with property and event
interfaces. The product itself is divided into four principle parts to this end: the ClassMaster
browser, the Visual Designer, the Repository Browser, and the Project Manager. Each is a multi-faceted
interface for a different portion of serious enterprise-level development. While PARTS has many unique
features for a Java integrated development environment (IDE), it retains a certain degree of quirkiness
throughout, which hindered its otherwise effectual feel.
Installing PARTS was relatively simple, but required a great deal of configuration before I was
able to attempt actual development. The abundant package includes the latest edition of Sun's
Java Development Kit (JDK), Iona's OrbixWeb (for CORBA deployment), Sun's Swing widgets (component
versions of common graphical user interface (GUI) elements), and support for other requisite
development tools such as JDBC, ActiveX, etc. Expect to use up to 75 MB (including JDK if you do not
have version 1.1.5) for installation.
One thing that was consistent throughout the various portions of PARTS, is that the user
interface for these tools was slow and took a great deal of time to get used to. The user guide
was not as comprehensive or searchable as it could be given the complexity of the application as a
whole. Moreover, many of the various tools lacked easily detectable help. ObjectShare abated this pain
to an extent with a generous helping of sample projects and a "Quick Tour" accessible from the Help menu,
which covers the deployment of a basic task selection applet.
Development begins with the Project Manager, from which you declare a new project and set its
properties before adding applets to the project that will invoke the Visual Designer. A tree-like hierarchy
of all files relating to working projectsor the entire PARTS system for that matteris
accessible from here. A new element within a project (generally an applet) will generate a .java source
file, a bare-bones .html documentation outline, and the in-progress .jedt Visual Designer file (which
can grow to alarmingly large sizes during the course of development).
As can be expected, the Visual Designer is where the bulk of the application will be put together.
In order for a GUI element to be used on the canvas of a new applet, it must be part of a component
catalog. PARTS for Java provides catalogs for Swing widgets, JDBC elements, ActiveX controls, and a
general JAVA catalog of common AWT components. While this may still seem somewhat limiting to a developer
who wishes to put any visual class on their applet, PARTS provides a "component wizard," which allows for
the bean-ifying of such objects. Once a component is placed on the applet's canvas, its pop-up context
menu allows for the editing of various visual properties as well as hiding and unhiding its various "links."
The concept of a link in PARTS is actually one of its most astute features. This is how events and
relationships between components are set and modified. By dragging a line with the right mouse button from
one component to another, a dialog box appears with all applicable events of the source and public methods
of the target. Fortunately for the developer, these links and their labels can be moved and hidden as
needed, which becomes a blessing as the complexity of a useful applet quickly grows. Possibly the biggest
criticism that can be made of the Visual Designer aside from its initially steep learning curve is that
it is not truly WYSIWYG, which can result in the need to run and tweak the layout of applets repeatedly
until they reach the desired look and feel.
The Visual Designer is at the forefront of rapid-application development tools in mostly precluding
the need to edit code at some point during development of a nontrivial applet. Nonetheless, ObjectShare is
not too arrogant about this virtue to omit a useful interface for accessing the Java source. This is provided
via the ClassMaster, a streamlined three-window browser that efficiently shows the hierarchy of objects along
with their respective properties and source text. This is also where breakpoints for debugging can be browsed,
set, and cleared within the individual classes.
The final noteworthy element to the PARTS development model is its debugger, which is not only
multithreaded but also written in Java. This latter asset can occasionally be a liability when the inevitable
sluggishness of a full-Java debugging process is considered, but this is offset by the portability achieved
with a debugger that can theoretically run on any platform. If running the debugger away from the comfort
of the Windows nest, the developer must learn the bulky command-line invocation syntax. It is a profound
comfort to the user that the debugger also has its own breakpoint editor, which averts the user's need to
go back to the ClassMaster where PARTS is running or use an ugly command-line call on another platform.
Outside of development tools, PARTS also includes a Repository Browser for the purpose of version
control in large or multiple projects. The interface and features are basically consistent with the
run-of-the-mill source-code control system, but when used in conjunction with the Project Manager (where
components can be locked, unlocked, catalogued, etc.) the overall effect is powerful enough to be effective
without being overwhelming to the increasing number of new developers who never fully understood the concepts
of a source-code control system(SCCS).
My quick-test build of an applet for displaying the fields of an ODBC database server was accomplished
without reaching for the ClassMaster to edit the file. Although lack of adequate documentation made the
initial creation in the Visual Designer time-consuming, it grew to be quite simple after the linking and
catalog nuances were demystified. The PARTS Visual Designer is a great product for designing rich event
models, but lags behind other Windows Java tools I've used in the past, in terms of quickly accessing and
altering the properties of the component I'm working with on the canvas. There was nothing in my normal
development routine that I was unable to accomplish with PARTS, however.
While PARTS is very up to date on the changes to the Java specification, it will require constant
updates as Sun continues to hone the functionality and direction with Glasgow (code name for the next major
revision of JavaBeans). In spite of its occasional clunkiness, PARTS is extremely versatile and adequately covers each stage of the enterprise development process. However, it may indeed be more the sum of its PARTS than the whole that determines its usefulness to you over another development product. If features like Java platform-independent debugger, component wizard, and click-and-drag event handling, jump out as godsends in your particular development strategy, PARTS will justify its hefty price with a capital interface for these endeavors.
Todd C. Zino works in publications and development at NSTL. In addition to
reviewing various object-oriented development tools, he is involved with programming and testing
of network environments. He can be contacted at email@example.com.
Client/Server Programming With Java and CORBA
by Robert Orfali and Dan Harkey
John Wiley & Sons, New York, NY, 1998, $49.95
Reviewed by Lowell E. Thomas, Java Report Book Editor
The second edition of Client/Server Programming With Java and CORBA is a pretty impressive book.
Both in size (more than 1000 pages) and in substance (loads of very useful information and programs),
this book packs a serious wallop.
Robert Orfali and Dan Harkey have been collaborating on a number of successful book projects over
several years. Among them, Instant CORBA (with Jeri Edwards, John Wiley & Sons, 1997), The
Essential Client/Server Survival Guide (with Jeri Edwards, John Wiley & Sons, 1997), and The Essential
Distributed Objects Survival Guide (with Jeri Edwards, John Wiley & Sons, 1995) are award-winning volumes.
The books are connected by subject matter-namely, building the infrastructure for the modern distributed
Object Web-with Client/Server Programming for Java being a kind of synthesis of the previous volumes
written with the professional programmer in mind.
The authors have developed a consistent and steady style that is both pleasantly reassuring and
informative. They somehow manage to convey complex material in a way that makes everyone feel comfortable
regardless of their skill level or experience. It is a delightful and lighthearted way that makes the
stuff seem, well, fun! Most computer books aimed at programmers are pretty matter-of-fact tomes,
sometimes rich with useful technical material for practitioners but rarely interesting beyond that.
There are the occasional classics like Donald Ervin Knuth's The Art Of Computer Programming
(Addison-Wesley, 1997) or Brian W. Kernigan and Dennis M. Ritchie's C Programming Language
(Prentice Hall Press, 1988), but even these books are interesting more for their pedagogical content
than for their style. Client/Server Programming for Java has it down with both the form and
The book is an in-depth study of the intersection of two of the most important software technologies
around. It covers ground that no other book on this level has until now. Detailed explanations are
given on the facilities built into JDK 1.1 and above for building portable, distributed, multi-tiered
client/server applications with Java, which among other things, includes full coverage of RMI, JDBC,
sockets, Java Beans, and Enterprise JavaBeans along with complete tutorials on competing distributed
object frameworks such as HTTP/CGI, Servlets, and Java/DCOM. Full and objective comparisons and benchmark
testing are done on all these frameworks, as well as analysis of the advantages and disadvantages of the
major ORBs currently in use including Netscape's (formerly Visigenic's) VisiBroker for Java 3.1 and Iona
Technologies OrbixWeb 3.0 (still in Beta at the time of the books publication). Ever on the "bleeding edge,"
the authors do a remarkable job of synthesizing the essential elements of these rapidly evolving technologies
and presents the developer/programmer with crucial material that he/she can make use of today and into the
The book consists of eight major sections. Part 1, "CORBA Meets Java," contains three chapters and is 132
pages long. Chapter 1 introduces distributed objects and answers the basic questions such as what is an ORB,
What is IIOP and IDL, and briefly addresses the essential CORBA Middleware objects and services. The OMG
specification for CORBA 2.0 is discussed in detail and plenty of information is given regarding
CORBA 3.0due out toward the end of this year. After discussing the evolution of the Internet,
Client/Server, and CGI, Chapter 2 introduces the concept of the Object Web, that almost mystical entity
where everything in the software technological universe seems to be converging to and goes on to discuss
the crucial role of integrating CORBA and Java (including JavaBeans). The overview section concludes with
a chapter comparing the different CORBA/Java ORBs on the market and ends by choosing between the three
major competitors-the authors end up selecting the Visigenic/Netscape ORB, which they see as leading the
Part 2 begins with Core CORBA/Java, from which they embark on the exploration of the CORBA/Java programming
model. Chapter 4 shows you how to construct a rudimentary distributed application with Java and CORBA, a
basic client/server Ping program. The example given is an important one in that the subsequent programs
contained in the book will build from. You are taken through the steps of writing the IDL interface, mapping
the IDL to Java and constructing the client and server side pieces of the code. They introduce the Object
Interaction Diagrams that are used to illustrate the dynamics of the process. In distilling everything to
a highly visual representation, these diagrams serve as an excellent aid to learning the material at hand.
Finally, the program is compiled using Symantec's Visual CafŽ (included on the CD-ROM) and then tested.
Two forms of the program are tested: one invoked locally and the other remotely over an Ethernet LAN.
This illustrates CORBA's powerful transparency facility whereby it doesn't matter whether the object you're
dealing with is on the local machine or on one in some distant corner of the intergalactic universe. The
two methods are compared with the results showing only a minor difference in the performance.
Two more chapters fill out the remainder of this section, which builds directly on the results of Chapter 4.
First, an applet version of the count program is constructed then a version involving the use of
Visigenic's C++ ORB as opposed to their Java ORB. Performance comparisons are made between various
permutations of the applet-based client and application client on one hand and the Java and C++ ORBs
on the other. When the dust has settled, Java ends up looking pretty solid in comparison to C++ as a
platform for developing distributed client/server applications and applets.
Part 3 deals with the Dynamic CORBA where clients and servers discover each other at run time, servers
offer up services and interfaces when they become available, and clients have the ability to discover
these interfaces and services and use CORBA's Dynamic Invocation Interface (DII), Trader Services, and
Interface Repositories. The section rounds out with performance comparisons being made between the two
programmatic mechanisms for accomplishing dynamic behavior: dynamic invocation and callbacks.
Part 4 compares the CORBA/Java paradigm with its competitors: Sockets, HTTP/CGI, Servlets, RMI, and DCOM.
Toward the end of each chapter, the pattern that was started in Chapter 4 of outlining, implementing, and
benchmark testing against the Count/Ping example is repeated for each methodology. With the overall results
being laid out in Chapter 16 in the form of a report card-like chart, when all is said and done, Java,
along with CORBA/IIOP (Inter ORB Protocol) comes out as the winner. That's hardly a surprise because this
book is, after all, about CORBA/Java. Nevertheless, the authors do account for their biases and admit that
their analysis is not altogether objective. In any event, the reader has the code on a CD-ROM packed with
some heavyweight tools with which to conduct their own tests, if they so desire.
After a section consisting of five chapters where the gnarly innards of CORBA are exhaustively explored,
Part 6 goes into issues pertaining to client/server programming using JDBC, CORBA, and Java. The first of
the four chapters in this section presents what the authors call the "world's longest tutorial chapter"
on the JDBC protocol. Reviewed here is everything you need to know about JDBC from the core API to the
metadata interface. Covered here are various performance issues involved in choosing between various 2-tier
and 3-tier client/server architecture's using CORBA, Java, and JDBC. A very extensive benchmark toolkit is
constructed, which builds on the Ping by creating a fully transactional OLTP banking system along with tools
for testing a number of performance metrics such as throughput and response time across concurrent users.
The database programmer gets a tremendous amount of value: learning how to construct a complete JDBC
database system from the ground up and to build a scalable CORBA middle-tier application server.
Part 7 covers all things pertaining to beans. Its seven chapters is a book unto itself on bean-related issues
including excellent tutorials on the JavaBeans component model, the Enterprise JavaBeans specification,
and something I'd never heard of before reading it here, CORBA Beans, a brand new model initially conceived
by the so called G4 (Netscape, Oracle, IBM, and Sun) and submitted to the OMG toward the end of 1997 as a
marriage between CORBA and JavaBeans. What emerges is a kind of JavaBeans++, a language-independent
distributed component model expected to be finalized in late 1998.
Part 8 concludes this heavy-hitting tome by demonstrating the step-by-step construction of a full-featured
state-of-the-art, Web-based, 3-tiered client/server application using all the technologies addressed in the
previous chapters. The application itself is quite a doozy: a club-Med Web-based reservation system that
can serve as a prototype for many a Web application. The authors use some of the latest tools to build its
various parts: including IBM's VisualAge, Symantec's Visual Café, and Inprise's JBuilder
Java programmers, CORBA programmers, MIS programmers, and client/server architects need look no further
than this book to obtain the state-of-the-art in the practical aspects of modern distributed computing.
The first edition has already sold several hundred thousand copies and this edition with its greatly
expanded coverage of core issues of CORBA, Java and JDBC and brand new chapters on JavaBeans, EJB, and
CORBA Beans should sell just as well. The material is extremely well presented; always with authority
and a touch of humor. The examples are convincing and highly useful for real-world programmers. If you
haven't done so already, go to the book store today (or log on to any number of online venues) and pick
up this excellent resource.
You won't be disappointed.
Lowell E. Thomas (firstname.lastname@example.org) is a freelance consultant
based in New York City. He specializes in database and multimedia applications.
Version Reviewed: 2.5
Current Version: 2.5
Cup rating system:
16811 Hale Ave., Ste. A
Irvine, CA 92606