Framework Comparison: Backbase AJAX framework Vs Other Similar Framework (Part 1)

The landscape of client-side technologies

Since 2005, when the term AJAX was invented, many JavaScript libraries and tools have popped up. In fact, there have been several tools earlier to aid DHTML development, which can be seen as predecessors for the AJAX tools and libraries. One of these is the earlier version of the Backbase framework, and another example is Bindows.

Some of those libraries survived the AJAX technology hype and grew into a solid base for many RIA projects and services, whereas some vanished.Libraries that survived have gone through a series of transformations and refactoring phases as well as marketing repositioning attempts. By now, there are hundreds of libraries, frameworks, and other tools, and it is not easy at all to find your way in this abundance and make the right choice.

Before we get to the actual comparison of the Backbase AJAX framework against similar solutions, we should look around to see how the canvas of relevant technologies is laid out. So, let's first go through the tree of technologies until we end up in a group where Backbase resides.

We mentioned earlier in this book that there were a number of other versions of the Backbase framework, all Java-related, such as a JSF Edition. These products are currently supported only for existing customers and not available for new development. Therefore, they are not included in this comparison. Of course, it is still possible to easily use Java with the Backbase Client Framework!

Server-side and client-side

Until recently, we thought of web applications as websites being created and run on a web server somewhere on the Internet. The server-side application was entirely responsible for the page generation: it checked for authorization, retrieved data from data sources, and generated static web pages filled in with the data.

With time, server output in HTML became enhanced with scripts running on the client-side, but the page generation and the business logic between user interactions was still processed on the server-side. To aid such rather complex development, several technologies and frameworks are available, for example, GWT, ASP.NET MVC, and ZK.

Today, web applications development has radically changed; the frontend of the application is moving to the client-side, the web browser. Both application logic and UI generation are moving with it. This is exactly where client-side toolkits come into play.

Let's proceed with those and ignore the server-dependent frameworks in the rest of this article. See the end of this article for more information on the frameworks mentioned earlier in this section.

Client-side libraries and frameworks

Most of JavaScript toolkits position themselves today as frameworks, although they called themselves libraries earlier. Some may really have evolved into a framework, whereas others are still, libraries.

In reality, it is not easy to differentiate between the two types of software: libraries and frameworks.

  • The common understanding of a library concludes that a library is designed to execute a well-defined task, for example, a library can decode data or, in the case of a JavaScript toolkit, it can simplify DOM traversal. As a library is designed to execute a certain task or a couple of tasks, it is usually not extensible in nature.
  • A software framework usually has wider scope. Eventually, it could be composed of several libraries. A framework, opposite to what a library does, allows and sometimes even requires extensions. A JavaScript framework often provides means to create widgets; it enables its own event's flow and provides well-designed APIs to those widgets.

Is it important to know whether a certain JavaScript toolkit is a library or a framework? We believe, yes, it is important.

In practice, you will see that a library is often used to fine-tune web pages, while a framework is used to build true client-side applications. For example, the library provides great visual effects that can be used to improve web page appearance and interaction, while the framework qooxdoo can hardly be used for that purpose; it is only suitable for building an application.

Being categorized as a library does not decrease the quality or capabilities of a toolkit. Instead, it properly positions software so that a right choice can be made based on the purpose of using it. jQuery, MooTools, Prototype.js, and are all JavaScript libraries, and they are great at what they had been designed for: enhancing web pages without changing much in the overall development process.

We will not include the JavaScript libraries mentioned in this section further in our comparison.

Flash, Silverlight, and JavaScript-based frameworks

For the sake of completeness of the technology comparison, it may also be interesting to check out how some AJAX frameworks stand compared to plugin-based solutions, such as, Flash or Silverlight.

Both Flash and Silverlight employ XML for application layout, MXML and XAML respectively.

Both Flash and Silverlight have a way to extend their component base by implementing custom tags in custom namespaces, something that the Backbase AJAX framework also offers.

Both platforms, similar to some JavaScript-based frameworks, implement the Document Object Model, which enables document access and event flow, although Silverlight provides a custom, lighter version of the DOM API. Styling is not done with CSS, in either Flash or Silverlight.

The plugin-based solutions such as Flash and Silverlight are both great choices for building Rich Internet Applications that run on a desktop. They are not usable for mobile devices because these plugins do not run on them.

Client-side GUI framework and application framework

There is another category of frameworks that we would like to exclude from our comparison: the application frameworks. Examples of such a framework are Cappuccino, SproutCore, and PureMVC.

