Top Reasons of Poor Performance of A TIBCO BW based Project

By | June 11, 2015

TIBCO BusinessWorks (BW) is a very handy tool which helps medium as well as large enterprises to integrate their heterogeneous systems in an efficient manner and run the business smoothly. TIBCO BW is not only good in terms of its ease of use and development friendliness; but also equipped with all the required features to outperform in highly critical environments with huge flux of data flowing around.

Despite all the great features available in TIBCO BW; some of the common mistakes committed during the project design, development and deployment; may lead to poor performance of the projects developed and deployed using this great tool.

In this post; I am going to talk about a few major blunders or mistakes that are committed by developers or architects in BW based projects.

 

Inefficient Usage of JDBC activities

Data is the key in almost every business and we can’t even think of any projects which don’t involve database related activities. Same is true for any integration projects developed using TIBCO BW. TIBCO BW provides different JDBC activities for updating/inserting/deleting/querying the data and also for invoking the stored procedures.

Writing queries with higher execution cost results in higher processing time of the queries and often causes JDBC timeout errors. Queries should be fine tuned; underlying databases should be properly indexed to reduce the associated costs of all the queries involved in any TIBCO process.

Specification of proper timeout value in JDBC activities configuration is also important. Specifying very low timeout value will result in higher rate of overall JDBC timeouts in the process. Timeout values should be decided only after a thorough analysis of the queries involved.

When using JDBC Query activity to fetch huge number of records from database; Process in Subsets option should be used and in subsequent activities; proper grouping should be used to iterate through the records in an efficient manner.

Since database activities are always time taking; any unnecessary redundant queries to the database should be avoided and data re-usability should be increased in the project. For example; If you are fetching some configuration data from the database in a starter process; same information should be flowing to any subsequent processes which also require same data (instead of querying from the database again).

 Tight Coupling in the Code

The term “tight coupling” refers to a high degree of dependency and linking between the entities/processes involved in a project. When developing TIBCO BW based projects; services should be kept as much loosely coupled as possible so that any future changes can be done with least possible disturbance in the overall picture.

For example; If your TIBCO project is interfacing with n number of upstream systems and you are using same schema structure in a single XSD file for all the interfaces; any changes if required for one interface; will impact all other n-1 interfaces as well as all interfaces are tightly coupled due to same XSD being used.

Hard coding of the data should be minimized as much as possible by utilizing the Global Variable options. Any configuration information if hard coded within TIBCO processes; result in unnecessary rework for any changes required in later stages. For input configurations of any activity; Schema elements should be preferred over specifying Complex Elements directly so that future changes are easy to handle.

Any global variables used for run-time configurations should also be set at service level if multiple services are made part of a single EAR. Keeping such variables at individual service level won’t disturb other service(s) using the same global variable if changed for one service.

However; re usability should not be compromised just to reduce the coupling. Any resource in the project which can be re-used for multiple processes, services or interfaces; should be utilized.

 Lack of Modularity in the Code

Another element counting to the poor performance of a project is redundant un-modularized design of the project. If project resources are not duly separated into re-usable modules; It results into introduction of large chunk of duplicate and redundant code which leads to overall degradation of the performance and code quality.

When designing TIBCO BW based projects; project resources should be proerly modularized based on their usability, interfaces and systems connectivity and other correlation factors. For example; If you are developing a TIBCO BW project which is interfacing with a billing system, a CRM system and a warehousing system; you should divide the processes/services in your project in a way like below:

* CRM Inbound Module

* CRM Data Handling Module

* CRM Outbound Module

* Billing Inbound Module

* Billing Orchestration Module

* Billing Outbound Module

* Warehouse Inbound Module

* Warehouse Outbound Module
* Common Auditing and Logging Module
* Exception and Error Handling Module

 

 Poor Architectural Decisions

Like any other project; TIBCO BW based projects also suffer mainly from the poor design decisions taken at architectural level as all underlying development and deployment level decisions are mainly governed by the high level architectural decisions taken at the project level.

