Sun's Java Studio Creator 2 is the company's upcoming second release of its somewhat lauded, somewhat maligned visual application development environment. In this review I give Java Studio Creator 2 (JSC2) Early Access edition a fresh look and discuss its merits and limitations.

For the uninitiated, JSC2 is Sun's effort to bring the same visual approach to Java/J2EE Website development that Microsoft Visual Studio or Macromedia Dreamweaver users have enjoyed for years. Sun works to make the visual design approach in JSC2 more comprehensive from a J2EE perspective than what you would expect from Dreamweaver by allowing JSC2 users to tap directly into business logic and data represented by EJBs, Web services, or databases using a drag-and-drop paradigm.

Sun's target audience for this IDE are somewhat-technical employees working at small-to-medium businesses (SMBs). I say "somewhat technical" and not "developer" since by taking a primarily visual approach to application development, JSC2 opens the role of the front-end developer to graphic artists, business and/or system analysts, and other users not traditionally associated with actual J2EE development.

Getting Started
For this review, I loaded JSC2 on an HP laptop running Windows XP Pro, with an AMD Athlon 64 3200+ processor, 1.25GHz RAM and 40GB hard drive. Sun recommends a slightly less beefy machine, running at least Win 2K or XP, with an Intel P4 1GHz, 512MB of RAM, and 325MB of hard disk space. JSC2 is available for Solaris, Windows, Linux (Java Desktop or RedHat), and OSX - that's right, "write once, run anywhere" is alive and well, thank you very much.

Installation did not go smoothly the first time round; I ran into an error with the bundled PointBase database engine and had to reinstall with a later build. I write this instance off as being an "early access" bug; the second installation attempt went off without a hitch.

JSC2 is built atop of NetBeans 4.1 - Sun's open source, all purpose Java IDE - and is able to leverage a few advantages due to its heritage. First, JSC2 gives the developer access to roughly the same set of tools that NetBeans provides - editors for all of the common languages associated with Java/J2EE development (Java, JSP, XML, WSDL, and the like), robust refactoring support, project building, HTTP monitoring, and more. JSC2 currently allows development in JDK 1.3.x and 1.4.x; 1.5 is not yet supported.

Second, NetBeans is a well-liked IDE with a robust community of developers backing it; if you run into a question or have an issue with JSC2, chances are good you'll be able to find assistance from within the NetBeans community online. While Sun doesn't recommend that JSC2 act as your primary IDE (more on this later), should a Java developer need to dig into the code, the tool certainly can support this.

Java Studio Creator 2 is available free for members of Sun's Developer Network; non-members pay a yearly subscription fee of $99. The pricing is very competitive with Microsoft's .NET Visual Studio Standard edition, which retails for $299, and with Macromedia's Dreamweaver 8 at $399.

First Impressions
When first starting JSC2, the user is presented with the Welcome screen (see Figure 1), which offers options for opening an existing project, starting a new one, or exploring tutorials on how to best use the IDE.

Setting up your own project is similar to the process in NetBeans. The breadth of project types, of course, isn't as comprehensive as NetBeans, Eclipse, or other Java IDEs such as IntelliJ or JDeveloper, but reasonable considering JSC2's focus on J2EE development.

Slow Going
After selecting a demo project to launch, JSC2 hung for quite a long time - several minutes, at least - before coming back to life. I have a reasonably well-endowed machine, and expected JSC2 to be a tad more responsive. Fortunately, subsequent launches of the IDE into an open project were faster affairs. Unfortunately, this wouldn't be the last time I would encounter slow performance from JSC2 during the course of my review; the IDE would sometimes take a few minutes to redraw the interface after having closed the lid on my laptop (see Figure 2). Quickly comparing JSC2 to Eclipse, which has always been rather speedy, the first major difference to come to mind is Eclipse's pioneering use of SWT instead of Swing, which is what NetBeans and therefore JSC2 use. However, without spending time tracing down the exact cause of the sporadic slowness in JSC2, it is difficult to know for certain.

