Evans Data Study: RAD scores the highest user satisfaction

It was with great pleasure that I read the Evans Data Study that was released this week; the study was a survey of over 1200 IDE users, and the bottom line was that RAD had the highest user satisfaction scores among the IDEs rated (including Oracle JDeveloper, Microsoft Visual Studio, MyEclipse and NetBeans). A survey is a survey; I have no doubt that you could find users of all of the above IDEs who are passionate supporters of their product of choice – but this survey revealed that compared to the other IDEs (and I’m quoting here) “RAD is just head and shoulders above them when it comes to user satisfaction.”

Cool; that’s what we’ve been trying to deliver, and it’s gratifying to see that our users are pleased with what we deliver.

What was most heartening to me, though, was what the survey didn’t measure; namely RAD 7.5. I think RAD 7.0 (which is the latest GA version of RAD that’s available) is a pretty darn good product, and the survey seems to agree with me – but I am even more pumped about what we have coming down the road, in the form of RAD 7.5. As I’ve discussed in this blog, we’ve had RAD 7.5 available in open beta since late last year – that code was refreshed at the beginning of May, and we’re still working on it. The fact that we were able to deliver public beta code so early in the schedule is a testament to the state and the quality of the release; we’re still adding features and function, we’re still fixing defects and improving the quality even more, and we’ve also got the benefit of lots of additional user feedback, with enough time (for a change) to do something about it. Put it all together, and I’m convinced that RAD 7.5 will be the best RAD we’ve ever delivered.

Back to the survey; results were provided giving an overall satisfaction of the different IDEs, and the various capabilities within the IDEs were also rated (how does your debugger rate, how do your web design tools rate, etc). Although we were first place in the overall rating, the RAD results in the individual areas were mixed; we did great in some places (application modeling tools, tech support, profiler, web design tools), and less well in other aspects. There was not a lot of variability in the rating for editors, all the products scored well - but in that category, RAD was in last place, for example.

That actually doesn’t surprise me, as the editors were one of the areas I was most concerned about as well – and for that reason, the editors, and the editing experience were one of the areas we’ve spent the most time and energy on, in RAD 7.5. I was presenting at the IBM Impact conference in April, and showed off some of the new features in RAD 7.5 – let me share a couple of highlights with you:

• The various deployment descriptor editors in RAD 7.0 were attempting to abstract away the details of the actual changes being made to the underlying files – but we’ve heard from numerous customers that it’s more important to assist the developers… but still “leave them in touch” with the underlying files being updated. We have a great new editor framework (the source of several patents) that we’re using across RAD 7.5, that means developers who make a change in the editor, will have no problem know what (and where) they have changed in the actual file – but at the same time, we still provide lots of help and validation in editing the actual contents. These new editors are getting great feedback from our beta customers.
  
  
• We’ve had a big focus on refactoring operations and quick fixes, both of which surface via editors of all shapes and sizes. Eclipse has a great history when it comes to providing refactoring operations, and RAD 7.5 really takes and extends that model; we participate in many existing eclipse refactoring operations now (for example, a rename will do the right thing across the many J2EE artifacts, as well the just the Java code), and we have added several of our own, J2EE specific refactoring operations. These refactoring operations allow us to provide significant help to developers who are updating their code, while leaving the editors to do just that – provide a good, focused, editing experience. Again, the feedback from beta users to date has been very positive on the changes we’ve made.
  
  
• JavaScript is increasingly important in a web 2.0 world, and so we’re introducing significant new support for JavaScript in RAD 7.5 – we have a comprehensive new JavaScript editor, which we’ve integrated into all the right places; you’ll now get support like code assist, syntax validation, and colour highlighting whether you are editing a standalone .js file, or a JavaScript snippet embedded in the middle of an HTML file, while you’re using the RAD page design tools.
  

These are just a few examples of the changes, improvements, and new features we’ve been developing for quite a while in RAD 7.5 – and the Evans survey has simply validated many of the decisions we’ve made; if we can be number one in user satisfaction with all our old editors, I’m super confident that we’ll be able to make developers even happier, and even more productive, with RAD 7.5.

Next up for me is the RSDC conference, in Orlando – we’ll be presenting and demoing RAD 7.5 there, so come by and say hi if you’ll be there.

Tim

The facts of RAD

MyEclipse has issued a press release that mentions RAD, and may cause some confusion, so I'd like to take this chance to set the facts straight.

