Last modified by Lars Braubach on 2013/09/30 14:46



For an overview about active components and the Jadex technology please refer to the documentation section.

component.png Component Programming Model

The programming model of Jadex is based on the notion of active components that are conceptually based on SCA (service component architecture). This allows for designing an application as hierarchical decomposition of components interacting via services and thus helps making complexity controllable. Active components extend SCA in several directions as it is intended to work in concurrent and dynamic distributed systems. The concurrency model of active components is further explained below. Support for dynamic distributed systems is based on distribution transparency, i.e. active components mask many of the complexities that typically arise when dealing with internetworking and remote sites. To cope with network changes, i.e. vanishing or newly appearing nodes and services, active components employ SOA (service oriented architecture) concepts for dynamically searching and binding services of other components. Details about the concepts of active components and the programming model can be found in the user guide.

concurrency.png Concurrency Model

On a first look, active components resemble SCA components to a high degree, but in constrast to SCA they have been built on basis of a concurrency model. This concurrency model considers each component as potentially concurrent to every other component, i.e. a component is a building block of concurrency. In this way active components resemble multi-agent systems (MAS). Each active component is not only a passive service provider, but may also provide additional behaviour that is executed autonomously. In Jadex the behavior of component types can be descibed in different flavors, e.g. with pure Java, as BPMN (business process modeling notation) workflow or even as cognitive BDI (belief-desire-intention) agent as described in the AC user guide, BPMN tutorial and BDI user guide respectively. The concurrency model of Jadex is based on the actor model and enforces strict state encapsulation between components, i.e. parameters are passed by copy (per default). Furthermore, Jadex includes techniques to ensure that components and their services are executed only within the logical component thread. This leads to a single thread model for each component and faciliates the programming considerably as no low-level synchronization primitives like semaphore or monitors need to be used.

interaction.png Multiple Interaction Styles

Active components are primarily based on method-call interactions as this is the common technique in object orientation. For many application cases it will be sufficient to rely on this scheme but there are cases in which interaction patterns might be more complex than request-response or binary data should be transferred. Complex interaction patterns can be realized in two different ways. On the one hand Jadex supports new kinds of structured return values (e.g. intermediate futures) that make it easy to handle cases in which a called service wants to announce more than one return value in the sense of subscription schemes. On the other hand developers also can implement interaction protocols based on asynchronous messages, which is the most flexible but also the most complicated variant. Jadex also offers a high-level API for binary data transfer via streams. Developers can e.g. pass a stream as parameter within a service call so that one side can read from it and the other side write to it. Streaming does not require a special communication infrastructure but uses the normal Jadex transports so that no extra ports need to be opened. 

prototyping.png Fast Prototyping

In case you want to design and implement a prototype of a concurrent and/or distributed application, Jadex helps to quickly devise a running software. Fast prototyping is supported on the programming as well as on the infrastructure level. On the programming level, e.g. Java annotation based components (called micro agents) can be used, which offer a simple and straight-forward implementation approach that is immediately accessible for Java developers. In addition, the Jadex distribution comes with many built-in services (e.g. for email communication or web service invocation) and example applications that may be exploited for your own systems. In addition, with Jadex simulation support it is possible to quickly transform simulations to real applications keeping the implementation largely the same. On the infrastructure level, Jadex follows a configuration by exception approach and thus can be run in many environments without initial configuration changes. In networks of nodes Jadex platforms are capable of finding each other automatically and form an overlay network. Once you have a prototype of your application up and running, you can start adjusting the configuration to better suit your needs, e.g. by introducing security properties or concretizing communication channels.

configure.png Dynamic Reconfiguration

Applications realized with Jadex consist of components that mimic business functionalities on different levels. Having componentized the functionality makes it possible to clearly understand what services are used and provided by components, which is the basis for dynamic reconfiguration. At runtime, components can use services of other components, whereby these services can be statically bound (as typically in SCA) or dynamically bound (as possible in SOA). Dynamic binding means that a component that requires a services, implicitly performs a search for the underlying service type and may rely on any service provider that is available in the logical overlay network of the application. This also allows for relocating component instances on other network nodes (by recreating a new component instance) based e.g. on performance or capacity utilization aspects.

security.png Platform Security Model

The Jadex platform provides a simple to configure yet powerful and flexible security mechanism based on shared secrets. The security mechanism ensures that your platform and data is protected against access from other platforms. Only platforms that share a common secret (a platform password or a logical network name and password) are allowed to discover and invoke services of each other. Per default a platform generates a random password at first startup and hence is automatically safeguarded against potential malicious attackers. The employed security mechanism is based on digests that are built with standard secure hash functions.   

integration.png Technology Integration

Technology integration is crucial for usage of the platform in different environments. Jadex addresses integration on different levels:

  • At the programming level Jadex heavily relies on standard languages like Java and XML and thus facilitates the usage of integrated development environments like eclipse. 
  • At the platform level Jadex offers direct support for integration with RESTful as well as WSDL based web services. The integration approach allows for exposing Jadex services as web services and also enables wrapping of existing web services as Jadex component services. This renders the barrier between the different technologies invisible and makes it possible to use Jadex as part of other types (e.g. SOA) of infrastructures.
  • At the build and deployment level Jadex uses Maven. On the one hand the structure of Jadex itself is assembled as different maven modules and on the other side Jadex is published regularily in the Maven central repository. Furthermore, Jadex also offers functionalities to automatically start components from specified artifacts, i.e. Jadex can automatically download a maven artifact (including its dependencies) and start a component from it.

simulation.png Simulation Support

The Jadex platform supports simulation transparency, which means that applications can be written that are executable as simulation as well as real time application. The application code is completely independent from the execution mode so that one can use a simulation control for determining at runtime if an application should be executed as simulation or not. Thus, simulation transparency makes it easy to prototype certain kinds of systems and explore their behavior in controlled simulation environemnts. After it could be ensured that the system delivers the desired functionalities the core code can be kept and it can be embedded and executed in a real environment. In addition, Jadex also offers a standard environment model called EnvSupport that can be used to setup virtual 2d and 3d environments as described in the corresponding Env user guide

overlay.png Overlay Network

In order to support distributed applications it is a necessary prerequisite that platforms on different nodes get to know of each other. Using Jadex the nodes will automatically discover each other using the platform awareness mechanism. Awareness will work in local intranets as well as in networks with internet access. Jadex provides an extensible set of discovery techniques that are used to find other hosts. Of course, it can be customized if awareness should be used and if so which discovery techniques are active. The awareness mechanim leads to an automatic overlay network formation of platforms that can reach each other. From a component perspective, the current overlay network structure is largely hidden as components just use required services of service providers located in a logical scope. 

tools.png Tool Support

The Jadex distribution comes with extensive tool support. Regarding the development of active components, using standard integrated development environments like eclipse is recommended. Additionally, small optional plugins (like the ADF checker) may be used to enhance error reporting for XML models. The configuration of the Jadex platform is supported via a GUI tool called JCC (Jadex Control Center). The JCC is plugin based and offers many different tools for management and debugging purposes. They include e.g. the Starter to start, supend, resume, and stop component instances, the TestCenter to execute unit like component tests, and the Security Tool to manage platform passwords and logical networks. The tools are described in detail in the tool guide.

Created by Alexander Pokahr on 2012/09/17 13:55


Copyright (C) 2002-2016 Lars Braubach, Alexander Pokahr, Kai Jander