close
Login
Thursday, 19 January 2017
Oct 21, 2016
The German energy provider Westnetz has chosen ULTRA4 to implement
read more
Jan 01, 2016
ULTRA4  extends its innovative Meeting and Collaboration platform,
read more
Aug 20, 2015
ULTRA4 develops a new credit card workflow system for Airplus ...
read more
May 17, 2013
UltraCore has been
extended by generic
layout-algorithms ...
read more
February 4, 2013
ULTRA4 has been
contracted by one
of the leading German ...
read more
June 20, 2012
ULTRA4 is implementing
an interactive map
application for the ...
read more
June 6, 2012
The cooperation between
Syna Ltd. and ULTRA4 cont.:
logistic planning system...
read more
March 10, 2012
Syna Ltd. has chosen
ULTRA4 to develop a
circuit switching ...
read more
September 1, 2011
ULTRA4's Web conferencing
and Meetings solution
Join2Meet is online...
read more

Towards a universal architecture for Business Web Applications
What is UltraCore™ and what benefits does it bring to web development?
Why UltraCore?
Comparison UltraCore™ with: Java EE & PHP, .NET, Spring, Ruby on Rails, Seam, Wicket

Towards a universal architecture for Business Web Applications

Choosing the appropriate architecture for your application is key. A lot of projects are in trouble because the development team did not apply well-known industry architecture best practices. Software projects using modern technologies such as Java, J2EE, XML, and Web Services are no exception to this rule.

In order to avoid this type of problem it is frequently recommended to use patterns that range from the classic Gang of Four patterns, Java patterns, to EJB design patterns, the Sun's Core J2EE Patterns catalogue and much more. Furthermore it is recommended to avoid so-called antipatterns; these are patterns that have been consolidated in the literature after thorough study of project failures.

Applying well-known industry architecture best practices, avoiding practices that have led to failures in the past and steadily improving your architecture from project to project is for sure an advisable way to go as an IT architect. It is though not enough in order to really optimize your development.

Why?

First, because your architecture will remain proprietary, regardless of how good it is. Second, because it will reflect the experience of your projects only and will miss the experience of the multitude of projects that take place outside your department and your company. And third, because your architecture will evolve from project to project in a way that developers working on different projects will have a different knowledege status and will in many cases not be able to maintain code written by others.

In other words, because it is very difficult and time consuming to achieve an industrial-like software development with a proprietary architecture.

That’s the point at which we start:

With the UltraCore™ Model Driven Architecture (UltraCore™ MDA) we provide IT architects with a universal architecture for Business Web Applications featuring the following unique concepts:

  • Platform independent source code model
  • Fusion of plain data with meta data
  • Use Cases structured according to the prepare-validate-execute pattern
  • Wizards (Stateful Use Cases)
  • Event Listeners
  • Abstract stateful GUI components

The UltraCore™ MDA has been proven to be successful in a variety of projects from the domains Telecommunications, Banking, Finance, Insurances, Marketing and Media, Shipping and Logistics with different development teams. It follows a pragmatic Modefl Driven Architecture (MDA) approach that guarantees the agility of the software development process: While classic MDA defines system functionality by using a Platform Independent Model (PIM) that is written in a Domain-Specific Language, UltraCore™ moves the PIM to the source code level, featuring in this way the unique concepts of “no automatic code generation” and “platform independency of source code” (c.f. background article The MDA approach of UltraCore).

UltraCore™ MDA is provided together with UltraCore™; that is ULTRA4's end-to-end platform for the development of multi-tiered Business Web Applications.

Find out more ...

 

What is UltraCore™ and what benefits does it bring to web development?

UltraCore™ is ULTRA4’s end-to-end platform for the development of multi-tiered Business Web Applications. Built on top of the Java EE platform, it hides its complexity while leveraging its advantages to a maximum extend.

Applications developed with UltraCore™ can be accessed not only via all modern Web Browsers but also via fixed-line telephones, mobile phones and other mobile devices like PDAs, smartphones, etc.

The first major milestone release was released in January 2007, with further milestone releases in March 2007, January 2008 and December 2008. The current version is 2.5.0.

UltraCore™ brings to web development superior modularity in all three tiers. By featuring the unique concepts of Session Syncing, Remote Application Execution, Page Chaining/Return Points and UI Proxy, UltraCore™ removes the obstacles of code reusability found in almost any other platform/framework currently available on the market (c.f. background articles Modularity at the presentation layer and Modularity - the obstacles).