PureMVC is, as the name suggests, a framework that is there to help you implement the MVC part of your application.

To position Cappuccino, we quote here some text from their website, which sums up very nicely what it is trying to achieve:

Cappuccino is not designed for building web sites, or making existing sites more "dynamic". We think these goals are too far removed from those of application development to be served well by a single framework. Projects like Prototype and jQuery are excellent at those tasks, but they are forced by their nature to make compromises which render them ineffective at application development.

On the other end of the existing frameworks are technologies like SproutCore . While SproutCore set out with similar goals to Cappuccino, it takes a distinctly different approach. It still relies on HTML, CSS, JavaScript, Prototype, and an entirely new and unique set of APIs. It also requires special development software and a compilation step.

The Backbase AJAX framework is not an application framework; rather it is a GUI framework. For smaller to medium-sized applications, you do not need an application framework, as long as you structure your application correctly. For larger applications, you could consider developing your own client MVC support, or try to integrate with a framework like PureMVC.

Backbase and other client-side GUI frameworks

In our knock-out competition, we have progressed now to a state where we have a set of JavaScript frameworks that are comparable in functionality to what the Backbase offers. For the comparison below, we selected: Bindows, Dojo, Ext JS, Javeline,qooxdoo, and YUI. Let's now take a deeper look at the most relevant characteristics of those toolkits and see how Backbase compares. We will consider the programming model, the widget set, component models, data binding, support for standards, performance, internationalization, and long-term viability.

We start with an overview table. Detailed descriptions follow in the next sections.








Ext JS








Programming model








Widget library








Component model

Binding Language

Binding Language

Dijit plugin


Binding Language



Data Binding

field set

data set

data set

data set

field set

data set

data set

Cross-browser support
















As you can see, this comparison table is not too useful because it merely shows what these frameworks have in common. We left out performance in this table because there is no easy way to compare these frameworks quantitatively and we do not know about any benchmark tests.

Programming model

The programming model varies between frameworks. It is a matter of developer preference to see which model he/she is more comfortable with. To help you find your own preference, we included a section at the end of this article to compare an Ext JS example with the same example in Backbase. We also use this example to show you how you can integrate other frameworks into Backbase if desired.

There are two different approaches used:

  • XML for UI layout and JavaScript for UI logic
  • JavaScript both for UI layout and for UI logic

In the first group, we have advanced toolkits such as Backbase, Bindows, and Javeline; in the second group, there are Dojo, Ext JS, qooxdoo, and YUI. The toolkits in the first group make use of XML as a way to layout the application UI and they provide a DOM or a DOM-like interface to it.

The toolkits in the second group produce widgets in a different way. They also provide other ways to register widget event handlers.

The major benefit of using XML for UI layout is better separation of the three concerns: UI, logic, and style. Just using different syntaxes for those areas forces better understanding of how to organize code; it also enables programming practices that were used for designing native HTML pages that have been proved to work well. Such a separation comes with a price: a framework might need some more time to process the XML initially. However, in practice, this does not seem to lead to significant degradation.

Using JavaScript both for UI layout and logic may lead to, as it is known "spaghetti-code", where at some point it becomes rather complex to maintain the application source base. A major problem is that often the look and feel of a page is hidden away in JavaScript source files. If they are included in the HTML page, it will make the code incomprehensible to most graphical web designers.


Every framework in our comparison has a great variety of UI widgets.There are comboboxes, tab boxes, date pickers, grids, and so on. It is vital that widgets in a framework follow common design principles so that the developer would be able to start using one, without the necessity to dig in first into documentation.

The widgets are often grouped into the following categories:

  • Layout widgets
  • User input widgets
  • Grid widgets
  • Windowing widgets
  • Others

In the Backbase AJAX framework, the widgets fall into similar categories, which is accidental, but rather because of the inheritance chains they follow. For example, all user input widgets have disabled and value attributes, and all layout widgets have margin and padding attributes.

Component model

The ability to create new components or extend existing ones helps hiding widgetspecific logic and presentation issues away from the application logic. A reusable component can be instantiated several times inheriting all logic its class has defined.

Backbase has a great technology for defining and extending UI widgets, the Tag Definition Language (TDL). TDL is a core concept in the Backbase methodology because it is used to build its own GUI library of widgets.

The other toolkits are all (except YUI) enabled to build components, some in similar and others in different ways. For example, Dojo is working on building a solid plugin system to create components, while Ext JS has provided this earlier. A model for creating components is not applicable to YUI, as YUI is rather a collection of disconnected widgets.

