Modularity, the obstacles

Posted by: Kostas in Modularity on Print PDF

Kostas

Our goal has been to achieve real modularity in a web application. This means, the capability to take an implemented module and to directly call and use it, not only inside the same application twice, but also inside another web application.

If you analyze this situation, it is far from trivial. We think therefore, until now, it has never been implemented or achieved. In order to re-use the module of the other application, the following large obstacles arise:

  • The current app tries to access another app with its own user management access control
  • The current app is deployed inside its own context, doesn't have deployed environment available of the other app

To overcome these obstacles, the current application should be able to transparently logon to the other application. It should be possible to hold an active session to that application, so that it gains access rights but also statefull access to this  application.

To guarantee the correct execution of the module to be re-used, the only way is to execute it inside the context of the other application. This means, after logging in to that application, the module has to be communicated to the other application, and to be started and executed in that context.

That is exactly what UltraCore can do for you. It allows you to login to another UltraCore application and establish a session for that application, including creating the normal session cache with state for that application. After that it allows you to execute an arbitrary class of that application inside its own context. It then returns the result to the current application, so that it can process the data. Because the other application could have been implemented on another server, it allows also remote access for this procedure. To increase the modularity capabilities of the framework, it also allows to send a local class implemented in the current application, to the other application for execution. It will deploy it transparantly realtime inside the other application. In this way, you can actually extend a system from remote, without the need to deploy anything new on that system.

All this functionality is provided from the RemoteApplication class in the UltraCore framework.