The Backbase Client Framework is a standards-based, server independent solution to creating web applications, ranging from traditional to desktop-like. It uses AJAX technologies to easily develop and deploy Rich Internet Applications.
The Client Framework is based on AJAX and web-based technologies that offer an enterprise-grade environment to develop standards-based code in both declarative and functional programming models, which is capable of running seamlessly in all major browsers. Developers can use the Client Framework as an extension of XHTML, a JavaScript toolkit, or a combination of both. Developing Rich Internet Applications using the Client Framework is simplified, because you can design your web applications in an object-oriented way, and use a model-view-controller architecture to make your application maintainable and extensible.
Backbase is pleased to announce the release of Rich Portal 4.2. This release includes an improved configuration mechanism, support for gadgets that exist independent of the layout manager, and a new data-provider tag that allows content feeds to be established programmatically.
Online resources:
Backbase is pleased to announce the release of Client Edition 4.4.2. In addition to priority bug fixes, this release includes a number of feature improvements.
Backbase Client Edition 4.4.2 can be downloaded from http://www.backbase.com/download.
Backbase is pleased to announce the publication of Backbase 4 RIA Development, a book about the Client Framework written by Ghica van Emde Boas and Sergey Ilinsky.
Backbase is very proud to announce the release of Rich Portal 4.1. This release includes support for server-side rendering, which delivers performance gains and enables Rich Portal pages for search engine optimization.
Online resources:
Backbase is pleased to announce the release of Client Edition 4.4.1. In addition to a number of priority bug fixes, this version of the Client Framework is optimized for Rich Portal 4.1.
Backbase Client Edition 4.4.1 can be downloaded from http://www.backbase.com/download.
Backbase is proud to announce the release of Client Edition 4.4.0, the latest version of its Enterprise AJAX Framework that includes a cross browser implementation of the SVG tag library.
The Client Edition delivers a robust foundation on which many of today's highly interactive websites have been built. And now, it also forms the basis of the latest version of the Rich Portal, a framework for creating personalized customer interaction environments, which aggregate information and applications from multiple sources into an unparalleled user experience.
We strongly recommend upgrading to Client Edition 4.4.0, which can be downloaded from http://www.backbase.com/download.
Backbase is proud to present Rich Portal 4.0, an important release of its framework for creating online personalized environments.
A Rich Portal page aggregates information and applications from various sources in a unified interface that end-users can personalize by adding content, adjusting preferences, and rearranging the layout.
A live demo of Rich Portal 4.0 is available at Rich Portal Demo. To request a trial version, please visit the Rich Portal Product Page.
Backbase is proud to announce the release of TDL Optimizer 2.0. If you are new to TDL Optimizer, it is designed to reduce the network latency by packaging resources together and optimizing those packages for their size. This is the first occasion Backbase TDL Optimizer is delivered as a separate download (the previous release was bundled with Client Edition and JSF Edition).
We strongly recommend upgrading to this latest release. Download Now »
Backbase Data Services 1.2 is now available, and includes support for JSON message formats, improved error handling, and improved configuration.
We strongly recommend upgrading to this latest release. Download Now »
Unlike traditional JavaScript, with its support for global variables and functions, Backbase technologies are designed to support many object-oriented concepts. This article describes the object-oriented nature of Backbase 4.x TDL and BTL.
When searching through the BDN forum for e:fragment you will find multiple complaints about javascript errors when using bb.command.load, or the declarive c:load equivalent, in combination with the <e:fragment /> as the root node of the requested file. Hopefully this blog post will clearify this issue.
In essence, the <e:fragment /> is an empty container, it will not be resolved to an XHTML element in the DOM structure. For instance, the <b:box /> is translated by the Client engine to a plain XHTML <div /> element. The <e:fragment /> tag doesn't have such a template.
The TDL Optimizer Video Tutorial walks you through the process of using the TDL Optimizer tool to minimize the number of HTTP requests for TDL bindings, so that you will become more familiar with using the TDL Optimizer to improve the performance of your Backbase-enabled applications.
Archives of the demo applications for the Client Edition 4.3.1 and the JSF Edition 4.3.1 releases are available for download.
We are proud to present the latest release of the Backbase Client Framework 4.3.1. We strongly recommend upgrading to 4.3.1. It can be downloaded at http://www.backbase.com/download.
The documentation is available on the BDN, and you can find a detailed overview of the changes in the Release Notes, as well as in the Change Log for Backbase Client Framework. Below is a short overview of what's new.
To coincide with the Client Edition 4.3.1 release, a new Eclipse plugin is available from the Backbase update site at http://eclipse.backbase.com/cpa. This posting describes the installation procedure, new and improved features, and known issues.
The Backbase Bundle for TextMate now has templates, drag commands, language file with preferences and a lot of snippets for easy development.
If you are not able to work with TextMate there is an editor that can also work with these bundles called E-TextEditor.
Although this bundle is not a supported Backbase product we do appreciate any comments you could have on it. If you are using something that you think might be of use for all of us using this bundle do not hesitate to add a comment.
We are proud to present the latest release of the Backbase Client Framework 4.3.0. We strongly recommend upgrading to 4.3.0. It can be downloaded at http://www.backbase.com/download.
The documentation is available on the BDN, and you can find a detailed overview of the changes in the Release Notes, as well as in the Change Log for Backbase Client Framework. Below is a short overview of what's new.
This example explains the Backbase dataGrid widget. The dataGrid is intended it to enhance the display of tabular data, supporting among others: sorting, formatting, editing, styling and paging. This widget provides high performance, also if the resulting table is very large, with thousands of cells.
This example shows you how to add a pager to a dataGrid widget, how to provide the user with dynamic control over column order, and how to 'freeze' columns when scrolling.
This example shows how to add editing and keyboard navigation functionality to the BTL dataGrid widget.
This example shows how the Backbase Client Framework can be used to enrich an existing web page by adding drag-and-drop functionality to HTML table rows.
Inputting data from a client to a server is most often done using a HTML form. The action in the form indicates the script on the server that is invoked when the form is submitted. The task of the server script is then to validate the form. When something is not right, usually the server script will redisplay the form, with the values that the user typed before already filled in, and an indication of what was wrong. This can be frustrating for the user if every time he/she mistypes something, the page is refreshed. To make it worse, some server scripts have trouble redisplaying the values already entered.
In this article, we explain how to approach Automated Testing in Web Applications, focusing specifically on how to test Backbase applications.
After addressing the background and benefits of automated testing within web projects, we demonstrate how to use Selenium and Ant to realize automated functional testing in a Backbase application.
In conclusion, performance tuning should be considered as an important issue at the early stage of web application project. During the project, performance test cases should be set up and should be kept up-to-date.
In general, there are five ways to improve the performance: the last three ways are suitable for most web applications, the first two are more specific for applications using the Backbase Client Framework:
This chapter focuses on performance tests as a benchmark that measures the optimization strength of an application and determines the extent to which an effort should be put into further optimization. Here are some general rules of how to develop such a test:
Define test cases for specific parts of the application. Do not just define one test case for the whole project. This helps to easily target which parts of the application need to be improved most.
This chapter describes some important methods during the deployment phase to achieve better performance.
The second chapter introduces many useful skills to help you choose the correct Backbase widgets and technologies when tuning performance.
Instead of using the full Backbase RIA implementation or traditional XHTML for a web application, combining these two model islands is a great approach. In this way, we can get the benefits from both sides: the speed from XTHML space and the functionality from the Backbase Client Framework.
Here is a quick checklist for checking performance on Backbase Applications:
During the early stage of the web application life cycle, we should pay attention to the following:
This page demonstrates how you could use the Backbase Client Framework to code generic cross-browser implementations of several animation and transition techniques that deliver smooth 3D-like animation effects.
The main challenge with using the Backbase Client Framework to develop web applications is to balance the client-side logic with server-side logic. Rich Internet Applications (RIAs) require more logic on the client, but putting too much logic on the client-side can be a disaster for performance.
There are many reasons for performance issues. This chapter aims at finding these reasons and providing some hints and tips to avoid overloading the client. These performance tuning methods are categorized into four stages, each represents one of four basic steps during the web application development life cycle: architecture, implementation, deployment and server-side optimization. The performance testing is then addressed, followed by a conclusion and reference information.
|
