How IEM systems
made ERP outdated >

Why Ultimate  / for developers

The intoxicating freshness of the 2013 autumn release and the complete absence of the ancient rudiments allow us to offer the following honeycombs to the developers working with the Ultimate Solid platform.
Note: the below-written text is purely about the differences from our competitors. The general, although important, properties (such as the full fledged 3-tier architecture, compile-time validation, the integrated environment for the UNIT-tests or error  tracking/handling) are not mentioned there.

Rich datamodel

The data model proposes  to describe the real world objects, their properties and interactions, by using  the rich data model.
The platform uses the "above-the-object" model of the representation – this allows to  simplify the understanding of the existing processes, development and testing.
In particular, the  rich data model means that you can develop an application by formulating it as  a unified whole in the directory terms or in the terms of documents. The directory  of goods is all-in-one: the data in the database, the forms for the list of  goods, the option of the individual record editing, the right to access it, and  so on.
Just compare it with  the SAP or Axapta data model – we have separate data conversion objects, separate tables with the data, separate authority rights and their  verification. There is a million of variants of how to present a standard list  of goods, and one must remember how to implement the same task in different  places.
When working with  a rich data model, it is always clear where and how to implement the directory. Certainly, you can still operate on the model used by the older fellows –   “if Monsieur knows his perversions”.
Click here for details.


Ultima  Businessware® is written in the latest version of one of the most modern  programming languages — C# 5.0. Its most advanced features are used – LINQ and  Asynchronous features.
LINQ allows to  formulate the complex queries to the business objects. The language and its  compiler are actively developing.
The client application uses asynchronous extensions of the C# language, consequently increasing the user-friendliness.
The platform facilitates the development of asynchronous applications, automatically  generating the asynchronous wrappers to call the methods of the application  server, and notifying the developer of synchronous queries.
SAP uses the ABAP – the procedural language with OOP-elements. There are neither the functional  extensions, nor the asynchronicity support. The situation in 1C is absolutely  the same.
Things are slightly  better in Axapta – but only because there is something you can do in C# over  there.
The situation with the in-built X ++ Axapta language is the same – the procedural language with the OOP extensions.
Click here for details.

native Oracle Database

What about the  Oracle DBMS with regard to the segment of the relational databases used for business applications? 
You can work with Oracle or you can work with everything else. Use all the richness of choice, as they say.
Ultimate Solid is originally designed to work with Oracle Database and maximize the use of the most intellectual and productive functionality of this DBMS: attaining, as a result, the maximum brevity, clarity, and productivity of the applications.
The competitors use  the DBMS as a notebook.
An easy-to-imagine  comparison: some old ladies use the iPhone, given to them by their grandsons, to record phone numbers, but they would still call to their old companions  using a bakelite phone of a stone age era.
1C, SAP and Axapta  DO NOT use the basic features of any modern DBMS as triggers or stored  procedures. As they say, it is unbelievable-but true.
It is more than that.
Even the referential integrity is checked by the application itself, and not by the database although the latter can do it much better (like a disposable lighter is way  better fit for making fire than a tinder and a flint). Naturally, this approach makes it not just but incredibly easy to write a code that will destroy the  referential integrity (not EVEN mentioning the performance of the system) – which is why this happens with surprising regularity.
Actually, this is the example of how to remove tonsils via a colorectal maneuver; this is the  essence of the typical hereditary vestiges left from those prehistoric times, when the ancestors of our today's competitors were working with the equally squalid rudimental databases, or, like 1C – with the DBF files.
Click here for details.

ORM (object relational mapping)

The transformation  of the relational data into the business objects of the system is completely transparent to the developer – just add water follow the LINQ query.
For each object the platform independently generates the necessary queries to create a database object. The system will prompt the options for the object creation, suitable for different cases of use – when the access is frequent, or when it is necessary  to record changes and other things.
Compare it with the SAP approach: it simply knows how to get back the rows of a table and save the back – even the access checks are on the application developer.
Axapta “boasts” the same situation, with a few exceptions.
Click here for details

Transaction hell

The manual transaction management is a well known headache. It is easy to catch the  exception, write it in the log and "accidentally" record the transaction later! A developer using Ultimate Solid will have to work hard  to do that: he will actually need to hack the system and perform queries to record the transactions, like SQL-queries.
SAP, Axapta and 1C use manual transaction control. That said, it is possible to  write a program that will save the object only partially. Such instances  regularly occur in actual practice.
For  example, there used to exist a certain Foo function that performed certain  actions and did the “commit” action at the end.
Then  it was decided to use this function from another function named Bar (so as not
to duplicate functionality). So, if an exception occurs in Bar after a Foo call, then the part of the actual work of the Bar function (what was done in Foo)  will remain in the database, and the rest will be "rolled back. "
The  result will be the data integrity loss.
To  discover the source of the awry data appearance is often a task of incredible  complexity. The sources can hide themselves for months, mysteriously floating around  guided by the moon phases, i. e. just existing in the form of the "slightly  incorrect data in the reports. "
Or not  that slightly.
And  they have to be edited after the discovery. This editing usually will be done
manually: one can only blanche at the sight of those hundreds, thousands and
millions of documents.
Click here for details