Furthermore, UltraCore™ follows a pragmatic Model Driven Architecture (MDA) approach that guarantees the agility of the software development process: While classic MDA defines system functionality by using a Platform Indepenent Model (PIM) that is written in a Domain-Specific Language, UltraCore™ moves the PIM to the source code level, featuring in this way the unique concepts of “no automatic code generation” and “platform independency of source code”. Find out more ...

Apart from these benefits, UltraCore™ provides a large list of further features that optimize web development like no other platform/framework currently available on the market.

Find out more ...

 


Why UltraCore™?

There are currently many web development platforms/frameworks available in market. Widely accepted platforms are Java EE, PHP and .NET; widely accepted frameworks are Spring, Ruby on RailsSeam, Symfony and Wicket.

Choosing a platform/framework is one of the major decisions you make as a web developer/IT manager, and will influence a lot of your development choices.

You have limited budget and timeline? You need to hit production yesterday? Or do you simply want to create better web applications designed for the future in an optimal way?

We want to explain why UltraCore™ is the optimal choice you can make in all these cases.

Using one of the platforms Java EE or PHP in a "pure" form (i.e. without combining them with any framework or library) is not a real option for web developers, since these platforms provide strongly technology-oriented but not application-oriented APIs.

Pure Java EE provides for example the technologies Java Database Java Database Connectivity (JDBC) for the Data tier, Enterprise Java Beans (EJB) Component Model for the Logic tier and Servlets combined with Java Server Pages (JSP) for the Presentation tier.

The web developer who decides to work with pure Java EE is therefore strained not only to learn all the "bolts and nuts" of these extremely complicated techniques, but also to develop at the level of database connections, SQL queries (by keeping control over transaction commits and rollbacks), plain Java code (within non-intuitive EJB and Servlet source code outlines), as well as plain html with Javascript.

This is a totally unsatisfactory situation for the developent of demanding web applications: The APIs mentioned so far are far too low-level in order to properly support even the elementary features of a modern web application (i.e. data validation, functional and data security, wizard-like processing, notifications, alarming, logging, batch processing, etc.).

The situation is similar also for PHP, with the additional drawback, that web applications written in PHP do not provide unlimited scalability and clustering capabilities, features that are inevitable for future-oriented applications.

Furthermore, PHP is a hybrid procedural and object oriented programming language with legacy problems: a lot of procedural code parts, that are confusing or even lead to security leaks, cannot be removed due to backwards compatibility.

As far as .NET is concerned, it surely comes with more out-of-the-box high-level application-oriented libraries than Java EE and PHP. It though nevertheless remains at the level of "bolts and nuts", especially as far as the integration of all these libraries to a consistent overall architecture is concerned: The web developer has to invent his/her own generic architecture on-top of the libraries in order to avoid a "patchwork" of heterogeneous components.

Furthermore, working with .NET and its libraries in en affective way, requires expensive educational courses with doubtfull impact on the effectivity/efficiency of the development process.

Using frameworks in combination with platforms is for sure the better option for the development of Business Web Applications.

In the following we compare each of the most prominent fullstack frameworks currently available on the market with UltraCore™. We take only fullstack frameworks into consideration, in order to have a just comparison.

UltraCore Spring

Highly structured source code model

Introduces a highly structured source code model that implements out-of-the-box all ever-recurring processing patterns of modern business applications.

In this way the programming effort is minimized (only non-default logic is programmed) and the scattering of processing logic over various redundant source code segments is prohibited.

No specific source code model

Does not impose any specific source code model. This means that developers have to come up with their own code structure in order to cope with the ever-recurring processing requirements of modern business applications.

This causes extra programming complexity and makes it difficult to produce source code that can survive staff changes.

Developer operates with application logic-oriented concepts

Operates with concepts related directly to the application logic like “Use cases”, “Wizards”, “Functional- and data security”, “Data Validations”, “Data formatting”, “UI Components”, “Dialog chains”, “GUI Styling”.

The web developer concentrates in business logic and the design of an appealing user interaction instead of tackling with the “bolts and nuts” of specialized technologies.

Developer operates with highly technical concepts

Operates with highly technical concepts like “Inversion of Control”, “Aspect-oriented programming”, “Transaction management”, “Model-view controller”, etc.

The web developer has to understand and apply correct these technical concepts instead of concentrating in business logic and the design of an appealing user interaction.

Convention over configuration

Is based on the principle of 'Convention over Configuration', meaning that almost no configurations are needed, and little amount of source code is needed to come to good results. UltraCore includes a lot of high level functionality implemented at all layers, that can function as default implementation, allowing to override specific parts of this.

Need for extensive configuration

Requires large amount of configurations and relatively large amount of written software to come to a result.

