All Ajax development can happen serverside using the Backbase framework and JSF
The Ajax wave has led to the emergence of several Ajax frameworks over the past year or so, each promising to make Ajax development simple and reliable. So while developers are just about coming to terms with the concept of Ajax, they now encounter the question of which Ajax framework to use.
Backbase is one of the leaders in the Ajax market, with specialized Ajax offerings for Java as well as .NET.
In this interview Mark Schiefelbein of Backbase talks about various Ajax application development issues like security and compatibility. He also tells us about the features of Backbase’s product as compared to
other Ajax frameworks.
IndicThreads >> Hi Mark! Good to have you on IndicThreads. Would you like to introduce yourself?
Mark Schiefelbein >> Thank you for the opportunity to do this interview. My name is Mark Schiefelbein, and I am the VP Product Development at Backbase. Backbase develops a comprehensive Ajax development framework geared towards Java developers. The focus of my role is development of the product roadmap and management of the development teams.
IndicThreads >> How do you define an Ajax framework? Why should one be using an Ajax framework for developing Enterprise Java applications?
Mark Schiefelbein >> An Ajax framework helps developers to quickly create highly interactive web-based user interfaces. Such a framework incorporates rich user interface components, interaction patterns, server connectivity and extensive tools for development and debugging. It is not just about making an asynchronous call from the client to the server, but everything a developer needs to build an Ajax interface for an Enterprise Java application.
“It is not just about making an asynchronous call from the client to the server…”
IndicThreads >> The Java edition of Backbase is some 75MBs. That’s bigger than many application servers. If I add Backbase to a Java enterprise application, what are the things I need to do? Do I just place your JAR files into my WEB-INF/lib and get going?
Mark Schiefelbein >> Yes, it’s really simple. The Backbase Java Edition consists of a client-side and a server-side module. Both are packaged in a WAR file that can easily be deployed from Eclipse. The client-side module contains the XML and JavaScript required for running the Ajax interface in the browser. The server-side module manages the integration between the client and Java business and data layers.
“The Backbase Java Edition consists of a client-side and a server-side module…”
To provide some clarification on the download size: both the server- and the client-side modules are under 1 Mb each, but as a commercial vendor we are focused on shipping an awful lot of documentation and examples, which comes in at about 60 Mb. Some redistributed libraries and development tools make up for the rest.
IndicThreads >> Could you explain what the architecture would be like for a normal Java Enterprise application that is using the Backbase Java Edition?
Mark Schiefelbein >> The Backbase Java Edition is based on JavaServer Faces (JSF) and works well with any server-side architecture as long as JSF handles the view.
We have extended JSF to introduce a number of improvements, such as support for Single Page Interfaces and client-server state synchronization. In addition to that, we provide dozens of high-quality JSF Components including all well-known Ajax widgets such as a Tree view, Data grid, and Tabs.
A really new thing introduced by the Backbase Java Edition is that all or part of the controller logic can be executed on the client. The Java Edition contains an Ajax engine that runs inside the browser and manages interactivity with the end user. We believe that the ability to run more presentation logic on the client can result in a significantly reduced response time of the interface. Of course you can also continue to control your interface entirely from the server as with traditional web interfaces.
“The Java Edition contains an Ajax engine that runs inside the browser and manages interactivity with the end user…”
IndicThreads >> Is security one of the top concerns for Ajax applications? There’s always the possibility that one major Ajax related security bug could set the cat amongst the pigeons.
Mark Schiefelbein >> Backbase works primarily with medium-sized and large enterprises. In those companies security is always a top priority, regardless of the technology used. While any new technology has a potential for introducing new threats we feel those are pretty limited for Ajax.
“Security threats for Ajax are pretty limited…”
The ground rules are that you should not send sensitive information to the client, such as passwords, and that it should not be possible to inject illegal calls to server-side functionality into the client-side application. In this respect an Ajax interface is no different from normal web interface. Any web developer who is aware of these risks will develop secure applications. And web developers who are not aware of these risks will make mistakes even if they’re not using Ajax. By the way, the Backbase software itself has been audited and found not to pose any security threat.
IndicThreads >> Some feel that it’s just too risky to rely on the client’s browser for the working of the application and that it’s only a matter of time before something goes wrong on someone’s machine.
Mark Schiefelbein >> We typically advise against running business logic solely on the client. The solution to creating reliable applications is correct use of both the client and server.
“We typically advise against running business logic solely on the client …”
Form validation is a great example: Client-side validation is great for end users as it facilitates filling in forms correctly and quickly. However, the form should also be validated on the server. As mentioned before, the Backbase Java Edition is a great tool to distribute presentation and business logic appropriately across client and server.
“Cross-browser incompatibilities have led people to question the stability of the browser platform…”
Cross-browser incompatibilities are one of the reasons that have led people to question the stability of the browser platform. Backbase Ajax software provides a browser compatibility layer that solves these issues in the framework as opposed to leaving the burden on the interface developer.
IndicThreads >> In a recent interview with IndicThreads, Jonas Jacobi said that “Pure Ajax creates the next generation legacy applications” and “There is no migration path from a pure Ajax solution”. Is my application future proof if I use Ajax with Backbase’s framework?
Mark Schiefelbein >> Jonas suggests that you can avoid legacy by focusing on JavaServer Faces (JSF), and that is exactly what the Backbase Java Edition does. An application developer who uses Backbase does not have to be aware of the specifics of the client-side Ajax engine and can just use the JSF UI Components, which work according to the JSF standard.
“Avoid legacy by focusing on JavaServer Faces (JSF)…”
However, we have customers who cannot move to JSF today, usually because they need to continue supporting a legacy application. For those customers we are offering a client-only Ajax solution that works with any server-side technology. In addition, this autumn we will launch a Struts edition, which provides an easy way to add Ajax features to the large number of active Struts projects.
IndicThreads >> As you would know, the Java world is obsessed with standards. is Backbase working on standardization of any of the technologies involved?
Mark Schiefelbein >> Yes, we are working on a number of initiatives. First of all, we are a member of the OpenAjax initiative, which aims to provide standardized tooling for Ajax development, primarily based on Eclipse. Our development tools are already based on Eclipse and WTP and we expect that the OpenAjax initiative will drive further standardization.
“OpenAjax initiative aims to provide standardized tooling for Ajax development…”
Secondly, we are using existing standards where possible. Most prominently this is JavaServer Faces, which is at the core of our Java Edition. On the client-side we make extensive use of XML, XPath and XSLT, and of course JavaScript.
For developers it would be great to have a single standardized UI definition language. That’s why we are closely following all initiatives to create such a language and are directly involved in some of them, including the OpenAjax Initiative markup subcommittee.
IndicThreads >> There are so many Ajax frameworks out there that it’s quite difficult to understand how one differs from another. Are Dojo, Backbase, Google Web Toolkit, DWR, etc. directly competing with each other or does each have its own space / category?
Mark Schiefelbein >> Ray Valdes of Gartner has created a frequently used classification of Ajax frameworks in an article on application development trends. He lists four levels of Ajax support:
- Snippet level
- Widget level
- Framework level
- Enhanced Framework level
DWR focuses solely on remoting of function calls and hence falls into the snippet level category. Several UI Component vendors focus on providing individual widgets to ajaxify existing web interfaces. Those are examples of the widget level category. To reach framework level a toolkit needs to provide an integrated Ajax Engine, with – for example – a common browser compatibility layer. Dojo is an example of this. Backbase and GWT are examples of the enhanced framework level as they also provide server-side integration and tool support.
DWR – Snippet Level
UI Components – Widget Level
Dojo – Framework Level
Backbase and GWT – Enhanced Framework level
While today there are many, many Ajax offerings, very few provide the functionality and maturity required to build and maintain Ajax interfaces for business-critical applications, like Backbase does.
IndicThreads >> Working with Javascript and browser compatibility issues would rank very high on many developers’ “most irritating tasks” list. With Ajax, do developers have to deal with both these things every day?
Mark Schiefelbein >> Application developers are looking for productivity and want to be able to quickly assemble an interface from pre-built components and then easily wire these components together by setting properties and events. Unlike snippet and widget level frameworks, Backbase provides a comprehensive toolkit that includes a browser compatibility layer, utility functions, pre-built components, and sample code: it makes Ajax development a lot less irritating!
“Backbase makes Ajax development a lot less irritating…”
IndicThreads >> Ajax frameworks were initially thought to be client side only. However considering that vendors like Backbase are now offering JSF and Struts editions, I guess the server side technology also makes a difference. Is that the case?
Mark Schiefelbein >> When Backbase started development of Ajax software 4 years ago the first problems to solve were the browser compatibility problems, the lack of a runtime framework and lack of UI components. It made sense to first focus on those issues before adding server-side features.
Now that the client-side Ajax product is mature enough we are focusing on integration with the server. Most developers prefer using a familiar server-side framework to program the user interface. The Java Edition is targeted at those developers. Everything can be done server-side using JSF.
IndicThreads >> Thanks Mark for sharing your insight into the world of Ajax. Any final thoughts you would like to share?
Mark Schiefelbein >> If you are considering to use Ajax with JSF, feel free to download an evaluation version of the Backbase Java Edition.
Related:
Seven Ajax Frameworks / Toolkits to watch out for