rapid application development/prototyping (RAD/RAP)

The rapid application  prototyping is ensured by means of a system objects’ graphical modeling; or – a  wizard.
Immediately after the object is created by a developer, the platform will automatically generate  a form for the list of the objects’ records (with all the tools for the data sampling, the selection of columns, sorting, buttons for creating and deleting records, etc. ) and the record edit form (which, of course, will open from the list of records by double-clicking).
And you can immediately start describing the business logic and further stages.
The development of the complex screen forms can be done in parallel with adding the business logic content – by different developers.
None of our distinguished colleagues on the market does offer ready forms to the developers — they have to use their hands everywhere. The fastest way to do it with the editors’ help is by using Axapta and 1C (it doesn’t take long to distribute the component on the form, but it needs to be done, and it will take 15 minutes to create a most simple  directory), but the most fun happens, traditionally, in SAP: one must still write  a program there — to prepare the data, convey it into a grid, draw a shape, and  do other monkey business.
Click here for details

version control

Our own version  control system forms an organic part of the Ultimate Solid platform. This allows you to have multiple versions of a configuration simultaneously, and a separate developer operates each of them; the platform ensures no conflicts will happen when changing the objects of the system. There is no need to further advertise this truly invaluable convenience to the developers who have the experience in the implementation of major applications within a team.
Ultimate Solid uses a distributed version control model — each developer makes changes in its branch (the analogue of a working copy or a local repository in other version control systems), and, upon the work completion, introduces the changes to the main branch (and periodically "tightens" the changes introduces by other developers).
A close model of work is implemented by Mercurial, Git, and a number of other industrial version control systems.
The application server can work with any of the selected versions (on any branch), whereby the end users can access the functionality by very small portions and with a high frequency of updates. Thus, the notorious continuous delivery — is the organic (and the main) development methodology for Ultimate Solid.
Let's see what the colleagues offer.
SAP, 1C and Axapta DO NOT have a version control system – in the sense that you can run the application server on the specified version. Axapta offers the possibility to upload/download a configuration, but it has about the same relation to the full-fledged version control as a barge with some field guns to a battleship.
This is naturally followed by the failure to make any development using a production system – in the absence of a version control system it becomes necessary to have at least 2 separate databases – the development and production systems. The always creative SAP PR specialists named this graceless curiosity a “three-mandate system landscape. " It is inspiring, that’s right! And, at the same time, we don’t have a damn clue. Just the thing for a naked king.
At the same time more or less flexible and reliable tools for the changes’ transportation are implemented only by SAP (one of those rare cases where the creation of the [excessively] gloomy Teutonic genius is somewhat ahead of its competitors).
Axapta ignores the need to transfer not only the data structure and the application code, but also the application data. Transfer with your hands, my dear comrades. The obvious consequence – the developers regularly forget to transfer, and transfer only when the users claim the errors. The similar situation is at 1C.
SAP supports the transfer of the application data, but (as usual)... If the "combat" system has a table containing, let’s say, four billion entries, the straight adding a mandatory field to this table will make almost any database experience a hang-up. Almost any administrator of a not-too-ancient DBMS knows how this can be done in several stages and without any problems for the users. However, SAP doesn’t know how to do that.
Click here for details

internationalization support

Ultimate Solid provides aids and built-in tools for the internationalization of applications. Each user can see the data and use the interface in their own language.

SAP and Axapta use  labeled files to solve a similar problem. Any text can be replaced by a label, and then the label can be transferred and used in the hand-manufactured forms.
Ultima  Businessware makes sure that the automatically generated forms of directories, documents and reports use the translated names directly, so the developer does  not need to get sick of using those labels.
Click here for details

printing mess

