First Look: Sun Java Studio Creator (Early Access)

Despite its name, Java Studio Creator is not a tool for creating studios. Instead, it's a tool for creating JSP-based web applications using JavaServer Faces (JSF). This might seem like a fairly narrow focus for an IDE, but Sun has made a commendable choice: to focus on one segment of an IDE's potential market. To do one thing, and do it well.

At its core, Creator is intrinsically about making development simpler by limiting choices. This theme resurfaces often when using the product.

As an aside, this could be an interesting development for IDEs: "vertical" creator tools built on a more generic, mature codebase (in this case NetBeans). I wonder if we'll see more "vertical" IDEs in the near future? Java Studio Creator Desktop/Swing Edition, for example?

Before I launch into this first look at Sun Java Studio Creator, it's worth lingering for a moment on the name. What the hell happened there? Talk about a name designed by committee. And to make it worse, the name doesn't adequately describe what the product is. Compare the names of past IDE/language "greats": Visual Basic, Delphi, Turbo Pascal, Emacs. These are all great, memorable names. Sun should have kept to the product's core principle ("keeping it simple") and called it something simple but inspired, like... Creator. Or "Web Creator". This would then allow for similar branded editions, such as Java Swing Creator, Java EJB Creator and so on. Or if inspiration really failed them, Sun could always do what car manufacturers do, and name the product after a planet.

As it is, people have already begun referring to the product simply as Creator, as that identifies the product nicely. It's not too late for Sun to learn from this: the "Java Studio" part is totally redundant. Anyway, I just had to get that off my chest. Back to the review...

Although it's focused on web applications, Creator also allows you to create and connect to web services. It doesn't include support for the full J2EE suite of APIs (EJB, JMS etc). So it loses out immediately to its main rival, WebLogic Workshop. But unlike its rival, Creator isn't just limited to the WebLogic app server.

Installation

The number of options during installation has been kept to a minimum. You get to tell it where to install, and that's about it. J2EE 1.4 gets installed regardless. This is actually quite a good thing: installers are notorious for plaguing the user with silly questions; often there's no indication of how the choice is really going to affect the user. "When using this product, will you mostly be wearing a hat? Y/N" So top marks to Creator for assuming sensible defaults and sticking with those.

On the down side, the installer seems to start up various services (PointBase etc). Surely installation is just about getting the thing installed. Afterwards, running it is about getting things started up. Probably not a real problem though.

First Impressions

This is what you see when Creator first starts up.

The layout is obviously optimized for high-res desktops. For most users this won't be a problem, but might be an issue for anyone programming on a laptop. For such people, they can always reconfigure the layout if it really becomes a problem.

