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.

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.
 
 
 
 
 
 

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

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

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.