First of all, the transition from WSAD to RAD was purely a naming one. WSAD was delivered prior to IBM's acquisition of Rational, and RAD 6.0 was simply the next version of "WSAD" released under the Rational brand. RAD is entitled as a free upgrade to all active WSAD customers; there is no new cost - describing the transition from WSAD to RAD as complex or costly is either uninformed, or intentionally misleading.

The plumbing that formed the core of both WSAD and RAD was donated by IBM to the eclipse WTP project, to provide a defacto standard interface that others could extend - meaning that any tool extensions will work correctly and naturally with RAD. MyEclipse uses this base, so the basic project structure is the same - but the vast majority of the components that form RAD are not part of WTP; they are only available in the IBM offerings. Those value add components and functional areas are where we're spending most of our time and energy on, and that's where the real benefit of RAD comes from.

RAD 7.0, which has been available for over a year, includes comprehensive support for J2EE & Web Application developers, with support for pure spec compliant applications, as well as integration for all the WebSphere extensions - for example we don't just support JSF, we also ship and have outstanding support for the IBM JWL widget library; the latest version of JWL (which is only available with RAD) makes it fall-off-a-log easy to create an Ajax application, with no handwritten javascript at all (see http://webspherecommunity.blogspot.com/2007/06/simple-ajax.html for more details).

That said, simply providing spec level support is not really a differentiator today; that's why we donated the code we did to WTP. The RAD value proposition is it's ability to improve the productivity of developers across the entire development life cycle. Some examples:

• Some other products provide simplistic support of UML, that requires iterative generation of java code, followed by import actions to keep the diagrams and code in sync. This round trip engineering approach was available back in Rational Rose, and is a long way from state of the art now. RAD provides much more than that - for example, we provide UML visualization, which allows you to view, edit, and update Java code using UML views. There's no separate model to get out of sync; you're editing the live code, but in UML.
• All modern IDEs include support for database interaction and definition, but RAD has the benefit of working with the DB2 developers to provide exceptional support (for all major databases); RAD includes graphical views of your data topology, a SQL scrapbook, impact analysis tools, the ability to write user-defined functions (UDFs) & stored procedures, and phenomenal support for embedded SQLJ.
• RAD has in-depth support for application profiling, analysis & testing; you can execute, monitor, and trace the flow and performance of your application, right out of the box.
  

Of course, we also have the benefit of working hand in hand with our IBM colleagues, to provide the very tightest integration with WebSphere. It's not hard to deploy an application to WebSphere Application Server, but only RAD includes copies of three versions of WAS, to simplify your unit testing on a "real" WebSphere server, at no additional cost. Because we actually embed the WAS server, we support both remote application deployment and local application deployment, which gives you better deployment performance because there's no copying of files necessary. RAD also includes complete support for WebSphere Portal Server, including creation wizards, views, and editors that enable you to develop, test, debug, and deploy portal and portlet applications.

When it comes to production application deployment, RAD includes an advanced Jython editor, designed to simplify the task of developing and testing WebSphere automation scripts. We also offer unique integration with the WebSphere admin console, allowing you to capture key actions in the admin console and turn them into the equivalent Jython script commands. Finally, there's an embedded Jython debugger, that will let you single step through the admin script, examine variable values, etc.

IBM remains strongly committed to RAD; the next version of RAD (7.5) has been available as an open beta since late last year; you can find more details here: http://webspherecommunity.blogspot.com/2007/11/rational-application-developer.html. As you'll see if you try this code, RAD 7.5 provides many compelling features that focus on developer efficiency such as JEE refactoring and quickfix operations, while offering enhanced integration with products from all IBM brands, but especially Rational, WebSphere, and DB2. As I said in my blog entry, I'm really pleased with the progress the team has made on RAD 7.5; even though this is just a beta, the code is great quality, the performance is good, and all early reports are extremely positive - come check it out!

Tim Francis,
WebSphere Tools & RAD Chief Architect

The wonders of modern hardware

I was at an IBM conference a couple of weeks ago, where some new hardware ideas were being presented. Perhaps it's my engineering background, but there's something very cool about building things you can hold in your hand - and when you combine that with the latest new technological ideas (multicore, etc), it's very impressive. In that light, I'm happy to share a video that I saw recently.



http://video.google.com/videoplay?docid=5125780462773187994

Tim Francis

Rational Application Developer

I have not posted to this blog for a while, and I can now explain why. Today, at the WebSphere Technical Conference in Vienna, we announced the upcoming availability of an open beta for the next major version of Rational Application Developer (RAD 7.5). Those of you who've read my previous posts (hi Mom!) will not be surprised by the themes we're focusing on for RAD 7.5; better support for the complete application development lifecycle, including refactoring operations and quickfixes that cover the complete Java EE programing model.

