Posted by: Brigitte in Untagged on
May 15, 2010
Welcome to the Infocenter of ULTRA4. Here you can find up to date background information on our products, ideas, concepts and thoughts. We hope you enjoy reading it. You can react to all articles by sending a mail via our contact form of the website.
Posted by: Jesse in Untagged on
April 6, 2010
The UltraCore realtime engine supports pushing realtime events to the browser. The technology behind the realtime implementation uses a dedicated connection between the browser and the server. The dedicated connection is used to stream realtime events directly to the client. The engine can work both in streaming and long polling mode (Comet style). The best possible protocol is automatically determined by the framework, depending on the browsers capabilities. Implementing realtime applications is as simple as implementing a realtime event handler, and generating realtime events that should be processed. The event listeners can push GUI updates to the browser, by just returning a modified GUI component. Example realtime event listener:
page.subscribeToTopic("topicName", new RealtimeListener() {
public Component liveEvent(Object eventData, Page currentPage) {
Posted by: Kostas in concepts on
March 23, 2010
UltraCore is a unique end-to-end platform for the development of multi-tiered Rich Internet Applications that has been developed by ULTRA4 on the basis of its many years of project experience in J2EE and application development. The platform is steadily extended and improved based on the experiences and needs of real-world projects.
UltraCore is based on the J2EE architecture and provides a cross-layer abstraction from the J2EE development model. In this way, it "hides" the complexity of J2EE (EJBs, Servlets, JSPs, etc.), while leveraging its advantages to a maximum extend for the developers: With UltraCore the developers become in effect business logic architects rather than being web programmers.
In order to unfold all its features, UltraCore pre requires only a J2EE web container. Therefore, it can run for example on top of the JBoss application server (or any other application server) but also without an application server but just with a servlet container like Tomcat.
Posted by: Kostas in UltraCore, RichData, MDA on
June 30, 2009
UltraCore has based itself on a new form of Model Driven Architecture. This aims to provide a domain constraint model at the code level.
Thus, within the UltraCore approach, the actual PIM model of an MDA approach moves to the code layer. The code layer directly allows for definition of constraints on the data. This is achieved by having a MetaData implementation on the data, via a flexible constraint API. With this, the data carries its own meta data with it, and thus is fully self describing.
This approach has the huge advantage, that processes that operate on the data, can directly inspect the constraints, and operate automatically because of this knowledge. For example, a validator object can inspect mandatoriness of the fields, and then check these fields for values.
Posted by: Jesse in Untagged on
June 17, 2009
With presentation templates, UltraCore achieves the capability to define a main application layout, that will be applied to all or certain application pages. The goal was to be able to define a presentation layout in plain HTML and CSS, without the need of any dynamic code inside. Also it would be possible to re-use templates between different applications, in this way creating a web template market, where different templates can be directly applied to an application, to create a completely different layout. By implementing this, we thought the final solution should be as powerfull as the Joomla templating mechanism, but should be language neutral. This means no code inside the template.This also allows the templates to be viewed directly inside a web browser.
We achieved the templating solution by introducing the following concepts:
- A template can include a dynamic UltraCore component, by defining the componentName attribute inside an HTML tag.
- We defined a naming convention for the standard components of an application
- The template engine should transform template resource URL's from local URL's to online URL's automatically
The first concept was implemented, by letting the template engine scan for tags with the componentName attribute. If such tags exist, the value of the componentName attribute is used to lookup the component in the current Page. If found, the component will be dynamically inserted. If not found, the html tag that defines the componentName is removed from the html code. In order to create fully styleable menu's, the following conventions where also defined:
Posted by: Kostas in Modularity on
June 4, 2009
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.
Posted by: Jesse in UltraTelecom, TTS on
June 4, 2009
ULTRA4 has developed a full featured realtime text to speech server, as part of its UltraTelecom platform. The server is a multi threaded environment that can handle large amounts of simultaneous requests for text to speech transformations. It is build in Java and can therefore run on most operating systems. It works together with our UltraTelecom IVR features. An IVR menu can directly make a call to the TTS server that will produce a dynamic sound file and can be played live back to the caller. The TTS server supports templating in order to mix predefined text with variables retrieved from for example the database. The templating solution also provides conditional statements as well as loop and other advanced programming statements. The TTS server can run either on the same server with a telephone IVR server, or on a different one for maximal distribution of load.
The low level TTS converter that is being used, is pluggable in order to support all kinds of TTS providers. At the moment, we provide standard Loquendo and Cepstral engines. These engines support all major languages among which English (UK), English (US), German, Greek, Italian, French, Dutch etc.
Posted by: Jesse in UltraCore, Modularity on
June 4, 2009
With modularity at the presentation layer, we mean the capability to re-use a dialog or comibination of dialogs inside the same or another application. The major obstacles/challenges for such functionality are:
- Presentation layer logic is connected to business logic, which is strongly dependent on its deployment environment
- How to return control to the caller of the re-usable dialog
With UltraCore, we allready managed to execute logic of one application inside the context of another application. We extended this capability with a so called GUI proxy feature. This means, a certain GUI, receives its events within the current application, but can forward the events to a proxy GUI running inside another application. This completely removes the first obstacle, allowing the GUI events and thus the business logic, to run in the context that it has been made for.
The second obstacle has been overcome by introducing the concept of return points. This can be seen as a stack oriented approach. A caller can register itself as a return point. Then it calls the re-usable GUI logic. This GUI logic doesn't have to know anything about the caller's implementation. It will just return the control to the last registered return point. It can also issue a loose coupled event on the object that will take over the control. In this way also allowing for return of feedback from the dialog. The caller can decide to implement a listener for the result or not.
Infocenter
