More action with Struts 2
In a recent review of Struts 2 in Action, JW Blogger Oleg Mikheev notes that Struts 2 is "just a collection of extensions built upon WebWork, which is ultimately the right thing to learn before starting a Struts 2 project." While Struts 2 has some architectural flaws, Oleg calls WebWork well-designed, well-tested, and reliable. What are your experiences using Struts 2 and WebWork?

Also see "Hello World the WebWork way," a JavaWorld excerpt from WebWork in Action, by Patrick Lightbody and Jason Carreira.

Newsletter sign-up

Sign up for our technology specific newsletters.

Enterprise Java
View all newsletters
Email Address:
JavaWorld.com

A first look at Borland's JBuilder IDE

After an extended pause, Borland jumps into the Java IDE market in a big way -- find out how this tool measures up and how it compares to the Symantec IDE Visual Cafe

By Chuck Mcmanis, JavaWorld.com, 11/01/97

In June 1995, when I first heard that Borland was going to make a Java tool, I was quite pleased. Borland was the only company that put a dent in the Visual Basic franchise that Microsoft had created. Further, Borland's Delphi development environment is considered by many (including myself) to be the best rapid application development (RAD) tool on the market. So it was with great excitement that I bought Borland C++ 5.0 with Java support late in '95.

Unfortunately, the Borland effort left a lot to be desired. One of the product's biggest drawbacks was that the Java support was an add-on module to C++, rather than being a tool in its own right. The problem with this approach is that Java wasn't all that much like C++ in terms of its compilation units, object files, and compilation targets. In Java you compile a class file into an object that you can immediately instantiate with other objects that are already on the system. There are no ".exe" and ".dll" targets, which are the model used by the generic C++ IDE. Thus, building classes was cumbersome, the documentation was nearly non-existent, and the experience was wholly unsatisfactory. The C++ compiler worked great though.

On the heels of the C++ add-on product, word quickly got out about "Latte," the code name for an IDE environment that the engineers from the Delphi group were going to work on and that was written completely in Java. The ambitious project was beset by delays; it demoed at the first JavaOne Developer Conference in San Francisco in 1996 and then again at JavaOne '97. Finally, it has been released as JBuilder.

A quick tour of JBuilder

JBuilder shares many common themes with the Delphi world and feels similar enough to the Symantec Visual Cafe tools. So it was easy for me to get going with JBuilder -- even without reading the supplied documentation. (When I did have a question, the documentation was fairly complete in terms of describing the available options.)

The environment consists of a "control bar," which is a floating toolbar window, a "browsing window" with a layered tree control on the left, and a viewing window on the right. There is only one control bar, but several browser windows can be open.

The control bar, shown below, consists of the standard menu commands across the top, a palette of tools on the left that provide shortcuts to the menu items, and a collection of components (JavaBeans) that are available for use in your visual application or applet. Below the tool palette and components is a status line that is updated with whatever activity is taking place at the current time.

JBuilder's control bar

The browser window is shown below. This window is where you interact with your source code, either HTML or Java. Above this is the control bar, which lets you start actions (such as a rebuild) and holds your collections of JavaBeans for use in your own applications. Further, each browser window can display a project going on in it, so if you are working on multiple projects -- such as a new JavaBean and an application that uses it -- you can have both projects open at once and easily move between them. This capability impressed me as it supports the most common form Java development, changing several different pieces at once. In one browser window there can be a project of utility classes, in another browser the applet that uses those classes, and in a third a set of HTML pages that use the applet.

Resources
  • "A look at inner classes"
    Reduce class clutter in your Java designsUse inner classes. http://www.javaworld.com/javaworld/jw-10-1997/jw-10-indepth.html
  • "Take an in-depth look at the Java Reflection API"
    Learn about the new Java 1.1 tools for finding out information about classes. http://www.javaworld.com/javaworld/jw-09-1997/jw-09-indepth.html
  • "Take a look inside Java classes"
    Learn to deduce properties of a Java class from inside a Java program. http://www.javaworld.com/javaworld/jw-08-1997/jw-08-indepth.html
  • "Build an interpreter in Java -- Implement the execution engine"
    Here's how to take the interpreter classes and run with them. http://www.javaworld.com/javaworld/jw-07-1997/jw-07-indepth.html
  • "How to build an interpreter in Java, Part 2The structure"
    The trick to assembling the foundation classes for a simple interpreter. http://www.javaworld.com/javaworld/jw-06-1997/jw-06-indepth.html
  • "How to build an interpreter in Java, Part 1The BASICs"
    For complex applications requiring a scripting language, Java can be used to implement the interpreter, adding scripting abilities to any Java app. http://www.javaworld.com/javaworld/jw-05-1997/jw-05-indepth.html
  • "Lexical analysis, Part 2Build an application"
    How to use the StreamTokenizer object to implement an interactive calculator. http://www.javaworld.com/javaworld/jw-02-1997/jw-02-indepth.html
  • "Lexical analysis and JavaPart 1"
    Learn how to convert human-readable text into machine-readable data using the StringTokenizer and StreamTokenizer classes. http://www.javaworld.com/javaworld/jw-01-1997/jw-01-indepth.html
  • "Code reuse and object-oriented systems"
    Use a helper class to enforce dynamic behavior. http://www.javaworld.com/javaworld/jw-12-1996/jw-12-indepth.html
  • "Container support for objects in Java 1.0.2"
    Organizing objects is easy when you put them into containers. This article walks you through the design and implementation of a container. http://www.javaworld.com/javaworld/jw-11-1996/jw-11-indepth.html
  • "The basics of Java class loaders"
    The fundamentals of this key component of the Java architecture. http://www.javaworld.com/javaworld/jw-10-1996/jw-10-indepth.html
  • "Not using garbage collection"
    Minimize heap thrashing in your Java programs. http://www.javaworld.com/javaworld/jw-09-1996/jw-09-indepth.html
  • "Threads and applets and visual controls"
    This final part of the series explores reading multiple data channels. http://www.javaworld.com/javaworld/jw-07-1996/jw-07-mcmanis.html
  • "Using communication channels in applets, Part 3"
    Develop Visual Basic-style techniques to applet design -- and convert temperatures in the process. http://www.javaworld.com/javaworld/jw-06-1996/jw-06-mcmanis.html
  • "Synchronizing threads in Java, Part II"
    Learn how to write a data channel class, and then create a simple example application that illustrates a real-world implementation of the class. http://www.javaworld.com/javaworld/jw-05-1996/jw-05-mcmanis.html
  • "Synchronizing threads in Java"
    Former Java team developer Chuck McManis walks you through a simple example illustrating how to synchronize threads to assure reliable and predictable applet behavior. http://www.javaworld.com/javaworld/jw-04-1996/jw-04-synch.html