The RAD 7.5 beta also provides support for the WebSphere EJB3 feature pack, the beta for which is available now for WebSphere 6.1. The RAD support for EJB 3.0 allows us to really exploit annotation based programming models. Previous versions of the spec focused on deployment descriptors, and the matching RAD releases had advanced editors to support that. In RAD 7.5, the focus is on Java developers, and using the Java editor as a base - but extending the already powerful Eclipse editor by adding significant new function and capability to support developing an annotation based application.

The intent is simple; most developers creating applications for WebSphere are quite comfortable using Java, and we have a great Java editor in RAD/eclipse - so it's a mistake to force them to switch to a whole new environment (with wizards and graphical editors) when they want to define some aspect of server interaction (such as Web Services or EJBs). This is a natural extension to what the spec defines, but the way we're supporting that pattern within RAD is new, easy to use, and productive.

The other aspect that I'm thrilled about is just the fact that we're running an open beta, less than a year after we shipped the last major version of RAD. We're not done yet, and we have more good ideas that we're still implementing - but the code is great quality, and the performance is good... and this shows a commitment to delivering a rock solid, robust, and well performing RAD. The intent is to encourage developers to explore the product, and not feel concerned that they'll get in trouble if they try something non-standard or off the golden path.

I'm really pleased with the progress the team has made on RAD 7.5; this is going to be the best version of RAD we've ever delivered, and the open beta gives you a chance to see where we're at, comment on what you see, and help us refine the product to make it exactly what you need. You can sign up for the beta here, and there will be newsgroups available to report problems, ask questions, and give us your feedback.

Tim Francis

Simple Ajax

I've been at a couple of conferences recently, and one of the hot topics that everyone is talking about is "Web 2.0". The great thing about these cool buzzwords is that they mean different things to everyone - but "Web 2.0" generally implies web sites that provide a richer, more interactive experience. In turn, one of the technologies that is used to provide this experience is Ajax (Asynchronous Javascript and XML). Ajax is not new, the technologies have actually been around for many years, but the pattern has recently been popularized by modern browsers and high profile applications such as Google Maps, GMail, etc.

AJAX is not a framework or library, it is an application pattern (although many frameworks are emerging to help, such as Dojo). An Ajax enabled page uses Javascript to send an XML request to call back to the server, the server asynchronously completes the request and sends back results, and then more Javascript in the page updates some parts of the page (rather than refreshing the entire page).

The problem is that developing AJAX based applications is hard - it requires writing complex Javascript and DHTML, and the asynchronous nature of the pattern further complicates debugging. There are also a series of other problems that have solutions - but are easier to get wrong, than they are to get right: Making the browser's 'back' button work is tough; Javascript has a tendency to leak memory; you must test your code on many browser variants, etc. As noted, frameworks that will help are starting to emerge, most notably Dojo - but they are still immature, and still require that you write JavaScript code in your page.

WebSphere and RAD have supported JSF (Java Server Faces) based applications for several releases now, and the combination of JSF and the JWL component library we ship offers a powerful combination that simplifies the development of applications. What's new is that RAD v7 has introduced some common AJAX behaviors into our JSF component library; you can now provide capabilities such as scrolling data tables with no page refresh, dynamic menus, and entry fields that support type ahead. The nice part is that none of this function requires you (the developer) to write any JavaScript - the bulk of the function is encapsulated in the JWL component library, and the tiny snippets that are required can be generated for you by RAD. In turn, this means you get to avoid most of the problems listed above - but still provide the enhanced interaction that people are starting to expect from modern web pages.

JSF based pages can co-exist quite happily with "normal" JSP and HTML pages, so there is no requirement for you to make a huge investment and redo your entire site. Instead, you can update just the pages that you wish to modernize, and provide the basic interaction patterns that are the hallmark of "Web 2.0". There are several resources available to help you understand the new capabilities, but a couple of articles on developer works provide a good starting point. The first one is "JSF and Ajax: Web 2.0 application made easy" and provides a general overview, and a second article titled "Improve the usability of Web applications with type-ahead input fields" walks you through adding typeahead to a JSF based page.

As Ajax continues to mature, frameworks such as Dojo will continue to add value to the development of advanced web pages - but the capability that's available in RAD v7 and WAS 6.1 today is more than enough to allow you to provide your customers with a modern, interactive site, without forcing your developers to go through a painful development process.

Tim Francis