Data model based on metadata (Rich Data Objects)

Implements the important Rich Data concept, establishing a centralized data meta data oriented architecture, allowing many processes to be automated like e.g. validation, security, generation of user interface elements from data, etc.

No metadata in data model

Has no model for meta data definitions.

Code-oriented business logic approach

Allows you to code all functionality, rules, evaluations in pure java within a highly structured, intuitive understandable source code outline, enforcing in this way the concentration of business logic in one place and providing easy readability of business logic implemented by others.

Configuration-oriented business logic approach

Moves a lot of logic to xml files, introducing maintenance problems, error signaling problems etc. Developers must go through non-intuitive xml-file semantics in order to understand business logic implemented by others.

Modularity in all tiers

Introduces strong modularity concepts, allowing even re-use of complete frontend and backend modules in other projects. Introduction of re-usable dialog chains, remote execution of code in another projects context (with live class submit), context dependent handling, register GUI part for Data types, etc.

Limited modularity

Has no such modular concepts.

Web templating for applications

UltraCore introduces as one of the first frameworks real web templating for applications: Any highly designed web template (for example a template of a content management system like Joomla, Liferay, etc.) can be directly used as user interface of an application that is built on top of UltraCore: With the unique concept of UI Component Injection, the original web template can be seamlessly extended in order to receive parts that contain application functionality (e.g. forms, grids, buttons, tabs, menus, breadcrumps, etc.). The power of the web templating design industry can thus be directly untilized when developing a Business Web Application.

No web templating

 

 

UltraCore Ruby on Rails

Presentation layer is connected to business logic

Presentation layer is connected to business logic via the data/meta data.

Presentation layer is disconnected from business logic

 

User Interface Component Model

Provides a component oriented GUI model, with event listeners for user interaction. Has been proven to require less code to produce a case. More efficient also for state management. Produces a better quality structure of source code.

Model View Controller

Is based on model view controller concept, requiring more effort to build a case as compared to the component oriented object model of UltraCore.

No need for code generation

Prevents the need for code generation, by having features implemented in the UltraCore API. It is better to use generic features via the java interface, so that you have the capability to override certain behaviour dynamically. It is also better to economize on generated source as much as possible. Large amounts of generated source create a maintenance problem. If a large part of this is never altered, why should it exist?

Extensive code generation

Uses a lot of code generation / scaffolding to easily gain a lot of functionality and rapidly achieve results in the beginning phase of a project. This is however bought with a higher burden of later adjustments due to changing requirements. In the worst case there is a risk, that adjustments are set up wrong and the code becomes incompatible with future versions of the framework.

No dealing with html tags & JSPs

Requires no generation of JSP's / View pages, by providing a GUI Java object model, that has its standard renderers out of the box available. By including aggregation components like e.g. containter, almost any layout can be build easily, and completely dynamic, based on java rules.When using the templating mechanisms, no new tags have to be learned. Binding components to the view page takes place by defining a comonentName attribute for any html tag. No real logic or java is needed inside the template.

Dealing with complex formatted tag-oriented definitions

Requires you to implement view pages, where you deal deal with complex formatted tag oriented definitions, as well as mix this with Rails language statements. Complicates embedding of conditional parts and parts that have to be included multiple times. Complicates also the ability to re-use user interface, almost making this impossible.

End-to-end automated testing

Provides end to end testing framework, allowing you to play a full animated test in a web browser, testing through from browser to presentation logic to backend and database. At all levels, since it is framework driven, the test framework can produce detailed information regarding failures, and will report it nicely in a structured excell list, including exact source location of occurence (if exception thrown).

No automated testing

No comparable testing capability is available.

Modularity in all tiers

Introduces strong modularity concepts, allowing even re-use of complete frontend and backend modules in other projects. Introduction of re-usable dialog chains, remote execution of code in another projects context (with live class submit), context dependent handling, register GUI part for Data types, etc.

Limited modularity

Has no such modular concepts.

Web templating for applications

UltraCore introduces as one of the first frameworks real web templating for applications: Any highly designed web template (for example a template of a content management system like Joomla, Liferay, etc.) can be directly used as user interface of an application that is built on top of UltraCore: With the unique concept of UI Component Injection, the original web template can be seamlessly extended in order to receive parts that contain application functionality (e.g. forms, grids, buttons, tabs, menus, breadcrumps, etc.). The power of the web templating design industry can thus be directly untilized when developing a Business Web Application.

No web templating

UltraCore Seam

Flexible data model with runtime-programmable metadata

Does not use any annotations, in order to create the most flexible data model. Uses a meta-data model that can be manipulated completely at runtime, allowing the most advanced requirements to be implemented easily.