Creator is of course built on top of NetBeans. This gives it a flying start, and the advantages it gains from this are many. The Java editor is luvverly (especially if you're already used to it). Abbreviations, code completion and auto-Javadoc all speed up coding immensely.

Creator gains all the flashy new gizmos from the new NetBeans 3.6, including the new properties panel and the new windowing system, complete with dockable windows.

Some of the nicer touches from NetBeans also make a welcome appearance; e.g. all the window sizes and layouts are remembered next time you start the product up. And some of the not-so-good NetBeans features have actually been improved upon or hidden altogether. For example, the Options panel is neat and tidy, having been whittled down to a very small subset of options, compared with the absolute mess of an Options panel that NetBeans users must put up with.

Exploring the IDE

The Toolbar consists of big, chunky Fisher-Price icons. While these might seem like fun for the first thirty seconds or so, they quickly begin to look (and feel) out of place. I say "feel" because their feel is non-standard. The rest of the UI uses the Windows look & feel; but the toolbar behaves differently. If you move the mouse over a toolbar button, it doesn't change in any way (the border should become visible). Small matter, but for such a prominent part of the UI it seems a bit botched-up.

On the plus side, Creator has improved the NetBeans explorer window. The replacement is the Project Navigator, which initially at least is tucked away in the bottom-right corner of the screen (an odd place for it). The NetBeans Filesystems concept is hidden away (you can activate it via the Project Navigator but it isn't there by default). In its place, Creator has a "Logical View" of the project, where the files are organized by category instead of location.

These categories are: Web Pages, Java Sources, Resources (images, stylesheets) and References (where all your external JAR files go). When you first create a new project, the References section is pre-loaded with JAR files for JSF, web services, JDBC Rowset and so on.

If you're using a different web framework, XML library or whatever, you can add in your own JAR files here. But let's face it: if you're into choices of this sort, you just won't be using Creator.

With Creator, it's not possible to compile an individual file. You have to build the entire project. Luckily, the build is incremental, so only classes that need to be recompiled will be. But I can think of a few people who will miss being able to hit F9 to do a quick compile of the class currently being edited. But the same problem that makes NetBeans 3.6 a non-option for a lot of people is also a problem in Creator: you can't compile JSPs prior to deploying them.

Code Clips

The palette on the left consists of "Code Clips" (e.g. "Call Web Service Method"). The purpose of the Code Clips (or is that snippets?) is that they provide snippets (or is that clips?) of code that you can drag into your Java code. It's a neat idea: just drag a snippet (e.g. "Concatenate Strings") from the Clips palette into the main Java editor, and the snippet is added into your code. A nice feature is that you can also select some code in the editor, and drag it over to the Clips palette to automatically create a new Clip. Nice.

This part of the product is strangely inconsistent, as if no-one could agree on naming (rather like the name of the product). The Clips palette, simply called "Palette", has a Clips tab; and the Clips tab contains "snippets" (not "clips"). The popup clip editor dialog is called a "Snippet Viewer", although it's not just a viewer because the code clips can also be edited.

There's no double-click default action on the clip items (dohh!), but if you right-click and choose Edit, then a modal dialog pops up containing the Java code snippet/clip. Why modal? That just seems kinda lazy, or rushed. Slightly worse, the snippet editor isn't syntax-highlighted. In fact it looks as if they've just used a basic JTextArea instead of the "proper" NetBeans Java editor. This means there's no undo/redo, no line numbers, macros etc. This is an odd decision, as the Java editor is designed to be modular, so that it can be embedded in Swing forms pretty easily.

The Clips palette is a bit twitchy. If it loses focus, it switches back to the Clips/Demo tab, meaning that currently that's the only place you can create new clips. Unfortunately, clips can't be dragged to other folders in the palette; so any new Clips you create have to go in the Demo folder. Oh well.

Also - and like the twitchy tab thing this is probably just a bug (which hopefully will be sorted out soon) - but the act of dragging a code clip into your code isn't undoable. You can delete the code of course, but Ctrl-Z just pings at you, scolding you for your impertinence.

The Page Editor

The page editor - the centrepoint of the whole application - is really nice (although it's not without its serious limitations, which we'll go into in a moment). Java finally has a true drag-and-drop, nearly-WYSIWYG WebForms-style editor for creating dynamic web pages. For example, you can give it a style sheet to use, and the editor changes to use the new styles.

At the bottom of the editor, there are a couple of tabs so you can switch between the Design view and Source view. The Design view is the "WYSIWYG" page view, whereas the Source view is a JSP source editor where you can view and edit the JSP code that gets generated when you drag-and-drop components onto the page.

The Design view updates if you edit the JSP code directly. There were some bugs in this area (e.g. delete a component from the JSP code, switch to the Design view, then switch back to the Source view and the component magically reappears), but I'm guessing these will be sorted out by the time the product is released.

Unlike the main editor tabs, the Design and Source tabs can't be dragged around and docked elsewhere. This is a shame, because it means that you can't view both the Design and Source editor windows simultaneously.

If I had to seriously criticize any one part of the visual JSP editor, it would be that the default layout is Visual Basic-style x,y positioning. This carries over to the web page itself, which uses CSS positioning to maintain the same layout; e.g. "position: absolute; left: 360px; top: 528px".

In the web form's Properties tab, I expected to see a property for changing the layout manager, like in Swing. Fair enough that the default was the nefarious and non-portable x,y layout. But as long as you could set it to an equivalent of GridBagLayout or SpringLayout (e.g. generating HTML tables to maintain the layout on the deployed page) then that wouldn't be so bad.

The x,y layout seems to be a concession to the VB crowd, and those programmers who always found Swing layout managers a bit on the tricky side, poor lambs. I'd always admired the Swing team for taking the bold step of using the "layout manager" approach in the first place, probably knowing that it would turn away the VB crowd.

With Creator, the x,y positioning is a step forward in the sense that what you see on the form is what you get on the deployed web page. But it's also a big step backwards in terms of usability and I18N. It also makes it trickier to create web pages that work nicely across varying sized desktops and devices. In fact, the lack of a web layout manager really sucks. Sure, you could create your JSP separately and then drop it into your Creator project; but that isn't what Creator is about.

Paint By Numbers: JavaServer Faces

Creator is a "paint-by-numbers" approach to creating web apps. It forces you to use their particular MVC architecture. Your web framework shall be JSP + JavaServer Faces (JSF). Server-side component event handlers will use managed page beans. If you're happy to let Creator make these kinds of decision for you, then it might be quite a good thing because what you end up with is a nifty IDE that makes developing web apps very simple.

Creating data-bound components is also pretty simple. For example, you can create data-bound Lists, link them to tables and define the SQL that populates them.

The Early Access release is limited to PointBase (which ships with the product); but Sun has indicated that version 1.0 will provide support for other databases. Let's hope so, otherwise the product just won't be of any use.

Creator does a nice job of keeping model, view and controller concerns separate: your event handler code goes into the page bean, and JSF handles the nitty-gritty of linking the JSP components to the component event handlers.

It's nice to see that JSF has finally found a use; but it would have been nice to be able to plug in alternative web frameworks. But then that wouldn't be what Creator is about. However, developers have already begun complaining that Creator doesn't allow you to add your own web components. You're basically stuck with the default set that JSF provides. This is severely limiting. The product needs to be more extensible than this.

Page Navigation

Page navigation is a really nice feature in Creator. It includes a "lines-and-boxes"-style editor (see the screenshot above) where you can see all the JSP pages in your webapp. If you click on a page icon, it expands to show its components. You can then drag from one of these components to another page icon, to create a navigation link. It's as simple as that. Perhaps a bit too simple though. I expected to be able to double-click the link between the two pages, to insert some server-side logic; e.g. to redirect to some other page instead.

I hope that Sun develops this part of the product further in a near-future release. The Page Navigation editor has a lot of potential, and in many ways is more important than the WYSIWYG page editor. But currently it's just a bit too limited. It has more flash than substance.

Where Does Creator Fit In?

Overall, experienced J2EE developers will find Creator's "less is more" approach to architectural choices rather restricting. But it's a necessary step to attract new developers who prefer the "Hobson's Choice" Microsoft approach.

Microsoft have of course been very successful with this approach: they limit the number of different ways that you can create something, and then concentrate on making very polished tools that support those limited options. Want to create a web app? Use Web Forms. No messing.

Java has always been about the exact opposite: choice. For every aspect of enterprise development with Java, there have always been many alternatives. WebForms? Pah! We have JSP, Struts, Verge, Tapestry, Swinglets, WebWork and so on. The people that choose to use Java for choice represent a vibrant community of developers. The sheer mass of open-source tools and frameworks available for Java is why a lot of people prefer to use Java over anything Microsoft produces. Like agile methodologists, these developers are constantly pushing the envelope, looking for better ways of doing things. They're a different breed from the VB crowd, who are more interested in getting the job done quickly than "pushing the envelope". Both approaches make sense, and it's possible to argue for or against each.

Until now, Sun has targeted (or been lucky enough to be adopted by) the forward-thinking "envelope-pushing" crowd. They need to simplify J2EE development, but not at the expense of their (hard-)core developer audience.

So they've made a very clever choice with Creator. In one sense they're doing the same as Microsoft, creating a lock-in IDE that forces you to paint a picture where they've already drawn the outline for you. On the other hand, Creator is built on top of NetBeans, a generic IDE that doesn't limit your options in the same way. So they're not switching off a vital segment of the developer workforce by any means. Even if many NetBeans users continue to defect to Eclipse or IDEA, it doesn't really matter: they're still Java developers.

For many existing Java devotees, then, Creator won't be of much interest. If you're already using WebWork, for example, you won't particularly appreciate being forced to use JSF. But then, Creator isn't targeted at you. Instead it's a blatant attempt to attract VB/DotNet developers over to Java - the ones who don't mind vendor lock-in, as long as there's a clear and obvious way of getting the job done.

Considering its purpose, then, Creator is a brave attempt, and comes very close to achieving its goal. Without taking into account its real purpose, it's an oddity: a strange little IDE that forces you down some very narrow paths. But considering why it's been designed the way it has, for a pre-1.0 version it does its job admirably.

Until now, DotNet developers have been able to boast of their great advantage: "Well, we has got WebForms, innit?" Now, finally, Java has a drag-and-drop tool to match. Creator still needs work to make it a really viable competitor, but another point-release or two (if Sun stick with it and get it right) should sort that out. From a marketing perspective (which might be all that really matters for its target audience), it gets ticks in all the right boxes.

Recent book reviews:

Refactoring: Improving the Design of Existing Code (Martin Fowler)

Use Case Driven Object Modeling With UML: A Practical Approach (Doug Rosenberg, Kendall Scott)

The Inmates Are Running the Asylum (Alan Cooper)

Message Forum:

Agree/disagree with this review? Please add your comments below!

Post a new message

Desktop/Swing version is planned
Vincent Brabant vincent.brabant@skynet.be
Yup!
David Bates david_lewis_bates@hotmail.com
from where i can download Sun Java Studio Creator ?
chakravarthi chakri_oruganti@yahoo.com
weblogic workshop allows all that and more
sujith sujithmcc@yahoo.com
The only one I am interested in is free!! ...
Jian jet03252000@yahoo.ca
Java Studio Creator 2.1 Start up problem
Annie 
Can not start Java Creator 2 Main Window
Wei Hu wei.hu@manchester.ac.uk
Where did u download it from?    Tell em this first! ...
Anonymous person 

Post a new message

<< Back to Reviews

<< Back to the Front Page