[Ace-users] A C++ IoC component framework for CORBA, Event, DDS, RTC, and SDR/JTRS-SCA applications

kjin101 at gmail.com kjin101 at gmail.com
Wed Nov 14 17:51:03 CST 2007

PocoCapsule/C++ for CORBA: An IoC component framework for CORBA, OMG-
Event/Notification, OMG-DDS, OMG-RTC, and JTRS-SCA/SDR applications

Like it or not, CORBA is commonly known as a complex technology. The
superfluous CORBA Component Model (CCM) further raised its entry
barrier significantly. The CCM has in fact became a synonym of
dreadful costs and risks, inherent vulunerabilities, and vendor lock-
in. Its Avalon and old pre-3.x EJB resembling techniques (such as the
component context injection, invasive control, and home interface)
have largely been abandoned by the mainstream software industry for
years. Yet, as the old tactic of "if you can't convince them (users),
confuse them!", CCM is still constantly being hyped with buzzwords
such as "leading edge", "advanced", "distributed", "real-time", and
"mission-critical". The favorite equation in defending the heaviness
and complexity claimed that advanced component frameworks for
distributed real-time missioncritical applications were unavoidably to
be heavy, complex, and certainly not meant for average developers and
domain users. Their simplifications could only yield functionality
stripped inferior editions.

In J2EE world, the inversion of control (IoC) and plain-old-java-
object (POJO) component model has been proved to be much superior than
the heavyweight old pre-3.0 EJB with regarding to straightforwardness,
flexibility, and openness. Although their significance had long been
downplayed in the CORBA world by CCM advocates, there is no reason
that these techniques and a plain-old-C++-object component-model could
not be applied in CORBA C++ applications.

PocoCapsule/C++ for CORBA is a framework for component-based C++ CORBA
applications. This framework is based on the open source (under GPL)
PocoCapsule/C++ IoC-and-DSM framework. As out-of-the-box solutions, it
includes assembly and deployment models for the following CORBA

* CORBA POA server applications. (see examples/corba/poa-server)
* OMG-Event/Notification Service. (see examples/corba/event)
* OMG-DDS applications.           (see examples/corba/dds)
* OMG-RTC applications.           (see examples/corba/rtc)
* JTRS-SCA applications.          (see examples/corba/jtrs-sca)

Based on the plain-old-C++-object support of the underlying IoC
container (e.g. PocoCapsule/C++ IoC), the PocoCapsule/C++ for CORBA
does not enforce any propritary component model. Instead, any C++
objects, such as CORBA remote/local object stubs, POA servants
(extended from IDL skeletons), native TIE servants, etc. are all valid
components. Therefore, it doesn't introduce any CCM-like compliant
barrier and is able to seamlessly and immediately reuse legacy
implementations of POA servants, event suppliers/consumers, DDS
writters/readers, and JTRS-SCA devices/resources, etc. without cost
and resky refactoring and reengineering.

In additional to above out-of-the-box solutions, facilitated by the
underlying domain-specific-modeling (DSM) support (of PocoCapsule/C++
DSM), the PocoCapsule/C++ for CORBA can easily be extended and
customized to support diverse of user-defined application assembly/
deployment models (DSM) that express specific applications at higher
abstraction levels (see <http://www.pocomatic.com/docs/whitepapers/

PocoCapsule/C++ for CORBA is designed with realtime and embedded
applications in mind. Although able to seamlessly support ORBs and
component implementations that heavily use templates, exceptions, STL,
RTTI etc., the PocoCapsule/C++ for CORBA runtime itself is completely
free from these sophisticated and heavyweight C++ sugars. Therefore,
it is able to be portable to the most rigorous realtime/embedded
systems (such as VxWorks and Symbain) where only the primitive and
lightweight C++ features are feasible. For typical applications,
PocoCapsule/C++ for CORBA has a rather small footprint (~200Kbytes on
Linux and VxWorks), negligible generated code, and absolutely zero add-
in performance overhead and realtime latency/jitter.

Contrary to the CCM equation, PocoCapsule/C++ for CORBA is able to
significantly lower the entry barrier of C++ CORBA application
developments without sacrificing, but rather strengthening, its
features and productivity. The learning curve of PocoCapsule/CORBA
(together with DDS, Event/Notification, RTC, and JTRS-SCA, etc.) is
not only shorter than CCM, but also shorter than plain old CORBA, and
even shorter than socket API. As some of CORBA advanced but hard to
use features become easily accessible, PocoCapsule/C++ for CORBA
virtually extends the feasible feature set of the underlying CORBA
implementation to average business logic developers.

With its low entry barrier, superior features, non-intrusiveness and
flexible customizability, PocoCapsule/CORBA is an ideal framework for
enterprises to build mission-critical CORBA applications in a starting
small and thinking big incremental approach.

* <http://www.pocomatic.com/articles.html>

* <http://www.pocomatic.com/docs/cpp-examples/#corba>

* <http://www.pocomatic.com/products.html>

<prod at pocomatic.com>

More information about the Ace-users mailing list