Inflexible data model without metadata

Wide use of annotations causes inflexible code model, that cannot deal with advanced requirements (example, what if a fields mandatoriness depends on a business logic java rule, or a security role assignment).

 

Fast application loading

Loads only necessary logic, is lightweight and fast.

Slow application loading

Has a bad performance and is very heavy (initializes slow) to use, not only because of its use of Hibernate.

Automated scoping of data

Fully automates the scoping of data for you, managing the data lifecycle based on high level concepts, such as dialog chains.

No automated data scoping

Requires you to think about the scope of the data behind the web pages.

Presentation layer is connected to business logic

Presentation layer is connected to business logic via the data/meta data.

Presentation layer is disconnected from business logic

No dealing with html tags & JSPs

Requires no generation of JSP's / View pages, by providing a GUI Java object model, that has its standard renderers out of the box available. By including aggregation components like e.g. containter, almost any layout can be build easily, and completely dynamic, based on java rules.

Dealing with complex formatted tag-oriented definitions

Requires you to implement view pages, where you deal with scope of the data, and deal with complex formatted tag oriented definitions. Complicates embedding of conditional parts and parts that have to be included multiple times. Complicates also the ability to re-use user interface, almost making this impossible.

End-to-end automated testing

Provides end to end testing framework, allowing you to play a full animated test in a web browser, testing through from browser to presentation logic to backend and database. At all levels, since it is framework driven, the test framework can produce detailed information regarding failures, and will report it nicely in a structured excell list, including exact source location of occurence (if exception thrown).

No automated testing

No comparable testing capability is available.

Modularity in all tiers

Introduces strong modularity concepts, allowing even re-use of complete frontend and backend modules in other projects. Introduction of re-usable dialog chains, remote execution of code in another projects context (with live class submit), context dependent handling, register GUI part for Data types, etc.

Limited modularity

Has no such modular concepts.

Web templating for applications

UltraCore introduces as one of the first frameworks real web templating for applications: Any highly designed web template (for example a template of a content management system like Joomla, Liferay, etc.) can be directly used as user interface of an application that is built on top of UltraCore: With the unique concept of UI Component Injection, the original web template can be seamlessly extended in order to receive parts that contain application functionality (e.g. forms, grids, buttons, tabs, menus, breadcrumps, etc.). The power of the web templating design industry can thus be directly untilized when developing a Business Web Application.

No web templating

UltraCore Wicket

Offline viewable web templating

Provides a view templating solution that allows to bind components to the view without introducing code into the templates. The templates can be also directly viewed in the Browser, because UltraCore has the capability to transform realtime the template url's from local to online url's.

Web templates can be viewed only online

Provides a view separation technology that allows to bind components to the view easily without introducing code into the templates. The static template cannot work also directly in the browser, because wicket provides no realtime transformation of the url's in the template.

Data model based on metadata (Rich Data Objects)

Implements the important Rich Data concept, establishing a centralized data meta data oriented architecture, allowing many processes to be automated like e.g. validation, security, generation of user interface elements from data, etc.

No metadata in data model

Has no model for meta data definitions.

Presentation layer is connected to business logic

Presentation layer is connected to business logic via the data/meta data.

Presentation layer is disconnected from business logic

No dealing with html tags & JSPs

Requires no generation of JSP's / View pages, by providing a GUI Java object model, that has its standard renderers out of the box available. By including aggregation components like e.g. containter, almost any layout can be build easily, and completely dynamic, based on java rules.When using the templating mechanisms, no new tags have to be learned. Binding components to the view page takes place by defining a comonentName attribute for any html tag. No real logic or java is needed inside the template.

Dealing with complex formatted tag-oriented definitions

Requires you to implement view pages, where you deal deal with complex formatted tag oriented definitions. Introduces new non html wicket tags. Complicates embedding of conditional parts and parts that have to be included multiple times. Complicates also the ability to re-use user interface, almost making this impossible.

End-to-end automated testing

Provides end to end testing framework, allowing you to play a full animated test in a web browser, testing through from browser to presentation logic to backend and database. At all levels, since it is framework driven, the test framework can produce detailed information regarding failures, and will report it nicely in a structured excell list, including exact source location of occurence (if exception thrown).

No automated testing

No comparable testing capability is available.

Modularity in all tiers

Introduces strong modularity concepts, allowing even re-use of complete frontend and backend modules in other projects. Introduction of re-usable dialog chains, remote execution of code in another projects context (with live class submit), context dependent handling, register GUI part for Data types, etc.

Limited modularity

Has no such modular concepts.