TIBCOmmunity Server Syndication Feed

BE rule patterns vs templates

pvincent@tibco.com — Fri, 21 Nov 2008 14:20:00 GMT

One quite common qu we get is "how" or "when" will BE support the idea of "rule templates", whereby one separates some conceptual prototype rule with runtime instances, and in particular manage these instances separately.

Interestingly, the idea of "production rule" (see http://tibcoblogs.com/cep/2008/11/17/the-value-of-production-rules/ ) somewhat gives you "rule patterns" or "rule templates" for free.

Consider a rule

declare EventA if EventA.cost > 113 then doSomething( EventA).

You can templatize this easily enough to:

declare EventA if EventA.cost > dataPolicy.cost then doSomething( EventA).

But note that dataPolicy could be an object instance, or a scorecard entry, or... another declaration:

declare EventA, dataPolicy if EventA.cost > dataPolicy.cost then doSomething( EventA).

Now you will compare any EventA with any dataPolicy instance. Clearly you will likely have particular dataPolicies for various event types, and can add that as a "join" in the rule condition.

In this way you are effectively using the power of rule declarations to create rule patterns and templates. And of course, as the policies or strategies you are creating for your "master rule" are defined as concepts, then they are also easy to update and manage, for example as "update events" at runtime, or even through running heuristics (expert rules) or S+ analytic functions.

Top / header Checkbox on Matrix Column

dhwang — Tue, 28 Oct 2008 19:14:08 GMT

Simply adding HTML for a checkbox to a matrix Column header results in a checkbox that doesn;t get checked or unchecked in response to mouse clicks.

The challenge in the implementation is that the Matrix headers are designed to use the mousedown event to reorder columns and trigger sort behaviors. This means that the click event on the checkbox gets intercepted and canceled by the header and clicking on the checkbox never causes the checkbox to get checked.

To address, use the mousedown event on the checkbox to toggle the checked state (see code below). It is also critical to cancel event bubbling to stop the Matrix from sorting and reordering when the user's intention is to check or uncheck the box.

Lastly, note that the checkbox described below is XHTML compliant. This is important if you intend your app to ever run on an XHTML Web page (and it's simply good practice these days to author well-formed HTML).

 <input type="checkbox" 
onmousedown="this.checked = !this.checked; jsx3.gui.Event.wrap(event).cancelBubble();" 
onclick="jsx3.gui.Event.wrap(event).cancelBubble();return false;" 
onmouseup="jsx3.gui.Event.wrap(event).cancelBubble();" />

Darren Hwang (channeling Luke Birdeau)

Some useful Builder usage tips

dhwang — Thu, 09 Oct 2008 23:59:02 GMT

Reassign the "ctrl+s" hot key to "Save & Reload".(Goto Builder Menu "Tools" > "IDE Settings" > "IDE Hot Keys" , locate "Save & Reload" , double click and press CTRL S keys)

Quickly locate a component using "ctrl+click" on a GUI control in the canvas to select the component on the "Component Hiearchy" palette. (NOTE : the matrix component swallows the "ctrl+click". So in order to click select a matrix control, you must do the clik on the little grey patch under the vertical scrollbar where the events bubbling is not cancel)

Float the "Component Libraries" palette to give more display area for the "Properties Editor" and "Event Editor" palettes. (This is really just a preference, but I find it useful since you can see more of the properties at a glance).

Update

Context sensitive help press keys "alt+F1" while focusing on the component you like get help on (For example, component hiearchy tree) to open the HTML Doc page on the component.

How to disable rows, columns or cells edit masks in a Grid matrix.

dhwang — Wed, 15 Oct 2008 23:27:20 GMT

To disable edit masks for the entire row in a Matrix - Grid, set event property "Before Edit" with following code fragment (follwing sample disables the non-always on edit mask ,such as menu and select/combo. Always on edit mask, such as checkbox and button, are disabled by the jsxdisabled="1" in the record row. E.g. <record jsxid="1" jsxtext="Alabama" jsxdisabled="1" /> ).


if (this.getRecord(strRECORDID).jsxdisabled == 1) false;

To disable edit mask of an entire column in a Matrix - Grid, set event property "Before Edit" (Following code disables the "comboColumn" by evaluating to false in "Before Edit" event handler).


if (objCOLUMN.getName() == "comboColumn") false; else {jsx3.log('EVENT: (jsxbeforeedit). Record: ' + strRECORDID); }

Follow similar logic to disable edit mask of a cell based on different factors such as the value of the another column. In "Befor Edit" event property, this code


if (this.getRecord(strRECORDID).status == "Deployed" && objCOLUMN.getName() == "selectMachine" ) false;

will disable the "selectMachine" cell (column) if status cell (column) has the value "Deployed".

Useful tools for AJAX application development

dhwang — Tue, 14 Oct 2008 00:09:00 GMT

These software tools provide additional assistance in developing tests:
1. For Internet Explorer, download and install the Developer Toolbar. This tool
provides a very useful DOM Explorer function that allows you to inspect the
generated HTML markup at runtime.
Microsoft Internet Explorer Developer toolbar

2. Download and install Visual Web Developer 2005 Express Edition. This web
IDE provides syntax highlighted editing for HTML, XML and JavaScript.
Visual Studio Express

3. For Firefox, the best debugging tool is

Firebug Addon

4. For Firefox, you can alternatively download and install the Web Developer toolbar.
Firefox Developer Toolbar add-on

5. Best IDE editor for Javascript is IntelliJ IDEA, but you need to pay license for this

6. If you use the Eclipse IDE, install the JSEclipse plug-in for JavaScript editing.
JSEclipse Editor plugin

7. Alternative free editor, try Notepad++ which supports more than two dozen different programming language editing. Also download the FunctionList plugin which will show you list of methods and class in an easy to access side pane.

Notepad++

How to do row highlight of Table row on mouse over

dhwang — Thu, 09 Oct 2008 23:53:25 GMT

Table Spyglass Event property enter this code.


var id = this.getId() + "_" + strRECORDID; 
if (id) document.getElementById(id).style.backgroundColor="yellow";
if (document.getElementById(this.lastid)) document.getElementById(this.lastid).style.backgroundColor=''; 
this.lastid = id;

FAQ: What standards does BE / TIBCO CEP support?

pvincent@tibco.com — Mon, 15 Sep 2008 08:46:14 GMT

Occasionally we get questions like:

"Which industry and open CEP/BRMS standards (incl. emerging standards) are supported"

This is a little misleading as "standards" can be used to describe a number of things. CEP is "too new" to have anything "standard" in event processing, other than event definitions through say JMS (TIBCO EMS). But there is interest there.

In BRMS, the only "relevant" standards are the rule representation standards:

- OMG PRR - currently in beta - provides a framework for representing production rules for Rete and sequential script engines (ie covers both BE rules and rule functions)

- W3C RIF dialect for PR (PRD) - currently in draft - provides an XML interchange format for use between rule engines and in other XML docs like XBRL, Acord, RosettaNet, etc

- OMG SBVR provides a standard for describing business languages, and is relevant to natural language (but not necessarily automatable) descriptions of things like policy rules and business constraints

- OMG OCL is a constraint language used to specify constraints in UML diagrams

TIBCO is actively involved in the first 2, as these are also useful for rule-driven CEP like BE.

On CEP Query Languages it is worth noting that most query languages are based on SQL. BE's is based on OQL, an object-database standard development of SQL.

Of course, BE also supports standards of UML State Models and UML Class (Concept) models. The main area to be aware of is that "OMG support" normally also implies the OMG metamodel infrastructure - recording or importing XMI, handling MOF, etc. We don't pay too much attention to these though as most UML tools have their own interpretation of XMI, and are therefore not "interchangable", making it somewhat useless as a standard. Eclipse EMF is probably the best thing to be compatible with here, and the open source EMF team are of course interested in standard Eclipse editors for SBVR and PRR...

Thanks to Mukesh for the blog suggestion.Thanks to Mukesh for the blog suggestion

The eternal argument - BPM vs SOA

mramakri — Mon, 08 Sep 2008 23:31:02 GMT

I was covering the BPM space for a while before I moved on to manage the SOA stack here at TIBCO. The repeat question I get asked from both sides of the fence is: what is the difference between BPM and SOA? It’s an interesting question with a myriad responses and I choose to start my series of blog posts here on this community, on BPM, on this particular topic.

BPM and SOA are two sides of the same coin, as one of my colleagues pointed out to me, in my early days at TIBCO. Another more concrete response – if 80% of your process is people centric and 20% systems centric, you are looking at BPM vs the other way for SOA. I’ve heard this one too – it’s all about the user, a more business centric user trying to define a process at the business layer needs BPM vs a technology-deep user defining a process at the systemsy layer, who needs SOA. I like this last one best: BPM is about extracting high level turnkey business processes and managing them as though they were assets in your organization, while SOA is about rewiring the IT plumbing in your infrastructure for efficiency and reuse; You need those business process assets to leverage your IT plumbing and you want your IT plumbing to always align with business process requirements.

While all these responses hold truth in them, the more I’ve worked in both spaces and closely followed them, I realize that the lines are blurry which is why people ask this repeat question. And when you think about it, a user wants to talk about finding a solution to the problem he has on hand, rather than be bombarded with three letter acronyms such as BPM and SOA. Vendors such as TIBCO are in a unique position where we have eons of experience in both areas that can leverage across product offerings so we cater to exactly this: provide the solution rather than a piece of technology that should be very carefully mapped to the problem.

Another point that is imperative: for the most successful SOA implementations, BPM and awareness of business processes is critical. Only then can you quantify and measure metrics against the business as well as design for the business, rather than just tweak and churn against technology for efficiency. If you read Paul Brown’s book on: Succeeding with SOA (highly recommend), he touches on this all through, where he talks about realizing business value through architectural design.

And the counter, at every point that a business process leverages the underlying infrastructure, a good design will allow it to reach out to an SOA implementation so there is always a loose coupling between BPM and SOA; rather than to hard coded systems interfaces to your business process. This loose coupling between BPM and SOA will allow one layer to change independent of the other. When you re-provision your IT infrastructure, you don't want to bring down your business processes, do you?

It’s important for BPM and SOA offerings to work well together – the BPM offering should be able to call out to the SOA services and orchestrations at design time with a few clicks of the mouse and work seamlessly at run time. And an SOA process should be able to call out to BPM centric processes without extensive work or rewiring. The best designs are from experience in both areas. My take, stick to your expertise be it SOA or BPM but learn extensively on the other area and attend conferences in both areas so you know what's happeninig on the other side of the fence before you sit down to design your architecture.

The takeaway is that BPM and SOA are interdependent and for good reasons, the best implementations leverage the strengths of both while keeping them decoupled.

In my next blog post, let’s look at what end to end business process management is all about before we dive off into the world of process modeling. Business process modeling is my favorite area where I’m hoping to explore with this audience, efficient process design using Business Studio. You can take a quick peak at Business Studio by visiting our developer center: Business Studio Developer Center

Why ActiveMatrix?

mramakri — Mon, 08 Sep 2008 20:41:35 GMT

This morning, when I was getting the latest version of ActiveMatrix installed on my laptop, it occurred to me that I have presented on ActiveMatrix and shown off the products more times than I care to remember and yet have never sat down and tried to explain in written words - why ActiveMatrix and how to use it.

Welcome to my first blog posting on this community. In this series of posts, I want to introduce you to TIBCO’s smashing suite of SOA products, ActiveMatrix, that I promise will slowly grow SCA tendrils around your fingers and have you addicted to building true-blue SOA. In particular I want to show you how easy to use and powerful ActiveMatrix Service Grid and ActiveMatrix Service Bus products can be. I want you to see that it doesn’t matter if you dream in Java or .net or C++ or Ruby or BusinessWorks or …, how you can share code, manage your operational environment and design your enterprise application across the heterogeneity while staying in your own realm. I want you to see how governance works in ActiveMatrix and how that sets apart the applications you build.

But first I’m going to assume you’ve never met ActiveMatrix before and draw a high level picture before we get into the juicy nitty-gritties. I’m a geek at heart but do believe in a top down approach. We will land up exploring building composite applications and mediation services and custom stuff. If you are already a pro, you can always catch me a few posts down the road and we can engage in an active discussion on some of the more advanced topics and learn to use ActiveMatrix together for some of the more complex configurations.

So first…. Why ActiveMatrix for TIBCO and why now? TIBCO, as you must have heard if you have ventured to this blog, has been a leader in the SOA/integration space for eons. BusinessWorks, which has been our core offering for several years, is the basis for our SOA presence and was one of the first products to define SOA to be the way it is today. BusinessWorks has been used by thousands of customers as their SOA and integration backbone. SOA at its heart is all about reusability – if you have existing functionality in an application that can be used in several other applications in your infrastructure, how can you break it down into services that can be called out from these other applications? This is a simplistic explanation of what BusinessWorks helps you with, among a myriad other things. BusinessWorks is a super enterprise service bus – an ESB++ that helps you with service enablement and reuse, integration, orchestration, mediation and management.

TIBCO is a cool company that learns and grows with its customers. One of the primary things we heard from our existing BusinessWorks customers over and again were a few key core needs which forced us to perk up our ears and actively evaluate how we can make their lives easier. And hence was born ActiveMatrix.

What were these messages we heard from our customers?

It’s one thing to use an ESB and leverage reuse, and another to implement enterprise wide SOA and see returns on your investment and manage the complexity and ever present factor of change in IT. Implementing successful SOA involves Governance and SLA management, service virtualization, management of heterogeneity in the infrastructure, availability of a lightweight mediation layer, and the need to continue to leverage a product like BusinessWorks, and co-exist with other implementations of ESBs and SOA solutions, ... the list is endless.

But you do get the message. ActiveMatrix is a vision to provide a platform that your underlying infrastructure can leverage as a basis for resolving all of these IT issues. It should be possible to change governance and compliance needs quickly, skilled technology experts should be able to interoperate without needing to jump in and become experts in other technologies. It's imperative to scale, load balance and provide high availabilty across services quickly and reliably and preferably at runtime without down-time. The business user should not need to have to define business requirements and SLAs in spreadsheets and power point decks that get lost in translation with the technology implementation. Better yet, the SLA requirements should proactively be met without downtime.

Hopefully this paints a picture of the vision behind ActiveMatrix. This is just the tip of the iceberg. In the subsequent posts, we’ll discuss more of these concepts and how you can leverage them in the products with some hands on stuff.

While you are waiting on my next post, I’d encourage you to browse around on our developer network where you can get your hands on a couple of our products ActiveMatrix Service Bus and ActiveMatrix Service Grid: http://developer.tibco.com I’d love to hear your experience with installing these products.

BE 3.0 Distributed Support - FAQ

pvincent@tibco.com — Fri, 05 Sep 2008 14:08:51 GMT

In the dialog following a blog (BE vs any-other-BRE-with-JMS), a number of high-level points were discussed. The TIBCO responses are reproduced below for TIBCommunity viewing...

Original points made by Alan:

-. BE takes a co-operative agent approach (for co-operating components and event processing services)

-. BE supports high scalability (for parallelizing applications and eXtreme Transaction Processing)

Comparison with other BREs:

-. Infrastructure for co-operating agents using other BREs needs to be programmed manually (eg shared blackboard). Advantage BE.

- High performance and scalability is offered usually via the app server used by other BREs, and requires additional programming eg for load balancing. Advantage BE (where its automatic by default).

Response to other BRE capabilities

- Note that most BRE's could invoke another rule service (but that is far from sufficient to support an agent-based approach). The point is that the shared distributed memory model (shared Working Memory) is out-of-the-box in BE.

- Other BRE suppliers "both exploring" and "will integrate" implies that this is future for other BREs, but currently included out of the box with BE. Note that it is quite possible that a conventional BRE customer has done a custom integration with a high performance cache or data grid technology (like you thought of doing). Check out their Wall St customers...

Shared Memory

Shared vs Partitioned (working) memory: actually I believe you need both (so the data grid approach used by BE allows for this). For CEP, where scalability to load (/low latency) is required, controlled shared and non-shared distributed memory is a required. The sort of controlled distributed reasoning we tend to need is multiple disparate agents sharing a blackboard model.

BE Shared Memory: just a note to confirm that although BE (>v2) ships with Coherance to handle shared memory, it is architected to potentially support other types of data grid too.

Such data grids are an increasingly interesting alternative to expensive centralized database transactions, especially for CEP and knowledge-based applications.

Collaborative Agents

BE supports collaborative agents (either via event passing and/or shared memory / data grid).

For large data sets one would use different agents with different views of the blackboard / shared memory area (i.e. with access to different classes) and apply apply layered reasoning (different depths of knowledge / rulesets) to the events and event histories. The idea is to try and avoid the problem you tried to solve - i.e. here is a very large set of data to apply to a very large set of rules, all in one go, with a mechanism that allows for real-time complex event processing alongside more knowledge-rich, slower rule processing, to collaborate on solution. "Divide and Conquer" etc etc.

Note also that with CEP, I only want to process an event once, but I might want to process it against all other available data. The same rules are processing changed data (i.e. typically the new event, and any assertions / changes from the other processing agents). So there is no "waste of CPU cycles", and low latency is preserved with a small overhead of synchronizing data updates across WMs (as of course there will always be some overhead)...

Types of Agents by Memory and Process
There are 4 use cases that BE allows:

A - shared memory, shared rules = replication for throughput
B - different memory, shared rules = data partitioning to handle data volume
C - shared memory, different rules = co-operative agents working against the same information
D - different memory, different rules = independent agent.

Most BE users today are probably doing A (remember most TIBCO customers are large enterprises). The power of this architecture is in the combinations of A-D that you can use in the same distributed application. The design approach is to use C to handle application complexity, and D in a different agent set to provide processing of large volumes of information, and then A for necessary performance / failover support as required for B and C agents, with D probably providing internal BAM monitoring / checklisting.

Note that the event-driven approach also provides a slight paradigm shift over conventional rule engine usage, which assists with understanding the needs for partitioning...

Comparison of Rule Distribution Approaches

"If a rule engine can use index joins to pattern match, why send all the extra data? "
Remember for event processing, the "extra data" is an event at a time plus any inferences, so this could well be less than re-sending index information around.

"Replicating the full working memory is ideal for fault tolerance, but suboptimal for increasing pattern matching performance and throughput."
Of course, application reliability and uptime is as important to our customers as performance. Especially resilience in distributed systems.

"Replicating the full working memory is ideal for fault tolerance, but suboptimal for increasing pattern matching performance and throughput."
Ah - but the point is that the WM is partitioned too! As said earlier, performance will depend on the use case. We need to get PRR or RIF out of the door so we can have some decent benchmarks to prove this stuff in action (across different frameworks).

"replicating just the beta node indexes is much more efficient than replicating all facts"
Which is certainly true if you are replicating all facts on every (rule execution) cycle, as the Rete index represents a "compiled form" of the conditions dependent on those facts. But in BE ('s Rule Engine) you are:
(a) not replicating the entire WM on every cycle
(b) only replicating certain WM "as needed" (and even then, note that "notification of change" <> "replicate WM fact", and that not all WM will need to be shared anyway)
(c) due to the event-at-a-time nature of continuous, complex event processing, we are likely to be replicating small numbers of facts in any cycle anyway.

So any assumption that the
Performance(replication(index)) << Performance(replication(WM delta))
is, at best, very use case and implementation dependent - and in the case of CEP, where the WM delta for shared facts may be very small, this might not be the overhead some might assume...

"the engine first looks in working memory ..."
Since BE2.2, the strategy per class is set by the developer, for in-memory only, cache+memory (default), and cache-only (i.e. explicit retrieval) modes. This is for fine-tuning and performance reasons, obviously.

"data is divided into concept instances and event data"
Event objects are really just a special type of object (and with appropriate event classes). Events are characterised by their Time To Live (how long they live in the Event Processing Agent, whether rule-driven or otherwise), and what "consumes" them. The latter is important because the registration of "consumption" can be used by the middleware layer to determine a successful "delivery" of the event. If the system has a catastrophic failure before event consumption, the event can be consumed by another agent instead.

"data tends to be relatively static, so it makes sense to put it in an in-memory database"
The in-memory role is primarily for reduced latency. CEP is about comparing new events with past events, so the latter must be easily (and speedily) accessible, whilst be capable of being updated as needed with information from the new events.

"asserting the same facts in multiple rule engines will cause each engine to go through the pattern matching process"
In the general sense, yes, but remember that raw / external events are only ever delivered to a single agent (for processing, and thence assertions / updates to any shared facts).

"Does BE integrate coherence Maps for the node memories, or is it simply using coherence as an external datastore?"
The latter, as sharing Rete node information would not be useful for other Event Processing Agent types (ie non-Rete) that are contributing to the solution.