If you want to thoroughly follow the directions of the garbage-accumulating unholy  bureaucratic assemblies of our God-protected Fatherland, then the multi-ton  junk paper piles will be the visible result of any organization’s work.
In addition to the convenient editor of the actual printed forms (supporting all modern features such as export to PDF, Excel, HTML and other formats, intersectional bands, tables, watermarks, barcodes, including 2D) Ultimate Solid also provides you  with the intelligent tools for managing your printing system.
The experienced developers repeatedly encountered errors in the print drivers that made the application crash.
The direct (initiated by conventional means) printing overloads the communication channels that can be critical for the VPN-channels between the remote offices.
Using conventional tools also requires a system administrator to perform a large amount of monkey tasks by connecting network printers for each network user, as well as the distribution and updates for the permissions to use them etc. The name of the printer is often prescribed directly in the program code; it must be connected on the
application server, and if the server gets changed, all the printers need to be re-created on the new server.

The printing system implemented in Ultimate Solid hides these problems by:

  • providing a means for the asynchronous printing
  • ensuring the delivery of the print jobs (maintaining the  priority) to the printer
  • making the recovery after the drivers’ failure
  • keeping records of pages printed by users
  • optimizing the traffic
All this is  available to the developers through the one and only Print method().
SAP has a certain printers’ virtualization system, while 1C and Axapta have nothing.
As for the printed forms’ editor – a relatively decent one (minding the squalor of the competitors) belongs to 1C. The international market monsters (in this segment) are so monstrous and international, that people, in most cases, prefer to use the long-suffering Excel format.

Сlick here for details

Development using WinForms & DevExpress

Ultimate Solid allows to implement any complex form  using the. NET WinForms tools and the extensive library of the DevExpress (and/or  any other) components.
The forms are drawn directly in the VisualStudio — the most convenient development tool, in our point of view.
What do our colleagues offer?
1C —   an integrated form editor with a limited set of components.
Axapta —   an integrated form editor with a limited set of components. A form can be drawn in the VisualStudio, too. However, due to the amount of the ridiculous restrictions imposed by Axapta, its use is actually impossible.
SAP – an integrated form editor with... you guessed it. There is a variant with using the SAP Portal, where you can draw in HTML, but such development s are scarce.
In all the cases the developer has to use a set of limited 20-30 components and has no access to any sophisticated components that are in the DevExpress and other modern libraries.
Click here for details

SOAP/REST support

The platform supports (on an application server level) the integration via SOAP and REST protocols with the serialization in XML or JSON.
A developer does not need to know any details about the implementation of these protocols; it is sufficient to describe the functions to receive and return the corresponding objects in the DTO (Data transfer objects) graphical interface and to implement them in C#.  
The rest will be done by the platform.  
1C and Axapta implement the subject (Axapta – SOAP only) through the use of the enjoying the well deserved love of people  MS Internet Information Server. SAP has a separate specially trained component for this, and to understand the administration of this component will bring the same headache as the desire to get to the core of any other thing in SAP.
Click here for details

Android direct support

The full-fledged iOS  support is in the research phase, due to some of its features and the dubious  prospects of the industrial demand. The WinPhone support is not considered due to  the undoubted lack of any demand.
Ultimate Solid allows you to develop the client applications for  Android with a proprietary interface.
When developing the mobile applications, the proprietary (as opposed to the universal SOAP / REST) protocol of the interaction with the application server has a number of advantages – encryption, compression and binary serialization are used.  
Axapta makes you simply use the web services. This is inconvenient: the web services in Axapta are heavy, and there is no support for the development.
SAP SUDDENLY presented a platform for the development created by Sybase. Apparently, the rights for the free inherited junk that SAP got after buying the decaying Sybase zombie made the company just give something unworthy to its clients. However, that platform also suggests using the native development tools and communicating via web services.
The platform for the development on the target device was detected neither here, nor there. The comrades from 1C heroically ported  their own development environment  both on Apple and Android. We did not go too deep in the details, to be honest, but because of the way the this environment is constructed (which, apparently, is the consequence of the orientation at the qualification of a typical 1C programmer, the 1C mobile application interface for iOS will be similar to the 1C program, and not to the program for Apple devices. The same is true for Android.
Click here for details

logging, log miner

Ultimate Solid implements its own flexible logging device: the administrator can configure the logging down to the individual table fields. As a result, the amount of the logs gets drastically reduced.

Last but not least — the most important advantage of the Ultimate Solid platform, which has no direct relation to it — the direct link of the partners’ developers with the platform development team.
As a consequence — the (common for the market) reaction period lasting for months (at least; and up to never) is reduced to days, and in the case of some critical bugs —   to hours.

And what is the result?

The result is that, based on the reliable statistics accumulated during the multiple years of experience, the developer’s productivity at Ultimate Solid is 10 times higher than the same at the SAP application.
We were unable to compare it with Axapta directly; however, by comparing the data from both of the above text and the (available to us) confirmed experience of implementing similar projects in Axapta, we assume the advantage is 3–6 times in favor of Ultimate Solid.