Selection of inappropriate messaging mechanism; inefficient decision regarding flow of information between different systems; flawed decisions regarding deployment topology, wrong infrastructural estimates and wrong choices of associated additional tools and technologies are the key contributors towards architectural failure of any TIBCO BW based project.

Based on the estimated flux of data flow, possible addition of any additional systems to the information system, frequency of future business/architectural changes in the overall enterprise and business needs regarding throughput of the systems; decisions should be made with thorough analysis.

Whether EMS or Rendezvous should be chosen for message communication; whether SOAP services should be considered or REST services; ADB Adapter should be selected or normal JDBC activities are enough; ActiveSpaces based caching is required or not; synchronous communication is needed or asynchronous mode of communication can also work; reprocessing mechanism is required or not; etc. are some of the example key architectural decisions which count greatly towards a TIBCO BW based project’s success or failure.

 

Improper Logging and Auditing

The biggest pain for a support resource is inability to find the root cause of any failure case. For the entire flow of a service request in TIBCO BW Code; if logging and auditing is not implemented properly; It becomes a big challenge to exactly find out the reason of any request failure. In order to enable proper tracking of the requests flowing in and out of a TIBCO service; not only errors and exceptions should be logged properly but also; proper auditing should be done for the requests at different checkpoints.

For example; If your TIBCO Based service is responsible for taking request from a CRM system and then it is responsible for validating the request, handing it over to a charging system,  getting response back from the charging system and updating the CRM system back with the final response; auditing should be done at each and every level starting from reception of the order to the final response handling.

Exceptional scenarios should also be logged properly with meaningful log messages which are understandable for the operational resources.

 

Inefficient Deployment Settings

No matter how smart you have developed and designed your project; If the services are deployed with improper settings; things won’t go right. Deployment of the services in a domain is a critical decision for which sufficient resources must be made available depending on the data traffic and business needs.

Deploying the applications in fault tolerant and load balanced mode with sufficient memory and CPU resources, with appropriate process configuration parameters (MAX JOBS, FLOW LIMIT, ACTIVATON LIMIT etc.) is a prime contributor towards the smooth and efficient running of the services in the production environment.

 

The list of performance measures doesn’t end here but I conclude here to keep the post to a reasonable length. I hope this post will help you to understand all these performance measures involved in any TIBCO BW project.

 

Ajmal Abbasi

Ajmal Hussain Abbasi is a TIBCO Consultant By Profession with more than 6 years experience in TIBCO products. He has extensive practical knowledge of TIBCO Business Works, TIBCO Spotfire, TIBCO BE, EMS and TIBCO ActiveSpaces. He has worked on a number of highly critical integration projects in Telecom sector by using his skills in Tibco Designer, Adapters, TIBCO EMS, RV, Administrator, TIBCO BE, TIBCO ActiveSpaces etc. Ajmal Abbasi is also experienced in developing solutions using Oracle PL/Sql, Linux and Java. You can contact Ajmal Abbasi for Consultancy, Technical Assistance and Technical Discussions.

More Posts - Website - Facebook - LinkedIn

2 thoughts on “Top Reasons of Poor Performance of A TIBCO BW based Project

  1. khushboo

    Hi,
    I have a few queries on your this post:

    1. In you below paragraph you have mentioned that for large data we must use Process in Subset option. But what is the benefit of using this option other than its usefulness in filtering out unrequired data? This can be done through the JDBC query also if we tune the query to get only that data which we require for processing.

    “When using JDBC Query activity to fetch huge number of records from database; Process in Subsets option should be used and in subsequent activities; proper grouping should be used to iterate through the records in an efficient manner”

    2. You below paragraph indicates that we must not use the same XSD if we have multiple interfaces, i.e., if multiple systems are accessing 1 service. But if we change the interface for each system then the reusability of the service will be removed. In this case we will have to add a new interface each time a new system wants to access my service, this will increase my coding time and the service wont be reusable anymore.
    For example; If your TIBCO project is interfacing with n number of upstream systems and you are using same schema structure in a single XSD file for all the interfaces; any changes if required for one interface; will impact all other n-1 interfaces as well as all interfaces are tightly coupled due to same XSD being used.

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *