Well, the question asked was “What are the differences between EAI and B2B”, and it seems that there is a lot to the topic, so i will start off by defining the purpose of EAI and B2B (with a few of my opinionated opinions thrown in!). I absolutely agree that there are similarities, particularly in terms of approach between EAI and B2B, meaning that using webMethods for both purposes can certainly work. But in this discussion, i will highlight the areas that force me to conclude that they are not only different, but so fundamentally different that their co-habitation within one framework is (in my opinion) just the coincidence of two java based companies looking for a way to survive the March 2000 stock market crash. That isn’t to say that the merger was bad for either company, in fact, in some senses, the ActiveWorks framework was less efficient than the current wM developer (see ‘Active Versus webMethods’, below), though the relative efficiencies of each approach is beyond the current topic.
At a high level,
The purpose of EAI is:
1) application level command and control
2) application level information propagation
and the purpose of B2B is:
1) conductance of inter-business transactional agreements and enforcements
EAI – command and control
EAI systems can be used to effectively signal and control remote systems. This is a very under-used aspect of EAI, but still a very legitimate use for the technology. By signaling remote applications, EAI can be used as a distributed or centralized application controller (or more appropriately as a mediator to a distinct application controlling system). It is effective at this, because a prerequisite for system control is the ability to observe that system, a capability well within the scope of EAI. That is, an EAI infrastructure can be set up to minimally monitor other applications, and then respond intelligently and send command signals to those systems. The old Active Software adapters were a good example of this. The adapter established two BrokerClients, one to listen for runtime data, and the other to accept command signals – in effect, ActiveWorks used ActiveWorks to communicate information about ActiveWorks to ActiveWorks. Great job Active! – one of the most beautiful meta-systems i have ever seen (sic – second to Smalltalk’s meta-layer, of course [wink]).
So why don’t we use EAI as a command and control system more often?
The simple answer is that companies don’t hire us to do this much. Also, as webMethods developers, we have moved away from the idea of using EAI to control remote systems. I argued strongly to keep the Active Software nomenclature “event”, which conceptually encompassed this broader usage of EAI, much more so than “document”. An event is an active triggering agent (ok, even Active never really had good event objects, they were really more data structure than control structure, but that is another story), while a document is a passive entity. The point is that we have allowed ourselves to merely think of EAI as “application level information propagation”, instead of being open to the idea that the technology can be used for more. We are taught how to integrate data, and since this is what we learn from webMethods, this is all we use it for.
Note: In my opinion (see the biological analogy discussion below), using EAI as a command and control system must be kept completely separate from an EAI implementation designed to propagate information, for performance and potential interference reasons.
EAI - Application level information propagation
Propagation is another primary usage of EAI, and the one that i will focus on to highlight the differences between EAI and B2B. Propagation is facilitated well in webMethods by pub/sub (e.g. using the Broker), built in latching support, and “in flight” data transformation capabilities.
EAI – propagation as a whole is NP complete
One of the difficulties of data propagation is that an integration system is necessarily a distributed asynchronous/synchronous messaging system, which has drastic ramifications for transactional integrity. Suppose for example, a single source publishes information to five target systems. The first three systems accept the information, but the fourth fails. Now we have a mess. It is unlikely (i.e. basically impossible) that the first three systems support two phase commit. Should we roll back the first three systems, or try to correct the error and commit to the remaining two systems. Can any of the first three systems roll back at all? Transactional integrity under these circumstances can be exceptionally difficult to attain or guarantee.
Active Software couldn’t solve this problem (neither can anyone [at this time], it is NP complete – a problem characterized by being not algorithmically solvable in polynomial time), but they did try to alleviate customer fears by creating the ATC (Application Transaction Coordinator [was this formerly known as the AIC? i can’t remember now]). Every customer that knew about the ATC believed and hoped that it was a transactional integrity guarantee for solving problems like the mess described above. In fact, it was merely a propagation coordination tool (a completely separate topic) with simple data correction facilities.
The mess above can get worse too: what if the application is processing order-specific information, and queuing it at a high rate (e.g. one transaction per second). How can we solve this type of error in a production system? The answer is we do the best we can. Note: in my opinion, we should be generally more diligent about informing our customers of the potential issues they might see in high transaction multiple targeted integrations.
Anyway, something more nefarious is occurring that the above example helps to show. webMethods EAI does not even qualify as a Group! This means that an inverse is not guaranteed to exist (Who cares about this [simple] math giberish? We better, if we are to successfully architect webMethods EAI integrations: follow along, please!).
Under normal algebraic rules, the inverse is part of our daily lives and forms our basis for understanding mathematical integrity. As a simple example, take:
5x + 3 = 13
We can simplify (re-arrange things without changing the truth of them) using inverses. The additive inverse of 3 is -3, so we can simplify the equation (remove the 3) by adding 3-1 to both sides of the equation thus:
5x +3 + -3 = 13 + -3 à 5x = 10
Now, the multiplicative inverse (normal algebra is a ring - rings have additive and multiplicative inverses) of 5 is 1/5, so we can multiply both sides of the equation by 5-1 without changing it, but the resultant formula will be more depictive in terms of x:
FONT=Times New Roman * 5x = (1/5) * 10 [/font]à x = 2
This is how we trained our mind to work and solve logical systems. The problem is that webMethods doesn’t work that way because it has to deal with every other application type in existence. Some of those applications are sophisticated in terms of their acceptance behaviors (e.g. Oracle), and some are terrifyingly primitive (e.g. mainframe, my_legacy_app_that_i_built_thirty_years_ago). Integrated applications that cannot roll back mean that:
ApplicationState1 + data1 – data1 != ApplicationState1
Even in systems that can rollback, we are not guaranteed commutatively, that is:
ApplicationState1 + data1 + data2 – data1 != ApplicationState1 + data2
That is, the system behavior is not a group, and not Abelian which implies that if we use our normal mathematical backgrounds to think about webMethods EAI we will be mistaken. Logic still applies, but not the usual Group theory, Integral Domains, Rings, and Fields that we normally use to assess and make decisions about how to construct systems, and equally importantly to predict how these systems will behave. I will write this twice: to predict how an EAI system will behave, you must recognize and manage the severe limitations of the mathematics of EAI.
…(continued in Differences between EAI and B2B part2)