• Home
• Features
  • Submit an article
  • Presentations and Articles
  • JavaPolis 2004 Online
  • JavaZone 2005
  • Announcements
  • Newsletters
• Forums
  • Overview
  • Help & FAQ
  • Posting guidelines
  • Recent postings
  • Popular discussions
  • Who's online
• Blogs
  • Popular blogs
  • Start your free blog
  • Recent blog entries
• JL Network
  • Javalobby.org
  • Javacrawl.com
  • JDocs.com
  • JRoller.com
  • JUGCentral.com
  • MyJavaServer.com
  • Friends & Partners
• Members Only
  • Control Panel
  • Subscriptions
  • Downloads
  • Benefits
  • Special Offers
• About JL
  • Our story
  • Sites & Services
  • In the News
  • Privacy policy
  • Contact us
  • Advertising info
  • FAQ

Is JSF ready to take on ASP.NET?

In the last two years since JavaServer Face's release to the public we've seen strong developer support as well as powerful IDE integration now being offered. Is it too soon to start comparing JSF development to Microsoft's ASP.Net/Visual Studio development experience?

I don't think so...

For comparison's sake I'll took a look at two key technologies offered by Microsoft: ASP.Net 2.0 and it's integrated development environment Visual Studio 2005 (Code named Whidbey). I'll then compare them both to the component technologies available in the core JSF technology as well as the leading JSF development environments. (Keep in mind that I'm by no means a .Net dev expert, but I think I know enough to effectively begin comparing .Net and JSF.)

Microsoft's Development Offering

First a quick intro to Microsoft's development technologies...
As you may be aware, the next big release for Visual Studio .Net and ASP is Visual Studio 2005 (Whidbey) and ASP.Net 2.0. Here are some key features that impressed me the most about them.

The Components: ASP.Net 2.0

The new ASP.Net 2.0 components, or as they are called in Microsoft lexicon: "controls", are designed to be more powerful yet requiring less developer coding to make usable. A prime example of this being the transformation of ASP.Net 1.x's Datagrid control to its 2.0 replacement the Gridview. The new 2.0 Gridview comes tightly couple with the Visual Studio development environment with easily accessible helper wizards known as "Smart Tasks" which can allow for quick customization of the Visual control from the visual editor. So for example a Gridview can be quickly customized on screen to set the columns staticly or dynamically, define if they are sortable, pageable etc. The developer can also use this popup helper wizard to quickly configure the look and feel for the component as a whole as opposed to entering numerous individual visual attributes for the control.

In general the Gridview along with the other 2.0 controls are enhanced with productivity and less manual coding in mind. They also totally utilize Visual Studio's Smart Task popup editors to make them easily customizable.

The Environment: Visual Studio 2005

As mentioned in the Gridview example, the upcoming Visual Studio 2005 edition offers more tightly integrated ASP.Net control interaction thus improving the usability of the controls themselves. Having quickly mentioned the ability to easily pull up advanced property editors which are customized for each control, I'll review the key features of Visual Studio 2005 development environment which impressed me the most.

• Inituitive Rendering: Visual Studio provides intuitive visual rendering of ASP control in the visual editor. This means that if you drop an ASP control onto the canvas, it renders as (as close as possible) as the runtime rendering occasionally with "dummy data" to give the correct visual impression of the control's runtime rendering. As you select the control, you can either edit it's properties using a generic property editor window, or a nifty new "Smart Tasks" popup editor which is customized per control.
  
  
  
• "Smart Tasks": "Smart Tasks" is a simple to use popup property editor customized for each ASP.Net control. It allows for customized configuration of complex controls. For example one can easily define the properties of a Gridview control such as the datasource, the columns of data to appear, whether or not editing, sorting or paging is possible. It is even possible to define the appearance of the control itself such as alternating row colors, basic color themes etc.
  
  
  
• Easy Databinding: Databinding can be done by using a "Smart tasks" popup property editor and assigning a datasource or by dragging a data object directly from the "Servers Explorer" to the canvas and be provided with a pre-databound gridview and datasource control.
  
  
  
• Easy to use page templating: With Visual Studio's "Master Page" technology it is very easy to build a "master" page which serves as a page template for other pages. Visual Studio provides a simple checkbox approach to decide whether or not to create a new page from a library of master pages.The visual editor also preserves the integrity of the content of the master page by providing editable regions in the pages based on master pages.
  
  
  
• Integrated Security: Visual Studio and ASP.Net provide a simple mechanism for building secure access to Web applications. By using the Login controls, one can quickly build a working login screen which plugs into the .Net security technology.
  s
  
• Built-in Mobile Development: Visual Studio 2005 offers substantial out of the box Mobile development for Microsoft associated Mobile devices.
• Application Themes: Offers the ability to create high level look and feel which can be swapped out, replaced and applied at runtime.

JavaServer Faces Development Offering

So now we come to the point where we compare what is available today with JSF development environments with what I've briefly reviewed from Microsoft's stack.

Intuitive rendering

Let's take a look at how well the JSF IDEs offer onscreen intuitive WYSIWYG rendering of JSF UI Components (basically equivalent to ASP controls). The news here is quite good! The ability to work on a visual canvas and see JSF UI Components in their runtime rendered states is actually doable today in several JSF enabled IDEs including Sun's Java Studio Creator, Oracle's JDeveloper 10.1.3, IBM's WSAD 5.1.2, as well as the recently initroduced M7's NitroX JSF IDE. All of these tools provide WYSIWYG JSF visual editing to differing levels of support.

Here are a few JSF IDE's and their visual JSF editors:


Oracle JDeveloper 10.1.3's JSF enabled Visual JSP Editor


Sun Java Studio Creator's JSF Visual Editor


IBM Websphere Application Developer's JSF enabled JSP Visual editor

Score: Tied both MS and JSF IDES offer this feature.

Easy Property Editors (Like "Smart Tasks")

The ability to easily edit properties of rich or complex components such as a JSF dataTable using an easily accessible editor similar to Microsoft's "smart tasks" editor does exist to varying degrees in certain JSF IDE's. For example Sun's Studio Creator allows one to edit the "Table Layout" by right-clicking on a DataTable in the visual editor. IBM also offers a pretty powerful property editor for it's custom version of the dataTable: HX:datagrid. Oracle JDeveloper also offers the ability to access the "properties" of the dataTable component through it's reentrant dataTable wizard.

However because of the differences between IDEs, this feature generally exists in the various JSF IDE's but each take their own getting used to because of their inconsistent approach and UI. Ideally having a single wizard standard for accessing JSF components in a visual editor would be great but probably not practically feasible.

Some Customized JSF IDE Property Editors


JDeveloper 10.1.3's Reentrant DataTable Wizard

IBM WSAD's Datagrid Property Editor


Sun Creator Studio's Table Layout Wizard for dataTables

Score: 1 point for Microsoft. Although various JSF editors offer advanced property editors, Microsoft offers a single, consistent wizard for this. (Kind of a benefit of owning the entire technology)

Easy Databinding

Do JSF IDEs offer the ability to easily databind JSF UI Components?
Yes, again to varying degrees. For example Sun's Java Studio Creator offers the ability to drop a data bindable UI Component onto the page first and then drop a data item such as a table onto the component and have the data attributes of the component set. IBM also offers wizards to support this. Oracle JDeveloper also offers the ability to drag and drop a component such as a DataTable and a creator wizard steps you through the process of databinding it to any JSF accessible data source. Oracle's production version of JDeveloper due out later this year will offer much more advanced databinding where you can drag and drop items from its Data Control Palette and have it create various pre-bound JSF UI Components.

Although the databinding for .Net is powerful, it is still most easily done with Microsoft's dataserver technologies (SQLServer) as opposed to being equally supported for all available databases/datasources while the JSF IDEs on the other hand offer considerable databinding to a wide variety of database/datasource which are Java compliant. So I think's fair to say that the JSF IDEs compete extremely well with Microsoft.

Score: 1 point for JSF IDEs for their ability to support multiple datasource/datatypes in very flexible ways.

Easy Page Templating

Although various JSF IDEs offer page templating to a certain extent such as IBM page templating, there is not yet a uniform easy way to build page templates such as how you use Microsoft "Master Page" templating technology. The near future looks better for JSF IDEs in that more page template support is being offered in products such as JDeveloper possibly a few others, but in general what would really be great is a standard approach to Web page templating which is approved by the JCP. That way all JSF IDEs can implement a single Web page templating strategy.

Score: 1 point for Microsoft's Master Page templating technology

Integrated Security

To the best of my knowledge I have not quite seen a simple to use approach to building in security into a Web application as what I see with Visual Studio's "Login" controls and smart tasks wizard which allow you to easily build the security for a Web application. This is not to say that you can't build security with the JSF IDEs, it's just that this takes a little more work to construct your security access policy and build UI forms that tie into a backend security system such with the application server or to a 3rd party LDAP server. Because of the high degree of attention needed for securing an enterprise application, it's debatable whether a simple point and click, 2 seconds and it's done, feature for JSF/J2EE applications is worth doing.

Score: Tied, although easy to use MS's Login features, a high degree of scrutiny and effort would still be required to build a really secure Web application.

Built in Mobile Development

Here is an area where Microsoft really provides a powerful development solution, however it only supports Microsoft's PDA technology. I've seen a small plug-in for PalmOs development in Visual Studio but it was so minimal and independently created, it is not worth mentioning.
For JSF IDE's I haven't seen much yet, however Oracle's production version of JDeveloper will be offering a very compelling JSF PDA development solution with both its Visual editor and ADF Faces. Oracle's ADF Faces JSF Components come with built-in PDA support and the production version of JDeveloper offer a PDA friendly Visual designer.

Score: Tied, although MS offers compelling technology for PDA development, it lacks adequate support for non-Microsoft PDA development. On the other hand, Oracle's ADF Faces offers built-in PDA support for different device types, but visual editor integration is not yet available until the production version JDeveloper 10.1.3.

Application Themes (Skins)

The ability to offer application level look and feel, or themes is definitely doable in JSF IDEs by using the common strategies of using a master CSS or images, however there doesn't yet exist a standard for build application level "look and feel" for a JSF or J2EE application which can be changed at runtime. JSF however does offer the core technology for doing this with its "pluggable rendering" technology where individual UI Components can render themselves in different ways depending on the client's request. Oracle's UIX technology (A predecessor to Oracle ADF Faces) provided exactly this capability where "skins" could be created and associated to user interface components and be applied/changed at runtime, however this capability is still being worked out in the current versions of ADF Faces.

I haven't seen other JSF based "Skinning" technologies yet that are tightly integrated into a visual IDE.

Score: 1 point for Microsoft. As much as I would like to give credit for JSF's pluggable rendering technology and Oracle's UIX technology, I still have to give a slight edge to Microsoft's Application theme technology since it is usable in a Visual IDE.

Summary

Although the Microsoft feature barely edged out the equivalent JSF IDE development features in this basic comparison, I think the new JSF enabled IDEs still offer a worthy challenge to Microsoft's technology. It should also be pointed out that the features highlighted from Microsoft's stack while compelling, are still beta. So for today's JSF IDEs to compete quite well with Microsoft's proprietary visual development environment which has yet to be released leads me to conclude that JavaServer Faces integrated development environments can now effectively take on Microsoft's development environment today, and although they may not yet offer all of the features in Microsoft stack, it is just a matter of time as the competitive nature within the J2EE community itself will also provide substantial energy to propel the evolution of JSF IDEs into the future and possibly even beyond Microsoft... It could happen! :)