ObjectShare's Parts for Java Professionals

 
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 projects—or the entire PARTS system for that matter—is 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 todd@lacemaker.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 content.

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 foreseeable future.

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.0—due 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 pack.

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 Client/Server.

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 (
lthomas@sigs.com) is a freelance consultant based in New York City. He specializes in database and multimedia applications.

 


SideBar
Side Bar Line   MugMugMug
Version Reviewed: 2.5
Current Version: 2.5

Cup rating system:
4 Outstanding
3 Good
2 Acceptable
1 Poor


Vendor Info
ObjectShare, Inc.
16811 Hale Ave., Ste. A
Irvine, CA 92606
v: 949.833.1122
f: 949.833.0209
www.objectshare.com

Featured

Most   Popular
Upcoming Events

AppTrends

Sign up for our newsletter.

Terms and Privacy Policy consent

I agree to this site's Privacy Policy.