Data binding

Data binding is an essential mechanism for building more complex applications. The toolkits that provide data binding have all data set bindings, to bind sets of data to lists and grids. Javeline and Backbase also allow finer granularity field bindings.

Standards support

Talking about standards, support for our set of JavaScript toolkits is tough. It is well known that browsers don't support well-established standards, so why would some framework aim to do so? And what standards can a framework support?

Most JavaScript frameworks support standards exactly for the reason that browsers do not support them: to allow developers to create applications that work crossbrowser or that can use new standards not available in any browser yet.

The Backbase APIs have been greatly inspired by the DOM and XBL (XML Binding Language, see standards. In browsers, the implementations for the DOM and for XBL are either very inconsistent or missing. As there is awareness of these standards among web developers and because there is evidence that browsers are striving to implement those eventually, application logic written today against the Backbase AJAX framework will pretty much work in future browsers natively or it will be easier to migrate it when these standards become available.


Open source AJAX frameworks such as Dojo, YUI, or qooxdoo have done a great job implementing aspects of internationalization. Their widgets can be easily adjusted to use different date or time formats for example.

The Backbase framework has some functionality for date formatting in its calendar widget, but further internationalization support is currently absent. Internationalization is on the radar of the Backbase development team and we expect that better support will be available at some point in time.


Performance considerations have always been of high importance when choosing an AJAX framework.

A major problem for many frameworks is the occurrence of memory leaks causing performance to degrade over time. At Backbase, performance is watched closely by running nightly performance tests and thus tracking the changes in the framework, and spotting potential memory leaks.

Performance can be adversely impacted by the necessity to do additional interpretation or compilation of the framework-specific code. The extra model and controller layers in the Backbase framework certainly require extra time. The gain in the level of abstraction you can use for your development and the shorter development times that should result are in the long run more important than the raw performance impact. History shows that eventually better optimizers and better hardware will offset the slower performance. After all, nobody would consider these days to program an application in Assembler language anymore.

Web browsers recently made a great leap in the struggle for the rendering speed. In fact, they have come to a point that the difference in performance of different frameworks became rather slight.

Long-term viability

The long-term existence of any software product depends on many factors other than its technical merits. Company strategy and profitability of a product are essential for the survival of closed source or company-owned products like the Backbase framework, Bindows, or Javeline.

Also, many open source products can only survive because of support by large companies: Microsoft supports jQuery, and the Apache web server or the Eclipse IDE would not exist today without considerable grants from IBM.

If we just look at the technical side of things, we believe that the Backbase AJAX framework has longer term viability because it tries to preserve the application programming model that exists in a browser rather than creating a new one.

The Backbase Core implements DOM APIs that you know from the browser, and these APIs will stay. XML as a technology for UI layout is well proven for HTML. Although it has not been given enough attention in the development community, XML-based markup for the UI of web applications will exist in a foreseeable future because, for UI designers , an XML-based language is much more manageable than a conventional programming language such as JavaScript.

Similar to Flash making use of MXML or Silverlight making use of XAML, the Backbase XML languages simplify interface creation while providing great separation between UI, logic, and style.


We did not try to convince you that the Backbase framework is the best framework by telling you that it has more widgets than its competition or something else. We did tell you however, where to find the competition and what features you can expect from a framework like the Backbase framework. We hope that it is now easier for you to decide for yourself what you want or need from a JavaScript toolkit and how Backbase can fit into your requirements.

To make this story a bit more practical, we have an example in the next part of the article for comparing programming styles and integration of other frameworks within the Backbase framework.


In this article, we have shown you a way to look at the various JavaScript frameworks available and how to categorize them.

As a result of our comparison, we showed some benefits of using the Backbase framework:

  • XML-based UI layout technology
  • Standards-based APIs
  • Extensibility: TDL is a powerful and object-oriented mechanism to create new components
  • Server agnostic framework, although products exist for the Java environment specifically
  • Longer term viability: Technologies enabled in Backbase are more likely to stay for longer

There are some points to watch out for concerning the Backbase framework:

  • XML-based resources (such as TDL bindings) cannot be served from a third domain
  • Application markup is hardly accessible for Internet crawlers
  • Does not fit traditional website creation, which actually is also a benefit
[ 1 | 2 ]

>> Continue Reading: Framework Comparison: Backbase AJAX framework Vs Other Similar Framework (Part 2)

You've been reading an excerpt of:

Backbase 4 RIA Development

Explore Title