Another minor niggle: running the bundled PointBase database in the background opens a shell window, which is left open as long as PointBase is running. To a battle-hardened J2EE developer, this is immaterial; however, seeing as JSC2 is meant to open the world of Website development to a larger, non-developer audience, it seems a little ghetto, especially in consideration of how polished the rest of JSC2 is. Hopefully, subsequent editions of JSC omit the phantom shell.

Visual Approach
I appreciated the fact that Sun took the visual approach to its logical conclusion in Java Studio Creator, working this concept into each of the main IDE features. The list of features includes (obviously) a visual JSP editor, visual database Query editor, visual CSS stylesheet editor, and visual page navigation editor.

Design, JSP, and Java Modes
Web pages from a project opened in JSC2 start the user off in Design mode. The user can drag-and-drop user interface (UI) components onto the rendered JSP page, and manipulate and customize from there. Each Web page has an associated Design, JSP, and Java view. The JSP mode allows you to edit the JSF tags underlying a page; the Java mode opens up the code for the bean that drives the page's behavior and content (called a PageBean in JSC parlance). While the JSP and Java editors in JSC2 are top-notch, Design mode is king for this IDE, and it's where you're likely to spend most of your time working (see Figure 3).

Drag-and-Drop Power
JSC2 offers up a comprehensive selection of user interface components, built on top of the JavaServer Faces (JSF) spec. All common form elements are represented (radio buttons, password fields, text areas, drop-menus, etc.). Tables come with the ability to sort each column, calendars, messages (for providing alerts or status updates), and a JavaScript-driven tab set. Also included are so-called composite components, such as a breadcrumb trail or an add/remove list, as well as data validators and converters, and code clips (snippets of code to help power your app). Sun has provided a strong stable of UI components likely to be used in your app and then some. UI components are accessed from the palette pane; these are grouped logically by type (Basic, Layout, Composite, etc.); you can create new categories based on your own organization if desired. JSC2 generates clean, well-formed JSF tags within the JSP for each UI component dragged onto a page in Design mode, as well as Java code for that page's associated PageBean.

The Fear of Generated Code
That brings us to the scary world of generated code - the fear of which is best known by its clinical name "Codiusgeneriphobia" - a black concept in the mind of most developers. It's one thing to have your IDE generate rote code, such as getters/setters, or onerous code like EJB remote/home interfaces; it's quite another for an IDE to generate code that might actually drive some of your apps behavior.

Code generated by JSC2 comes complete with warnings in the comments that any changes are subject to being replaced. I was somewhat shocked when I looked under the covers at the code that JSC2 was generating for the single Web page I had been working on during the course of this review. The PageBean created by JSC2 was replete with attributes and getters/setters; calls to JSF UI component objects - including try/catch/finally blocks for JSF-specific exceptions; calls to other beans; image object configuration details; JDBC connectivity parameters, SQL statements, RowSet handlers, and more. Obviously, this kind of bleeding between application tiers or concerns could cause serious problems in the future, in terms of debugging, maintenance, and future refactoring - especially if the need ever should arise to use this generated code outside of any editor other than JSC.

Another area of concern is the ability to test each unit of code created by JSC2. Given the overt complexity of the PageBeans generated by the IDE in support of each page's functionality, you're basically sacrificing the ability to atomically test each object through JUnit.

Easy Access of Business Services
JSC2 makes short work of accessing information or business logic by providing direct access to database tables and views, EJBs, and Web services (see Figure 4). One omission is the inability to access business logic through a generic POJO as an alternative to working with an EJB for business logic; given Sun's predilection for perpetuating their dubious EJB technology, this is hardly surprising. As Sun's target market for JSC2 are SMBs, the lack of a legacy system (mainframe/midrange) or ERP integration is understandable. JSC2 comes preconfigured with drivers for DB2, Oracle, MS-SQL Server, Sybase, and PointBase; adding another SQL engine such as MySQL or PostgreSQL is quick and painless, and provided with the appropriate JDBC driver.

Leveraging the JSF spec, user interface elements dropped into a page can be bound to any available business service; this is basically a straightforward, point-and-click process in three steps. Simply right-click on the UI component, select the data resource from a drop-menu, choose which elements from that data source you'd like represented in the UI component, and you're done. JSC2 imports the appropriate data and/or logic and automatically updates the Design view with a preview of the information that will be imported.